| Requires any of the roles: | bookingsupplier-administrator-write, superadmin |
| POST | /licenses/company/delete | End all licenses | End all licenses on the company for the logged in user. |
|---|
import 'package:servicestack/servicestack.dart';
class LicenseItemsResponse implements IConvertible
{
int Id = 0;
String Name = "";
int AllowedItems = 0;
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 LicensePriceResponse implements IConvertible
{
int LicenseTypeId = 0;
String CountryId = "";
int Price = 0;
Country Country;
int LicensePlanId = 0;
LicensePriceResponse({this.LicenseTypeId,this.CountryId,this.Price,this.Country,this.LicensePlanId});
LicensePriceResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
LicenseTypeId = json['LicenseTypeId'];
CountryId = json['CountryId'];
Price = json['Price'];
Country = JsonConverters.fromJson(json['Country'],'Country',context!);
LicensePlanId = json['LicensePlanId'];
return this;
}
Map<String, dynamic> toJson() => {
'LicenseTypeId': LicenseTypeId,
'CountryId': CountryId,
'Price': Price,
'Country': JsonConverters.toJson(Country,'Country',context!),
'LicensePlanId': LicensePlanId
};
getTypeName() => "LicensePriceResponse";
TypeContext? context = _ctx;
}
class LicenseTypeQueryResponse implements IConvertible
{
/**
* The license type id
*/
// @ApiMember(Description="The license type id")
int Id = 0;
/**
* 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 newsletter license.
*/
// @ApiMember(Description="If the license type is not a standard license but instead an extra license option. An example would be sending newsletter 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 = 0;
/**
* 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<LicensePriceResponse> 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<LicensePriceResponse>',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<LicensePriceResponse>',context!)
};
getTypeName() => "LicenseTypeQueryResponse";
TypeContext? context = _ctx;
}
class ProductGroupResponse implements IConvertible
{
String Id = "";
String Name = "";
String TierId = "";
ProductGroupResponse({this.Id,this.Name,this.TierId});
ProductGroupResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Id = json['Id'];
Name = json['Name'];
TierId = json['TierId'];
return this;
}
Map<String, dynamic> toJson() => {
'Id': Id,
'Name': Name,
'TierId': TierId
};
getTypeName() => "ProductGroupResponse";
TypeContext? context = _ctx;
}
class TierResponse implements IConvertible
{
String Id = "";
String Name = "";
List<ProductGroupResponse> ProductGroups = [];
TierResponse({this.Id,this.Name,this.ProductGroups});
TierResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Id = json['Id'];
Name = json['Name'];
ProductGroups = JsonConverters.fromJson(json['ProductGroups'],'List<ProductGroupResponse>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'Id': Id,
'Name': Name,
'ProductGroups': JsonConverters.toJson(ProductGroups,'List<ProductGroupResponse>',context!)
};
getTypeName() => "TierResponse";
TypeContext? context = _ctx;
}
class VossSubscriptionResponse implements IConvertible
{
DateTime SubscriptionBillingPeriodStartDate = DateTime(0);
DateTime SubscriptionBillingPeriodEndDate = DateTime(0);
DateTime? BindingPeriodEndDate;
TierResponse Tier;
VossSubscriptionResponse({this.SubscriptionBillingPeriodStartDate,this.SubscriptionBillingPeriodEndDate,this.BindingPeriodEndDate,this.Tier});
VossSubscriptionResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
SubscriptionBillingPeriodStartDate = JsonConverters.fromJson(json['SubscriptionBillingPeriodStartDate'],'DateTime',context!);
SubscriptionBillingPeriodEndDate = JsonConverters.fromJson(json['SubscriptionBillingPeriodEndDate'],'DateTime',context!);
BindingPeriodEndDate = JsonConverters.fromJson(json['BindingPeriodEndDate'],'DateTime',context!);
Tier = JsonConverters.fromJson(json['Tier'],'TierResponse',context!);
return this;
}
Map<String, dynamic> toJson() => {
'SubscriptionBillingPeriodStartDate': JsonConverters.toJson(SubscriptionBillingPeriodStartDate,'DateTime',context!),
'SubscriptionBillingPeriodEndDate': JsonConverters.toJson(SubscriptionBillingPeriodEndDate,'DateTime',context!),
'BindingPeriodEndDate': JsonConverters.toJson(BindingPeriodEndDate,'DateTime',context!),
'Tier': JsonConverters.toJson(Tier,'TierResponse',context!)
};
getTypeName() => "VossSubscriptionResponse";
TypeContext? context = _ctx;
}
class CompanyLicenseQueryResponse implements IConvertible
{
int Id = 0;
int TypeId = 0;
LicenseTypeQueryResponse Type;
DateTime ValidFrom = DateTime(0);
DateTime ValidTo = DateTime(0);
String? VossSubscriptionId;
VossSubscriptionResponse VossSubscription;
String MetaData = "";
bool Active;
String LicenseStatus = "";
bool Canceled;
int? LicensePlanId;
DateTime Updated = DateTime(0);
DateTime Created = DateTime(0);
CompanyLicenseQueryResponse({this.Id,this.TypeId,this.Type,this.ValidFrom,this.ValidTo,this.VossSubscriptionId,this.VossSubscription,this.MetaData,this.Active,this.LicenseStatus,this.Canceled,this.LicensePlanId,this.Updated,this.Created});
CompanyLicenseQueryResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Id = json['Id'];
TypeId = json['TypeId'];
Type = JsonConverters.fromJson(json['Type'],'LicenseTypeQueryResponse',context!);
ValidFrom = JsonConverters.fromJson(json['ValidFrom'],'DateTime',context!);
ValidTo = JsonConverters.fromJson(json['ValidTo'],'DateTime',context!);
VossSubscriptionId = json['VossSubscriptionId'];
VossSubscription = JsonConverters.fromJson(json['VossSubscription'],'VossSubscriptionResponse',context!);
MetaData = json['MetaData'];
Active = json['Active'];
LicenseStatus = json['LicenseStatus'];
Canceled = json['Canceled'];
LicensePlanId = json['LicensePlanId'];
Updated = JsonConverters.fromJson(json['Updated'],'DateTime',context!);
Created = JsonConverters.fromJson(json['Created'],'DateTime',context!);
return this;
}
Map<String, dynamic> toJson() => {
'Id': Id,
'TypeId': TypeId,
'Type': JsonConverters.toJson(Type,'LicenseTypeQueryResponse',context!),
'ValidFrom': JsonConverters.toJson(ValidFrom,'DateTime',context!),
'ValidTo': JsonConverters.toJson(ValidTo,'DateTime',context!),
'VossSubscriptionId': VossSubscriptionId,
'VossSubscription': JsonConverters.toJson(VossSubscription,'VossSubscriptionResponse',context!),
'MetaData': MetaData,
'Active': Active,
'LicenseStatus': LicenseStatus,
'Canceled': Canceled,
'LicensePlanId': LicensePlanId,
'Updated': JsonConverters.toJson(Updated,'DateTime',context!),
'Created': JsonConverters.toJson(Created,'DateTime',context!)
};
getTypeName() => "CompanyLicenseQueryResponse";
TypeContext? context = _ctx;
}
class Questionnaire implements IConvertible
{
String Question = "";
String Value = "";
Questionnaire({this.Question,this.Value});
Questionnaire.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Question = json['Question'];
Value = json['Value'];
return this;
}
Map<String, dynamic> toJson() => {
'Question': Question,
'Value': Value
};
getTypeName() => "Questionnaire";
TypeContext? context = _ctx;
}
// @ApiResponse(Description="You were unauthorized to call this service", StatusCode=401)
// @ValidateRequest(Validator="IsAuthenticated")
class EndAllLicenses implements ICompany, IConvertible
{
/**
* The company id, if empty will use the company id for the user you are logged in with.
*/
// @ApiMember(Description="The company id, if empty will use the company id for the user you are logged in with.")
String? CompanyId;
/**
* If true, all licenses and the booking system are terminated today. If false (default), the licenses stay active and are billed until the end of the current billing period, and each license's ValidTo is set to that date.
*/
// @ApiMember(Description="If true, all licenses and the booking system are terminated today. If false (default), the licenses stay active and are billed until the end of the current billing period, and each license's ValidTo is set to that date.")
bool Deactivate;
/**
* Questionaire with answers from customer why ending license.
*/
// @ApiMember(Description="Questionaire with answers from customer why ending license.")
List<Questionnaire> Questionnaire = [];
EndAllLicenses({this.CompanyId,this.Deactivate,this.Questionnaire});
EndAllLicenses.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
CompanyId = json['CompanyId'];
Deactivate = json['Deactivate'];
Questionnaire = JsonConverters.fromJson(json['Questionnaire'],'List<Questionnaire>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'CompanyId': CompanyId,
'Deactivate': Deactivate,
'Questionnaire': JsonConverters.toJson(Questionnaire,'List<Questionnaire>',context!)
};
getTypeName() => "EndAllLicenses";
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()),
'LicensePriceResponse': TypeInfo(TypeOf.Class, create:() => LicensePriceResponse()),
'LicenseTypeQueryResponse': TypeInfo(TypeOf.Class, create:() => LicenseTypeQueryResponse()),
'List<LicenseItemsResponse>': TypeInfo(TypeOf.Class, create:() => <LicenseItemsResponse>[]),
'List<LicensePriceResponse>': TypeInfo(TypeOf.Class, create:() => <LicensePriceResponse>[]),
'ProductGroupResponse': TypeInfo(TypeOf.Class, create:() => ProductGroupResponse()),
'TierResponse': TypeInfo(TypeOf.Class, create:() => TierResponse()),
'List<ProductGroupResponse>': TypeInfo(TypeOf.Class, create:() => <ProductGroupResponse>[]),
'VossSubscriptionResponse': TypeInfo(TypeOf.Class, create:() => VossSubscriptionResponse()),
'CompanyLicenseQueryResponse': TypeInfo(TypeOf.Class, create:() => CompanyLicenseQueryResponse()),
'Questionnaire': TypeInfo(TypeOf.Class, create:() => Questionnaire()),
'EndAllLicenses': TypeInfo(TypeOf.Class, create:() => EndAllLicenses()),
'List<Questionnaire>': TypeInfo(TypeOf.Class, create:() => <Questionnaire>[]),
});
To override the Content-type in your clients, use the HTTP Accept Header, append the .csv suffix or ?format=csv
The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.
POST /licenses/company/delete HTTP/1.1
Host: testapi.bokamera.se
Accept: text/csv
Content-Type: text/csv
Content-Length: length
{"CompanyId":"00000000-0000-0000-0000-000000000000","Deactivate":false,"Questionnaire":[{"Question":"String","Value":"String"}]}
HTTP/1.1 200 OK
Content-Type: text/csv
Content-Length: length
{"Id":0,"TypeId":0,"Type":{"Id":0,"Name":"String","Description":"String","IsExtraLicenseOption":false,"PeriodOfNoticeDays":0,"Items":[{"Id":0,"Name":"String","AllowedItems":0}],"Prices":[{"LicenseTypeId":0,"CountryId":"String","Price":0,"Country":{"CurrencyId":"String","CurrencyInfo":{"Name":"String","CurrencySign":"String","Active":false,"ModifiedDate":"0001-01-01T00:00:00.0000000+00:00","Id":"String"},"Name":"String","Culture":"String","TimeZone":"String","ModifiedDate":"0001-01-01T00:00:00.0000000+00:00","Id":"String"},"LicensePlanId":0}]},"VossSubscriptionId":"00000000-0000-0000-0000-000000000000","VossSubscription":{"BindingPeriodEndDate":"0001-01-01T00:00:00","Tier":{"Name":"String","ProductGroups":[{"Name":"String"}]}},"MetaData":"String","Active":false,"LicenseStatus":"String","Canceled":false,"LicensePlanId":0}