Greyhounds.WebApi

<back to all web services

FindRoundStats

import 'package:servicestack/servicestack.dart';

class RoundStatus
{
    static const RoundStatus Pending = const RoundStatus._(0);
    static const RoundStatus InProgress = const RoundStatus._(1);
    static const RoundStatus Ended = const RoundStatus._(2);

    final int _value;
    const RoundStatus._(this._value);
    int get value => _value;
    static List<RoundStatus> get values => const [Pending,InProgress,Ended];
}

class RoundStats implements IConvertible
{
    String? id;
    DateTime createdAt = DateTime(0);
    RoundStatus status;
    int canceledCount = 0;
    double canceledAmount = 0;
    int betCount = 0;
    double stakeAmount = 0;
    double winningsAmount = 0;
    double balanceAmount = 0;
    double balancePct = 0;

    RoundStats({this.id,this.createdAt,this.status,this.canceledCount,this.canceledAmount,this.betCount,this.stakeAmount,this.winningsAmount,this.balanceAmount,this.balancePct});
    RoundStats.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        createdAt = JsonConverters.fromJson(json['createdAt'],'DateTime',context!);
        status = JsonConverters.fromJson(json['status'],'RoundStatus',context!);
        canceledCount = json['canceledCount'];
        canceledAmount = JsonConverters.toDouble(json['canceledAmount']);
        betCount = json['betCount'];
        stakeAmount = JsonConverters.toDouble(json['stakeAmount']);
        winningsAmount = JsonConverters.toDouble(json['winningsAmount']);
        balanceAmount = JsonConverters.toDouble(json['balanceAmount']);
        balancePct = JsonConverters.toDouble(json['balancePct']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'createdAt': JsonConverters.toJson(createdAt,'DateTime',context!),
        'status': JsonConverters.toJson(status,'RoundStatus',context!),
        'canceledCount': canceledCount,
        'canceledAmount': canceledAmount,
        'betCount': betCount,
        'stakeAmount': stakeAmount,
        'winningsAmount': winningsAmount,
        'balanceAmount': balanceAmount,
        'balancePct': balancePct
    };

    getTypeName() => "RoundStats";
    TypeContext? context = _ctx;
}

class FindRoundStats implements IConvertible
{
    DateTime periodFrom = DateTime(0);
    DateTime periodTo = DateTime(0);
    int currentPage = 0;
    int pageSize = 0;

    FindRoundStats({this.periodFrom,this.periodTo,this.currentPage,this.pageSize});
    FindRoundStats.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        periodFrom = JsonConverters.fromJson(json['periodFrom'],'DateTime',context!);
        periodTo = JsonConverters.fromJson(json['periodTo'],'DateTime',context!);
        currentPage = json['currentPage'];
        pageSize = json['pageSize'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'periodFrom': JsonConverters.toJson(periodFrom,'DateTime',context!),
        'periodTo': JsonConverters.toJson(periodTo,'DateTime',context!),
        'currentPage': currentPage,
        'pageSize': pageSize
    };

    getTypeName() => "FindRoundStats";
    TypeContext? context = _ctx;
}

class PaginatedResult<T> implements IConvertible
{
    List<RoundStats>? data;
    int currentPage = 0;
    int pageSize = 0;
    int totalItems = 0;
    int totalPages = 0;

    PaginatedResult({this.data,this.currentPage,this.pageSize,this.totalItems,this.totalPages});
    PaginatedResult.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        data = JsonConverters.fromJson(json['data'],'List<RoundStats>',context!);
        currentPage = json['currentPage'];
        pageSize = json['pageSize'];
        totalItems = json['totalItems'];
        totalPages = json['totalPages'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'data': JsonConverters.toJson(data,'List<RoundStats>',context!),
        'currentPage': currentPage,
        'pageSize': pageSize,
        'totalItems': totalItems,
        'totalPages': totalPages
    };

    getTypeName() => "PaginatedResult<$T>";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'grh1.api.bettor.webhop.biz', types: <String, TypeInfo> {
    'RoundStatus': TypeInfo(TypeOf.Enum, enumValues:RoundStatus.values),
    'RoundStats': TypeInfo(TypeOf.Class, create:() => RoundStats()),
    'FindRoundStats': TypeInfo(TypeOf.Class, create:() => FindRoundStats()),
    'PaginatedResult<T>': TypeInfo(TypeOf.Class, create:() => PaginatedResult<T>()),
    'List<RoundStats>': TypeInfo(TypeOf.Class, create:() => <RoundStats>[]),
});

Dart FindRoundStats DTOs

POST /rounds/stats HTTP/1.1 
Host: grh1.api.bettor.webhop.biz 
Accept: application/xml
Content-Type: application/xml
Content-Length: length

<FindRoundStats xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Greyhounds.WebApi.ServiceModel">
  <CurrentPage>0</CurrentPage>
  <PageSize>0</PageSize>
  <PeriodFrom>0001-01-01T00:00:00</PeriodFrom>
  <PeriodTo>0001-01-01T00:00:00</PeriodTo>
</FindRoundStats>

HTTP/1.1 200 OK
Content-Type: application/xml
Content-Length: length

<PaginatedResultOfRoundStatsHTcU5Hwp xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Greyhounds.ReadModel">
  <CurrentPage>0</CurrentPage>
  <Data>
    <RoundStats>
      <BalanceAmount>0</BalanceAmount>
      <BalancePct>0</BalancePct>
      <BetCount>0</BetCount>
      <CanceledAmount>0</CanceledAmount>
      <CanceledCount>0</CanceledCount>
      <CreatedAt>0001-01-01T00:00:00</CreatedAt>
      <Id>String</Id>
      <StakeAmount>0</StakeAmount>
      <Status>Pending</Status>
      <WinningsAmount>0</WinningsAmount>
    </RoundStats>
  </Data>
  <PageSize>0</PageSize>
  <TotalItems>0</TotalItems>
  <TotalPages>0</TotalPages>
</PaginatedResultOfRoundStatsHTcU5Hwp>