MyApp

QueryBookings

bookings

Find Bookings

The following routes are available for this service:
GET	/bookings
GET	/bookings/{Id}

import 'package:servicestack/servicestack.dart';
import 'dart:typed_data';

// @DataContract
abstract class QueryBase
{
    // @DataMember(Order=1)
    int? skip;

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

    // @DataMember(Order=3)
    String? orderBy;

    // @DataMember(Order=4)
    String? orderByDesc;

    // @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 QueryDb<T> extends QueryBase
{
    QueryDb();
    QueryDb.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<$T>";
    TypeContext? context = _ctx;
}

// @DataContract
abstract class AuditBase
{
    // @DataMember(Order=1)
    DateTime? createdDate;

    // @DataMember(Order=2)
    // @required()
    String? createdBy;

    // @DataMember(Order=3)
    DateTime? modifiedDate;

    // @DataMember(Order=4)
    // @required()
    String? modifiedBy;

    // @DataMember(Order=5)
    DateTime? deletedDate;

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

    AuditBase({this.createdDate,this.createdBy,this.modifiedDate,this.modifiedBy,this.deletedDate,this.deletedBy});
    AuditBase.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        createdDate = JsonConverters.fromJson(json['createdDate'],'DateTime',context!);
        createdBy = json['createdBy'];
        modifiedDate = JsonConverters.fromJson(json['modifiedDate'],'DateTime',context!);
        modifiedBy = json['modifiedBy'];
        deletedDate = JsonConverters.fromJson(json['deletedDate'],'DateTime',context!);
        deletedBy = json['deletedBy'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'createdDate': JsonConverters.toJson(createdDate,'DateTime',context!),
        'createdBy': createdBy,
        'modifiedDate': JsonConverters.toJson(modifiedDate,'DateTime',context!),
        'modifiedBy': modifiedBy,
        'deletedDate': JsonConverters.toJson(deletedDate,'DateTime',context!),
        'deletedBy': deletedBy
    };

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

enum RoomType
{
    Single,
    Double,
    Queen,
    Twin,
    Suite,
}

/**
* Discount Coupons
*/
class Coupon implements IConvertible
{
    String? id;
    String? description;
    int? discount;
    DateTime? expiryDate;

    Coupon({this.id,this.description,this.discount,this.expiryDate});
    Coupon.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        description = json['description'];
        discount = json['discount'];
        expiryDate = JsonConverters.fromJson(json['expiryDate'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'description': description,
        'discount': discount,
        'expiryDate': JsonConverters.toJson(expiryDate,'DateTime',context!)
    };

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

/**
* Booking Details
*/
class Booking extends AuditBase implements IConvertible
{
    int? id;
    String? name;
    RoomType? roomType;
    int? roomNumber;
    DateTime? bookingStartDate;
    DateTime? bookingEndDate;
    double? cost;
    // @References(typeof(Coupon))
    String? couponId;

    Coupon? discount;
    String? notes;
    bool? cancelled;

    Booking({this.id,this.name,this.roomType,this.roomNumber,this.bookingStartDate,this.bookingEndDate,this.cost,this.couponId,this.discount,this.notes,this.cancelled});
    Booking.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        id = json['id'];
        name = json['name'];
        roomType = JsonConverters.fromJson(json['roomType'],'RoomType',context!);
        roomNumber = json['roomNumber'];
        bookingStartDate = JsonConverters.fromJson(json['bookingStartDate'],'DateTime',context!);
        bookingEndDate = JsonConverters.fromJson(json['bookingEndDate'],'DateTime',context!);
        cost = JsonConverters.toDouble(json['cost']);
        couponId = json['couponId'];
        discount = JsonConverters.fromJson(json['discount'],'Coupon',context!);
        notes = json['notes'];
        cancelled = json['cancelled'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'id': id,
        'name': name,
        'roomType': JsonConverters.toJson(roomType,'RoomType',context!),
        'roomNumber': roomNumber,
        'bookingStartDate': JsonConverters.toJson(bookingStartDate,'DateTime',context!),
        'bookingEndDate': JsonConverters.toJson(bookingEndDate,'DateTime',context!),
        'cost': cost,
        'couponId': couponId,
        'discount': JsonConverters.toJson(discount,'Coupon',context!),
        'notes': notes,
        'cancelled': cancelled
    });

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

/**
* Find Bookings
*/
class QueryBookings extends QueryDb<Booking> implements IConvertible
{
    int? id;

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

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

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

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

class Todo implements IConvertible
{
    int? id;
    String? text;
    bool? isFinished;

    Todo({this.id,this.text,this.isFinished});
    Todo.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

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

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

    // @DataMember(Order=3)
    List<Todo>? 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<Todo>',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<Todo>',context!),
        'meta': meta,
        'responseStatus': JsonConverters.toJson(responseStatus,'ResponseStatus',context!)
    };

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

TypeContext _ctx = TypeContext(library: 'blazor_gallery.servicestack.net', types: <String, TypeInfo> {
    'RoomType': TypeInfo(TypeOf.Enum, enumValues:RoomType.values),
    'Coupon': TypeInfo(TypeOf.Class, create:() => Coupon()),
    'Booking': TypeInfo(TypeOf.Class, create:() => Booking()),
    'QueryBookings': TypeInfo(TypeOf.Class, create:() => QueryBookings()),
    'List<Booking>': TypeInfo(TypeOf.Class, create:() => <Booking>[]),
    'Todo': TypeInfo(TypeOf.Class, create:() => Todo()),
    'List<Todo>': TypeInfo(TypeOf.Class, create:() => <Todo>[]),
});

Dart QueryBookings DTOs

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

HTTP + JSV

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

GET /bookings HTTP/1.1 
Host: blazor-gallery.servicestack.net 
Accept: text/jsv

HTTP/1.1 200 OK
Content-Type: text/jsv
Content-Length: length

{
	offset: 0,
	total: 0,
	results: 
	[
		{
			id: 0,
			name: String,
			roomType: Single,
			roomNumber: 0,
			bookingStartDate: 0001-01-01,
			bookingEndDate: 0001-01-01,
			cost: 0,
			couponId: String,
			discount: 
			{
				id: String,
				description: String,
				discount: 0,
				expiryDate: 0001-01-01
			},
			notes: String,
			cancelled: False,
			createdDate: 0001-01-01,
			createdBy: String,
			modifiedDate: 0001-01-01,
			modifiedBy: String,
			deletedDate: 0001-01-01,
			deletedBy: String
		}
	],
	meta: 
	{
		String: String
	},
	responseStatus: 
	{
		errorCode: String,
		message: String,
		stackTrace: String,
		errors: 
		[
			{
				errorCode: String,
				fieldName: String,
				message: String,
				meta: 
				{
					String: String
				}
			}
		],
		meta: 
		{
			String: String
		}
	}
}