BokaMera.API.Host

<back to all web services

LicenseInformationQuery

The following routes are available for this service:
GET/licenses/information/Get whats included in each licenseThis service is used to get to summare of information about whats included in each license.
import 'package:servicestack/servicestack.dart';

// @DataContract
abstract class QueryBase
{
    /**
    * Skip over a given number of elements in a sequence and then return the remainder. Use this when you need paging.<br/><br/><strong>Example:</strong><br/><code>?skip=10&orderBy=Id</code>
    */
    // @DataMember(Order=1)
    int? Skip;

    /**
    * Return a given number of elements in a sequence and then skip over the remainder. Use this when you need paging.<br/><br/><strong>Example:</strong><br/><code>?take=20</code>
    */
    // @DataMember(Order=2)
    int? Take;

    /**
    * Comma separated list of fields to order by. Prefix the field name with a minus if you wan't to invert the sort for that field.<br/><br/><strong>Example:</strong><br/><code>?orderBy=Id,-Age,FirstName</code>
    */
    // @DataMember(Order=3)
    String? OrderBy;

    /**
    * Comma separated list of fields to order by in descending order. Prefix the field name with a minus if you wan't to invert the sort for that field.<br/><br/><strong>Example:</strong><br/><code>?orderByDesc=Id,-Age,FirstName</code>
    */
    // @DataMember(Order=4)
    String? OrderByDesc;

    /**
    * Include any of the aggregates <code>AVG, COUNT, FIRST, LAST, MAX, MIN, SUM</code> in your result set. The results will be returned in the meta field.<br/><br/><strong>Example:</strong><br/><code>?include=COUNT(*) as Total</code><br/><br/>or multiple fields with<br/><code>?include=Count(*) Total, Min(Age), AVG(Age) AverageAge</code><br/></br>or unique with<br/><code>?include=COUNT(DISTINCT LivingStatus) as UniqueStatus</code>
    */
    // @DataMember(Order=5)
    String? Include;

    // @DataMember(Order=6)
    String? Fields;

    // @DataMember(Order=7)
    Map<String,String?>? Meta;

    QueryBase({this.Skip,this.Take,this.OrderBy,this.OrderByDesc,this.Include,this.Fields,this.Meta});
    QueryBase.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Skip = json['Skip'];
        Take = json['Take'];
        OrderBy = json['OrderBy'];
        OrderByDesc = json['OrderByDesc'];
        Include = json['Include'];
        Fields = json['Fields'];
        Meta = JsonConverters.toStringMap(json['Meta']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Skip': Skip,
        'Take': Take,
        'OrderBy': OrderBy,
        'OrderByDesc': OrderByDesc,
        'Include': Include,
        'Fields': Fields,
        'Meta': Meta
    };

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

abstract class QueryDb2<From,Into> extends QueryBase
{
    QueryDb2();
    QueryDb2.fromJson(Map<String, dynamic> json) : super.fromJson(json);
    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson();
    getTypeName() => "QueryDb<$From,$Into>";
    TypeContext? context = _ctx;
}

class LicenseItemsResponse implements IConvertible
{
    int? Id;
    String? Name;
    int? AllowedItems;

    LicenseItemsResponse({this.Id,this.Name,this.AllowedItems});
    LicenseItemsResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Id = json['Id'];
        Name = json['Name'];
        AllowedItems = json['AllowedItems'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Id': Id,
        'Name': Name,
        'AllowedItems': AllowedItems
    };

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

class BaseModel implements IConvertible
{
    BaseModel();
    BaseModel.fromJson(Map<String, dynamic> json) : super();
    fromMap(Map<String, dynamic> json) {
        return this;
    }

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

class Currency extends BaseModel implements IConvertible
{
    // @Required()
    String? Name;

    // @Required()
    String? CurrencySign;

    // @Required()
    bool? Active;

    DateTime? ModifiedDate;
    // @Required()
    String? Id;

    Currency({this.Name,this.CurrencySign,this.Active,this.ModifiedDate,this.Id});
    Currency.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        Name = json['Name'];
        CurrencySign = json['CurrencySign'];
        Active = json['Active'];
        ModifiedDate = JsonConverters.fromJson(json['ModifiedDate'],'DateTime',context!);
        Id = json['Id'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'Name': Name,
        'CurrencySign': CurrencySign,
        'Active': Active,
        'ModifiedDate': JsonConverters.toJson(ModifiedDate,'DateTime',context!),
        'Id': Id
    });

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

class Country extends BaseModel implements IConvertible
{
    // @References(typeof(Currency))
    String? CurrencyId;

    Currency? CurrencyInfo;
    // @Required()
    String? Name;

    String? Culture;
    String? TimeZone;
    DateTime? ModifiedDate;
    // @Required()
    String? Id;

    Country({this.CurrencyId,this.CurrencyInfo,this.Name,this.Culture,this.TimeZone,this.ModifiedDate,this.Id});
    Country.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        CurrencyId = json['CurrencyId'];
        CurrencyInfo = JsonConverters.fromJson(json['CurrencyInfo'],'Currency',context!);
        Name = json['Name'];
        Culture = json['Culture'];
        TimeZone = json['TimeZone'];
        ModifiedDate = JsonConverters.fromJson(json['ModifiedDate'],'DateTime',context!);
        Id = json['Id'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'CurrencyId': CurrencyId,
        'CurrencyInfo': JsonConverters.toJson(CurrencyInfo,'Currency',context!),
        'Name': Name,
        'Culture': Culture,
        'TimeZone': TimeZone,
        'ModifiedDate': JsonConverters.toJson(ModifiedDate,'DateTime',context!),
        'Id': Id
    });

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

class LicensePrice extends BaseModel implements IConvertible
{
    // @Ignore()
    Country? Country;

    // @Ignore()
    bool? MonthlyPayment;

    // @Required()
    int? LicenseTypeId;

    // @Required()
    String? CountryId;

    // @Required()
    int? Price;

    DateTime? ModifiedDate;

    LicensePrice({this.Country,this.MonthlyPayment,this.LicenseTypeId,this.CountryId,this.Price,this.ModifiedDate});
    LicensePrice.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        Country = JsonConverters.fromJson(json['Country'],'Country',context!);
        MonthlyPayment = json['MonthlyPayment'];
        LicenseTypeId = json['LicenseTypeId'];
        CountryId = json['CountryId'];
        Price = json['Price'];
        ModifiedDate = JsonConverters.fromJson(json['ModifiedDate'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'Country': JsonConverters.toJson(Country,'Country',context!),
        'MonthlyPayment': MonthlyPayment,
        'LicenseTypeId': LicenseTypeId,
        'CountryId': CountryId,
        'Price': Price,
        'ModifiedDate': JsonConverters.toJson(ModifiedDate,'DateTime',context!)
    });

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

class LicenseTypeQueryResponse implements IConvertible
{
    /**
    * The license type id
    */
    // @ApiMember(Description="The license type id")
    int? Id;

    /**
    * The license type name
    */
    // @ApiMember(Description="The license type name")
    String? Name;

    /**
    * The license type description
    */
    // @ApiMember(Description="The license type description")
    String? Description;

    /**
    * If the license type is not a standard license but instead an extra license option. An example would be sending new letter license.
    */
    // @ApiMember(Description="If the license type is not a standard license but instead an extra license option. An example would be sending new letter license.")
    bool? IsExtraLicenseOption;

    /**
    * The period of notice for the license in days.
    */
    // @ApiMember(Description="The period of notice for the license in days.")
    int? PeriodOfNoticeDays;

    /**
    * The license items for the license type
    */
    // @ApiMember(Description="The license items for the license type")
    List<LicenseItemsResponse>? Items;

    /**
    * The license prices in each country for the license type
    */
    // @ApiMember(Description="The license prices in each country for the license type")
    List<LicensePrice>? Prices;

    LicenseTypeQueryResponse({this.Id,this.Name,this.Description,this.IsExtraLicenseOption,this.PeriodOfNoticeDays,this.Items,this.Prices});
    LicenseTypeQueryResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Id = json['Id'];
        Name = json['Name'];
        Description = json['Description'];
        IsExtraLicenseOption = json['IsExtraLicenseOption'];
        PeriodOfNoticeDays = json['PeriodOfNoticeDays'];
        Items = JsonConverters.fromJson(json['Items'],'List<LicenseItemsResponse>',context!);
        Prices = JsonConverters.fromJson(json['Prices'],'List<LicensePrice>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Id': Id,
        'Name': Name,
        'Description': Description,
        'IsExtraLicenseOption': IsExtraLicenseOption,
        'PeriodOfNoticeDays': PeriodOfNoticeDays,
        'Items': JsonConverters.toJson(Items,'List<LicenseItemsResponse>',context!),
        'Prices': JsonConverters.toJson(Prices,'List<LicensePrice>',context!)
    };

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

class LicenseInformation extends BaseModel implements IConvertible
{
    // @Ignore()
    List<LicensePrice>? Prices;

    int? Id;
    int? LicenseInformationId;
    // @Required()
    String? Name;

    // @Required()
    String? Description;

    String? Url;
    // @Required()
    bool? FreeEdition;

    // @Required()
    bool? StartEdition;

    // @Required()
    bool? ProEdition;

    String? FreeEditionValue;
    String? StartEditionValue;
    String? ProEditionValue;
    bool? PlatinumEdition;
    String? PlatinumEditionValue;
    DateTime? ModifiedDate;
    bool? SmartEdition;
    bool? EnterpriseEdition;
    String? SmartEditionValue;
    String? EnterpriseEditionValue;

    LicenseInformation({this.Prices,this.Id,this.LicenseInformationId,this.Name,this.Description,this.Url,this.FreeEdition,this.StartEdition,this.ProEdition,this.FreeEditionValue,this.StartEditionValue,this.ProEditionValue,this.PlatinumEdition,this.PlatinumEditionValue,this.ModifiedDate,this.SmartEdition,this.EnterpriseEdition,this.SmartEditionValue,this.EnterpriseEditionValue});
    LicenseInformation.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        Prices = JsonConverters.fromJson(json['Prices'],'List<LicensePrice>',context!);
        Id = json['Id'];
        LicenseInformationId = json['LicenseInformationId'];
        Name = json['Name'];
        Description = json['Description'];
        Url = json['Url'];
        FreeEdition = json['FreeEdition'];
        StartEdition = json['StartEdition'];
        ProEdition = json['ProEdition'];
        FreeEditionValue = json['FreeEditionValue'];
        StartEditionValue = json['StartEditionValue'];
        ProEditionValue = json['ProEditionValue'];
        PlatinumEdition = json['PlatinumEdition'];
        PlatinumEditionValue = json['PlatinumEditionValue'];
        ModifiedDate = JsonConverters.fromJson(json['ModifiedDate'],'DateTime',context!);
        SmartEdition = json['SmartEdition'];
        EnterpriseEdition = json['EnterpriseEdition'];
        SmartEditionValue = json['SmartEditionValue'];
        EnterpriseEditionValue = json['EnterpriseEditionValue'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'Prices': JsonConverters.toJson(Prices,'List<LicensePrice>',context!),
        'Id': Id,
        'LicenseInformationId': LicenseInformationId,
        'Name': Name,
        'Description': Description,
        'Url': Url,
        'FreeEdition': FreeEdition,
        'StartEdition': StartEdition,
        'ProEdition': ProEdition,
        'FreeEditionValue': FreeEditionValue,
        'StartEditionValue': StartEditionValue,
        'ProEditionValue': ProEditionValue,
        'PlatinumEdition': PlatinumEdition,
        'PlatinumEditionValue': PlatinumEditionValue,
        'ModifiedDate': JsonConverters.toJson(ModifiedDate,'DateTime',context!),
        'SmartEdition': SmartEdition,
        'EnterpriseEdition': EnterpriseEdition,
        'SmartEditionValue': SmartEditionValue,
        'EnterpriseEditionValue': EnterpriseEditionValue
    });

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

// @ApiResponse(Description="You were unauthorized to call this service", StatusCode=401)
class LicenseInformationQuery extends QueryDb2<LicenseInformation,LicenseTypeQueryResponse> implements IConvertible
{
    /**
    * If you want to include the connected license prices
    */
    // @ApiMember(DataType="boolean", Description="If you want to include the connected license prices", ParameterType="query")
    bool? IncludeLicensePrices;

    ResponseStatus? ResponseStatus;

    LicenseInformationQuery({this.IncludeLicensePrices,this.ResponseStatus});
    LicenseInformationQuery.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        IncludeLicensePrices = json['IncludeLicensePrices'];
        ResponseStatus = JsonConverters.fromJson(json['ResponseStatus'],'ResponseStatus',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'IncludeLicensePrices': IncludeLicensePrices,
        'ResponseStatus': JsonConverters.toJson(ResponseStatus,'ResponseStatus',context!)
    });

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

class AccessKeyTypeResponse implements IConvertible
{
    int? Id;
    String? KeyType;
    String? Description;

    AccessKeyTypeResponse({this.Id,this.KeyType,this.Description});
    AccessKeyTypeResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Id = json['Id'];
        KeyType = json['KeyType'];
        Description = json['Description'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Id': Id,
        'KeyType': KeyType,
        'Description': Description
    };

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

// @DataContract
class QueryResponse<AccessKeyTypeResponse> implements IConvertible
{
    // @DataMember(Order=1)
    int? Offset;

    // @DataMember(Order=2)
    int? Total;

    // @DataMember(Order=3)
    List<AccessKeyTypeResponse>? Results;

    // @DataMember(Order=4)
    Map<String,String?>? Meta;

    // @DataMember(Order=5)
    ResponseStatus? ResponseStatus;

    QueryResponse({this.Offset,this.Total,this.Results,this.Meta,this.ResponseStatus});
    QueryResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Offset = json['Offset'];
        Total = json['Total'];
        Results = JsonConverters.fromJson(json['Results'],'List<${runtimeGenericTypeDefs(this,[0]).join(",")}>',context!);
        Meta = JsonConverters.toStringMap(json['Meta']);
        ResponseStatus = JsonConverters.fromJson(json['ResponseStatus'],'ResponseStatus',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Offset': Offset,
        'Total': Total,
        'Results': JsonConverters.toJson(Results,'List<AccessKeyTypeResponse>',context!),
        'Meta': Meta,
        'ResponseStatus': JsonConverters.toJson(ResponseStatus,'ResponseStatus',context!)
    };

    getTypeName() => "QueryResponse<$AccessKeyTypeResponse>";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'testapi.bokamera.se', types: <String, TypeInfo> {
    'LicenseItemsResponse': TypeInfo(TypeOf.Class, create:() => LicenseItemsResponse()),
    'BaseModel': TypeInfo(TypeOf.Class, create:() => BaseModel()),
    'Currency': TypeInfo(TypeOf.Class, create:() => Currency()),
    'Country': TypeInfo(TypeOf.Class, create:() => Country()),
    'LicensePrice': TypeInfo(TypeOf.Class, create:() => LicensePrice()),
    'LicenseTypeQueryResponse': TypeInfo(TypeOf.Class, create:() => LicenseTypeQueryResponse()),
    'List<LicenseItemsResponse>': TypeInfo(TypeOf.Class, create:() => <LicenseItemsResponse>[]),
    'List<LicensePrice>': TypeInfo(TypeOf.Class, create:() => <LicensePrice>[]),
    'LicenseInformation': TypeInfo(TypeOf.Class, create:() => LicenseInformation()),
    'LicenseInformationQuery': TypeInfo(TypeOf.Class, create:() => LicenseInformationQuery()),
    'List<LicenseTypeQueryResponse>': TypeInfo(TypeOf.Class, create:() => <LicenseTypeQueryResponse>[]),
    'AccessKeyTypeResponse': TypeInfo(TypeOf.Class, create:() => AccessKeyTypeResponse()),
    'QueryResponse<AccessKeyTypeResponse>': TypeInfo(TypeOf.Class, create:() => QueryResponse<AccessKeyTypeResponse>()),
});

Dart LicenseInformationQuery 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.

GET /licenses/information/ HTTP/1.1 
Host: testapi.bokamera.se 
Accept: application/xml

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

<QueryResponseOfLicenseTypeQueryResponseWg5EthtI xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.servicestack.net/types">
  <Offset>0</Offset>
  <Total>0</Total>
  <Results xmlns:d2p1="http://schemas.datacontract.org/2004/07/BokaMera.API.ServiceModel.Dtos">
    <d2p1:LicenseTypeQueryResponse>
      <d2p1:Description>String</d2p1:Description>
      <d2p1:Id>0</d2p1:Id>
      <d2p1:IsExtraLicenseOption>false</d2p1:IsExtraLicenseOption>
      <d2p1:Items>
        <d2p1:LicenseItemsResponse>
          <d2p1:AllowedItems>0</d2p1:AllowedItems>
          <d2p1:Id>0</d2p1:Id>
          <d2p1:Name>String</d2p1:Name>
        </d2p1:LicenseItemsResponse>
      </d2p1:Items>
      <d2p1:Name>String</d2p1:Name>
      <d2p1:PeriodOfNoticeDays>0</d2p1:PeriodOfNoticeDays>
      <d2p1:Prices xmlns:d4p1="http://schemas.datacontract.org/2004/07/BokaMera.API.ServiceModel.Db">
        <d4p1:LicensePrice>
          <d4p1:Country>
            <d4p1:Culture>String</d4p1:Culture>
            <d4p1:CurrencyId>String</d4p1:CurrencyId>
            <d4p1:CurrencyInfo>
              <d4p1:Active>false</d4p1:Active>
              <d4p1:CurrencySign>String</d4p1:CurrencySign>
              <d4p1:Id>String</d4p1:Id>
              <d4p1:ModifiedDate xmlns:d8p1="http://schemas.datacontract.org/2004/07/System">
                <d8p1:DateTime>0001-01-01T00:00:00Z</d8p1:DateTime>
                <d8p1:OffsetMinutes>0</d8p1:OffsetMinutes>
              </d4p1:ModifiedDate>
              <d4p1:Name>String</d4p1:Name>
            </d4p1:CurrencyInfo>
            <d4p1:Id>String</d4p1:Id>
            <d4p1:ModifiedDate xmlns:d7p1="http://schemas.datacontract.org/2004/07/System">
              <d7p1:DateTime>0001-01-01T00:00:00Z</d7p1:DateTime>
              <d7p1:OffsetMinutes>0</d7p1:OffsetMinutes>
            </d4p1:ModifiedDate>
            <d4p1:Name>String</d4p1:Name>
            <d4p1:TimeZone>String</d4p1:TimeZone>
          </d4p1:Country>
          <d4p1:CountryId>String</d4p1:CountryId>
          <d4p1:LicenseTypeId>0</d4p1:LicenseTypeId>
          <d4p1:ModifiedDate xmlns:d6p1="http://schemas.datacontract.org/2004/07/System">
            <d6p1:DateTime>0001-01-01T00:00:00Z</d6p1:DateTime>
            <d6p1:OffsetMinutes>0</d6p1:OffsetMinutes>
          </d4p1:ModifiedDate>
          <d4p1:Price>0</d4p1:Price>
        </d4p1:LicensePrice>
      </d2p1:Prices>
    </d2p1:LicenseTypeQueryResponse>
  </Results>
  <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>
    <ErrorCode>String</ErrorCode>
    <Message>String</Message>
    <StackTrace>String</StackTrace>
    <Errors>
      <ResponseError>
        <ErrorCode>String</ErrorCode>
        <FieldName>String</FieldName>
        <Message>String</Message>
        <Meta xmlns:d5p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
          <d5p1:KeyValueOfstringstring>
            <d5p1:Key>String</d5p1:Key>
            <d5p1:Value>String</d5p1:Value>
          </d5p1:KeyValueOfstringstring>
        </Meta>
      </ResponseError>
    </Errors>
    <Meta xmlns:d3p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
      <d3p1:KeyValueOfstringstring>
        <d3p1:Key>String</d3p1:Key>
        <d3p1:Value>String</d3p1:Value>
      </d3p1:KeyValueOfstringstring>
    </Meta>
  </ResponseStatus>
</QueryResponseOfLicenseTypeQueryResponseWg5EthtI>