Betting.WebApi

<back to all web services

SetBettingPoliciesConfig

Requires Authentication
The following routes are available for this service:
POST/cmd/bettingPolicies/config
import 'package:servicestack/servicestack.dart';

class PayinConstraintType
{
    static const PayinConstraintType SingleBet = const PayinConstraintType._(0);
    static const PayinConstraintType MultiBet = const PayinConstraintType._(1);
    static const PayinConstraintType SystemBet = const PayinConstraintType._(2);

    final int _value;
    const PayinConstraintType._(this._value);
    int get value => _value;
    static List<PayinConstraintType> get values => const [SingleBet,MultiBet,SystemBet];
}

class Money implements IConvertible
{
    double? amount;
    String? currency;

    Money({this.amount,this.currency});
    Money.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        amount = JsonConverters.toDouble(json['amount']);
        currency = json['currency'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'amount': amount,
        'currency': currency
    };

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

class PayinConstraint implements IConvertible
{
    PayinConstraintType? type;
    Money? min;
    Money? Default;
    Money? warningThreshold;
    Money? max;

    PayinConstraint({this.type,this.min,this.Default,this.warningThreshold,this.max});
    PayinConstraint.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        type = JsonConverters.fromJson(json['type'],'PayinConstraintType',context!);
        min = JsonConverters.fromJson(json['min'],'Money',context!);
        Default = JsonConverters.fromJson(json['default'],'Money',context!);
        warningThreshold = JsonConverters.fromJson(json['warningThreshold'],'Money',context!);
        max = JsonConverters.fromJson(json['max'],'Money',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'type': JsonConverters.toJson(type,'PayinConstraintType',context!),
        'min': JsonConverters.toJson(min,'Money',context!),
        'default': JsonConverters.toJson(Default,'Money',context!),
        'warningThreshold': JsonConverters.toJson(warningThreshold,'Money',context!),
        'max': JsonConverters.toJson(max,'Money',context!)
    };

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

class WinningsCapType
{
    static const WinningsCapType SingleBet = const WinningsCapType._(0);
    static const WinningsCapType MultiBet = const WinningsCapType._(1);
    static const WinningsCapType SystemBet = const WinningsCapType._(2);

    final int _value;
    const WinningsCapType._(this._value);
    int get value => _value;
    static List<WinningsCapType> get values => const [SingleBet,MultiBet,SystemBet];
}

class WinningsCap implements IConvertible
{
    WinningsCapType? type;
    Money? cap;

    WinningsCap({this.type,this.cap});
    WinningsCap.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        type = JsonConverters.fromJson(json['type'],'WinningsCapType',context!);
        cap = JsonConverters.fromJson(json['cap'],'Money',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'type': JsonConverters.toJson(type,'WinningsCapType',context!),
        'cap': JsonConverters.toJson(cap,'Money',context!)
    };

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

class BettingPolicies implements IConvertible
{
    RecordList<PayinConstraint>? payinConstraints;
    String? payinTaxationPolicyId;
    RecordList<WinningsCap>? winningsCaps;
    String? winningsTaxationPolicyId;

    BettingPolicies({this.payinConstraints,this.payinTaxationPolicyId,this.winningsCaps,this.winningsTaxationPolicyId});
    BettingPolicies.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        payinConstraints = JsonConverters.fromJson(json['payinConstraints'],'RecordList<PayinConstraint>',context!);
        payinTaxationPolicyId = json['payinTaxationPolicyId'];
        winningsCaps = JsonConverters.fromJson(json['winningsCaps'],'RecordList<WinningsCap>',context!);
        winningsTaxationPolicyId = json['winningsTaxationPolicyId'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'payinConstraints': JsonConverters.toJson(payinConstraints,'RecordList<PayinConstraint>',context!),
        'payinTaxationPolicyId': payinTaxationPolicyId,
        'winningsCaps': JsonConverters.toJson(winningsCaps,'RecordList<WinningsCap>',context!),
        'winningsTaxationPolicyId': winningsTaxationPolicyId
    };

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

class Ref implements IConvertible
{
    String? id;
    String? val;

    Ref({this.id,this.val});
    Ref.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        val = json['val'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'val': val
    };

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

class SetBettingPoliciesConfig implements IConvertible
{
    String? id;
    BettingPolicies? policies;
    Ref? productInstanceRef;
    Ref? ownerRef;
    bool? isActive;

    SetBettingPoliciesConfig({this.id,this.policies,this.productInstanceRef,this.ownerRef,this.isActive});
    SetBettingPoliciesConfig.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        policies = JsonConverters.fromJson(json['policies'],'BettingPolicies',context!);
        productInstanceRef = JsonConverters.fromJson(json['productInstanceRef'],'Ref',context!);
        ownerRef = JsonConverters.fromJson(json['ownerRef'],'Ref',context!);
        isActive = json['isActive'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'policies': JsonConverters.toJson(policies,'BettingPolicies',context!),
        'productInstanceRef': JsonConverters.toJson(productInstanceRef,'Ref',context!),
        'ownerRef': JsonConverters.toJson(ownerRef,'Ref',context!),
        'isActive': isActive
    };

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

class RecordList<T> extends ListBase<T> implements IConvertible
{
    final List<T> l = [];
    set length(int newLength) { l.length = newLength; }
    int get length => l.length;
    T operator [](int index) => l[index];
    void operator []=(int index, T value) { l[index] = value; }
    RecordList();
    RecordList.fromJson(Map<String, dynamic> json) : super();
    fromMap(Map<String, dynamic> json) {
        return this;
    }

    Map<String, dynamic> toJson() => {};
    getTypeName() => "RecordList<$T>";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.sbbet.ath.cx', types: <String, TypeInfo> {
    'PayinConstraintType': TypeInfo(TypeOf.Enum, enumValues:PayinConstraintType.values),
    'Money': TypeInfo(TypeOf.Class, create:() => Money()),
    'PayinConstraint': TypeInfo(TypeOf.Class, create:() => PayinConstraint()),
    'WinningsCapType': TypeInfo(TypeOf.Enum, enumValues:WinningsCapType.values),
    'WinningsCap': TypeInfo(TypeOf.Class, create:() => WinningsCap()),
    'BettingPolicies': TypeInfo(TypeOf.Class, create:() => BettingPolicies()),
    'RecordList<PayinConstraint>': TypeInfo(TypeOf.Class, create:() => RecordList<PayinConstraint>()),
    'RecordList<WinningsCap>': TypeInfo(TypeOf.Class, create:() => RecordList<WinningsCap>()),
    'Ref': TypeInfo(TypeOf.Class, create:() => Ref()),
    'SetBettingPoliciesConfig': TypeInfo(TypeOf.Class, create:() => SetBettingPoliciesConfig()),
    'RecordList<T>': TypeInfo(TypeOf.GenericDef,create:() => RecordList()),
});

Dart SetBettingPoliciesConfig DTOs

To override the Content-type in your clients, use the HTTP Accept Header, append the .xml suffix or ?format=xml

HTTP + XML

The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.

POST /cmd/bettingPolicies/config HTTP/1.1 
Host: api.sbbet.ath.cx 
Accept: application/xml
Content-Type: application/xml
Content-Length: length

<SetBettingPoliciesConfig xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Betting.WebApi.ServiceModel">
  <Id>String</Id>
  <IsActive>false</IsActive>
  <OwnerRef xmlns:d2p1="http://schemas.datacontract.org/2004/07/Starnet.Common">
    <d2p1:_x003C_Id_x003E_k__BackingField>String</d2p1:_x003C_Id_x003E_k__BackingField>
    <d2p1:_x003C_Val_x003E_k__BackingField>String</d2p1:_x003C_Val_x003E_k__BackingField>
  </OwnerRef>
  <Policies xmlns:d2p1="http://schemas.datacontract.org/2004/07/Betting.Common">
    <d2p1:PayinConstraints>
      <d2p1:PayinConstraint>
        <d2p1:Default xmlns:d5p1="http://schemas.datacontract.org/2004/07/Starnet.Common">
          <d5p1:Amount>0</d5p1:Amount>
          <d5p1:Currency>String</d5p1:Currency>
        </d2p1:Default>
        <d2p1:Max xmlns:d5p1="http://schemas.datacontract.org/2004/07/Starnet.Common">
          <d5p1:Amount>0</d5p1:Amount>
          <d5p1:Currency>String</d5p1:Currency>
        </d2p1:Max>
        <d2p1:Min xmlns:d5p1="http://schemas.datacontract.org/2004/07/Starnet.Common">
          <d5p1:Amount>0</d5p1:Amount>
          <d5p1:Currency>String</d5p1:Currency>
        </d2p1:Min>
        <d2p1:Type>SingleBet</d2p1:Type>
        <d2p1:WarningThreshold xmlns:d5p1="http://schemas.datacontract.org/2004/07/Starnet.Common">
          <d5p1:Amount>0</d5p1:Amount>
          <d5p1:Currency>String</d5p1:Currency>
        </d2p1:WarningThreshold>
      </d2p1:PayinConstraint>
    </d2p1:PayinConstraints>
    <d2p1:PayinTaxationPolicyId>String</d2p1:PayinTaxationPolicyId>
    <d2p1:WinningsCaps>
      <d2p1:WinningsCap>
        <d2p1:Cap xmlns:d5p1="http://schemas.datacontract.org/2004/07/Starnet.Common">
          <d5p1:Amount>0</d5p1:Amount>
          <d5p1:Currency>String</d5p1:Currency>
        </d2p1:Cap>
        <d2p1:Type>SingleBet</d2p1:Type>
      </d2p1:WinningsCap>
    </d2p1:WinningsCaps>
    <d2p1:WinningsTaxationPolicyId>String</d2p1:WinningsTaxationPolicyId>
  </Policies>
  <ProductInstanceRef xmlns:d2p1="http://schemas.datacontract.org/2004/07/Starnet.Common">
    <d2p1:_x003C_Id_x003E_k__BackingField>String</d2p1:_x003C_Id_x003E_k__BackingField>
    <d2p1:_x003C_Val_x003E_k__BackingField>String</d2p1:_x003C_Val_x003E_k__BackingField>
  </ProductInstanceRef>
</SetBettingPoliciesConfig>

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

<ResponseStatus xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.servicestack.net/types">
  <ErrorCode>String</ErrorCode>
  <Message>String</Message>
  <StackTrace>String</StackTrace>
  <Errors>
    <ResponseError>
      <ErrorCode>String</ErrorCode>
      <FieldName>String</FieldName>
      <Message>String</Message>
      <Meta xmlns:d4p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
        <d4p1:KeyValueOfstringstring>
          <d4p1:Key>String</d4p1:Key>
          <d4p1:Value>String</d4p1:Value>
        </d4p1:KeyValueOfstringstring>
      </Meta>
    </ResponseError>
  </Errors>
  <Meta xmlns:d2p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
    <d2p1:KeyValueOfstringstring>
      <d2p1:Key>String</d2p1:Key>
      <d2p1:Value>String</d2p1:Value>
    </d2p1:KeyValueOfstringstring>
  </Meta>
</ResponseStatus>