ClubManager.Api

FindMessage

**Requires Authentication**
Required role:	API

The following routes are available for this service:
All Verbs	/api/Query/Message

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;
}

class MessageTemplateInstance implements IConvertible
{
    int? MessageTemplateId;
    String? Name;
    String? Subject;
    String? Body;
    int? ReportId;
    int? TemplateType;
    DateTime? Created;
    int? CreatedBy;
    DateTime? Modified;
    int? ModifiedBy;
    DateTime? Deleted;
    int? DeletedBy;
    int? EventType;
    int? ContentType;
    bool? Hidden;
    int? ParentMessageTemplateId;
    String? InclusionTags;
    String? ExclusionTags;

    MessageTemplateInstance({this.MessageTemplateId,this.Name,this.Subject,this.Body,this.ReportId,this.TemplateType,this.Created,this.CreatedBy,this.Modified,this.ModifiedBy,this.Deleted,this.DeletedBy,this.EventType,this.ContentType,this.Hidden,this.ParentMessageTemplateId,this.InclusionTags,this.ExclusionTags});
    MessageTemplateInstance.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        MessageTemplateId = json['MessageTemplateId'];
        Name = json['Name'];
        Subject = json['Subject'];
        Body = json['Body'];
        ReportId = json['ReportId'];
        TemplateType = json['TemplateType'];
        Created = JsonConverters.fromJson(json['Created'],'DateTime',context!);
        CreatedBy = json['CreatedBy'];
        Modified = JsonConverters.fromJson(json['Modified'],'DateTime',context!);
        ModifiedBy = json['ModifiedBy'];
        Deleted = JsonConverters.fromJson(json['Deleted'],'DateTime',context!);
        DeletedBy = json['DeletedBy'];
        EventType = json['EventType'];
        ContentType = json['ContentType'];
        Hidden = json['Hidden'];
        ParentMessageTemplateId = json['ParentMessageTemplateId'];
        InclusionTags = json['InclusionTags'];
        ExclusionTags = json['ExclusionTags'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'MessageTemplateId': MessageTemplateId,
        'Name': Name,
        'Subject': Subject,
        'Body': Body,
        'ReportId': ReportId,
        'TemplateType': TemplateType,
        'Created': JsonConverters.toJson(Created,'DateTime',context!),
        'CreatedBy': CreatedBy,
        'Modified': JsonConverters.toJson(Modified,'DateTime',context!),
        'ModifiedBy': ModifiedBy,
        'Deleted': JsonConverters.toJson(Deleted,'DateTime',context!),
        'DeletedBy': DeletedBy,
        'EventType': EventType,
        'ContentType': ContentType,
        'Hidden': Hidden,
        'ParentMessageTemplateId': ParentMessageTemplateId,
        'InclusionTags': InclusionTags,
        'ExclusionTags': ExclusionTags
    };

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

class UserInstance implements IConvertible
{
    int? UserId;
    String? UserName;
    String? Name;
    String? Email;
    String? MobilePhone;
    bool? Enabled;
    DateTime? LastLogin;
    DateTime? Created;
    bool? Training;
    bool? Deleted;
    int? CoursesCompleted;
    bool? DisplayHomeNotification;
    bool? TwoFactorEnabled;
    bool? EmailConfirmed;
    bool? MobilePhoneConfirmed;
    bool? Notifications;
    DateTime? ChangePassword;
    DateTime? Activated;

    UserInstance({this.UserId,this.UserName,this.Name,this.Email,this.MobilePhone,this.Enabled,this.LastLogin,this.Created,this.Training,this.Deleted,this.CoursesCompleted,this.DisplayHomeNotification,this.TwoFactorEnabled,this.EmailConfirmed,this.MobilePhoneConfirmed,this.Notifications,this.ChangePassword,this.Activated});
    UserInstance.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        UserId = json['UserId'];
        UserName = json['UserName'];
        Name = json['Name'];
        Email = json['Email'];
        MobilePhone = json['MobilePhone'];
        Enabled = json['Enabled'];
        LastLogin = JsonConverters.fromJson(json['LastLogin'],'DateTime',context!);
        Created = JsonConverters.fromJson(json['Created'],'DateTime',context!);
        Training = json['Training'];
        Deleted = json['Deleted'];
        CoursesCompleted = json['CoursesCompleted'];
        DisplayHomeNotification = json['DisplayHomeNotification'];
        TwoFactorEnabled = json['TwoFactorEnabled'];
        EmailConfirmed = json['EmailConfirmed'];
        MobilePhoneConfirmed = json['MobilePhoneConfirmed'];
        Notifications = json['Notifications'];
        ChangePassword = JsonConverters.fromJson(json['ChangePassword'],'DateTime',context!);
        Activated = JsonConverters.fromJson(json['Activated'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'UserId': UserId,
        'UserName': UserName,
        'Name': Name,
        'Email': Email,
        'MobilePhone': MobilePhone,
        'Enabled': Enabled,
        'LastLogin': JsonConverters.toJson(LastLogin,'DateTime',context!),
        'Created': JsonConverters.toJson(Created,'DateTime',context!),
        'Training': Training,
        'Deleted': Deleted,
        'CoursesCompleted': CoursesCompleted,
        'DisplayHomeNotification': DisplayHomeNotification,
        'TwoFactorEnabled': TwoFactorEnabled,
        'EmailConfirmed': EmailConfirmed,
        'MobilePhoneConfirmed': MobilePhoneConfirmed,
        'Notifications': Notifications,
        'ChangePassword': JsonConverters.toJson(ChangePassword,'DateTime',context!),
        'Activated': JsonConverters.toJson(Activated,'DateTime',context!)
    };

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

class MessageInstance implements IConvertible
{
    int? MessageId;
    DateTime? DueDate;
    DateTime? SentDate;
    bool? Processed;
    int? Failures;
    int? InstanceId;
    String? MessageSid;
    MessageTemplateInstance? MessageTemplate;
    // @References(typeof(MessageTemplateInstance))
    int? MessageTemplateId;

    DateTime? OpenedDate;
    DateTime? BouncedDate;
    DateTime? DeliveredDate;
    DateTime? UnsubscribedDate;
    DateTime? SpamReportDate;
    UserInstance? User;
    // @References(typeof(UserInstance))
    int? UserId;

    int? InstanceType;

    MessageInstance({this.MessageId,this.DueDate,this.SentDate,this.Processed,this.Failures,this.InstanceId,this.MessageSid,this.MessageTemplate,this.MessageTemplateId,this.OpenedDate,this.BouncedDate,this.DeliveredDate,this.UnsubscribedDate,this.SpamReportDate,this.User,this.UserId,this.InstanceType});
    MessageInstance.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        MessageId = json['MessageId'];
        DueDate = JsonConverters.fromJson(json['DueDate'],'DateTime',context!);
        SentDate = JsonConverters.fromJson(json['SentDate'],'DateTime',context!);
        Processed = json['Processed'];
        Failures = json['Failures'];
        InstanceId = json['InstanceId'];
        MessageSid = json['MessageSid'];
        MessageTemplate = JsonConverters.fromJson(json['MessageTemplate'],'MessageTemplateInstance',context!);
        MessageTemplateId = json['MessageTemplateId'];
        OpenedDate = JsonConverters.fromJson(json['OpenedDate'],'DateTime',context!);
        BouncedDate = JsonConverters.fromJson(json['BouncedDate'],'DateTime',context!);
        DeliveredDate = JsonConverters.fromJson(json['DeliveredDate'],'DateTime',context!);
        UnsubscribedDate = JsonConverters.fromJson(json['UnsubscribedDate'],'DateTime',context!);
        SpamReportDate = JsonConverters.fromJson(json['SpamReportDate'],'DateTime',context!);
        User = JsonConverters.fromJson(json['User'],'UserInstance',context!);
        UserId = json['UserId'];
        InstanceType = json['InstanceType'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'MessageId': MessageId,
        'DueDate': JsonConverters.toJson(DueDate,'DateTime',context!),
        'SentDate': JsonConverters.toJson(SentDate,'DateTime',context!),
        'Processed': Processed,
        'Failures': Failures,
        'InstanceId': InstanceId,
        'MessageSid': MessageSid,
        'MessageTemplate': JsonConverters.toJson(MessageTemplate,'MessageTemplateInstance',context!),
        'MessageTemplateId': MessageTemplateId,
        'OpenedDate': JsonConverters.toJson(OpenedDate,'DateTime',context!),
        'BouncedDate': JsonConverters.toJson(BouncedDate,'DateTime',context!),
        'DeliveredDate': JsonConverters.toJson(DeliveredDate,'DateTime',context!),
        'UnsubscribedDate': JsonConverters.toJson(UnsubscribedDate,'DateTime',context!),
        'SpamReportDate': JsonConverters.toJson(SpamReportDate,'DateTime',context!),
        'User': JsonConverters.toJson(User,'UserInstance',context!),
        'UserId': UserId,
        'InstanceType': InstanceType
    };

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

// @AutoQueryViewer(Description="", IconUrl="octicon:database", Title="Message")
class FindMessage extends QueryDb<MessageInstance> implements IConvertible
{
    FindMessage();
    FindMessage.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() => "FindMessage";
    TypeContext? context = _ctx;
}

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

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

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

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

TypeContext _ctx = TypeContext(library: 'api.clubmanagercentral.com', types: <String, TypeInfo> {
    'MessageTemplateInstance': TypeInfo(TypeOf.Class, create:() => MessageTemplateInstance()),
    'UserInstance': TypeInfo(TypeOf.Class, create:() => UserInstance()),
    'MessageInstance': TypeInfo(TypeOf.Class, create:() => MessageInstance()),
    'FindMessage': TypeInfo(TypeOf.Class, create:() => FindMessage()),
    'List<MessageInstance>': TypeInfo(TypeOf.Class, create:() => <MessageInstance>[]),
});

Dart FindMessage 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 /api/Query/Message HTTP/1.1 
Host: api.clubmanagercentral.com 
Accept: application/xml
Content-Type: application/xml
Content-Length: length

<FindMessage xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/ClubManager.Api.Services.Query">
  <Skip xmlns="http://schemas.servicestack.net/types">0</Skip>
  <Take xmlns="http://schemas.servicestack.net/types">0</Take>
  <OrderBy xmlns="http://schemas.servicestack.net/types">String</OrderBy>
  <OrderByDesc xmlns="http://schemas.servicestack.net/types">String</OrderByDesc>
  <Include xmlns="http://schemas.servicestack.net/types">String</Include>
  <Fields xmlns="http://schemas.servicestack.net/types">String</Fields>
  <Meta xmlns:d2p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" xmlns="http://schemas.servicestack.net/types">
    <d2p1:KeyValueOfstringstring>
      <d2p1:Key>String</d2p1:Key>
      <d2p1:Value>String</d2p1:Value>
    </d2p1:KeyValueOfstringstring>
  </Meta>
</FindMessage>

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

<QueryResponseOfMessageInstancePEZRWkv_P 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/ClubManager.Api.Services.Query">
    <d2p1:MessageInstance>
      <d2p1:BouncedDate>0001-01-01T00:00:00</d2p1:BouncedDate>
      <d2p1:DeliveredDate>0001-01-01T00:00:00</d2p1:DeliveredDate>
      <d2p1:DueDate>0001-01-01T00:00:00</d2p1:DueDate>
      <d2p1:Failures>0</d2p1:Failures>
      <d2p1:InstanceId>0</d2p1:InstanceId>
      <d2p1:InstanceType>0</d2p1:InstanceType>
      <d2p1:MessageId>0</d2p1:MessageId>
      <d2p1:MessageSid>String</d2p1:MessageSid>
      <d2p1:MessageTemplate>
        <d2p1:Body>String</d2p1:Body>
        <d2p1:ContentType>0</d2p1:ContentType>
        <d2p1:Created>0001-01-01T00:00:00</d2p1:Created>
        <d2p1:CreatedBy>0</d2p1:CreatedBy>
        <d2p1:Deleted>0001-01-01T00:00:00</d2p1:Deleted>
        <d2p1:DeletedBy>0</d2p1:DeletedBy>
        <d2p1:EventType>0</d2p1:EventType>
        <d2p1:ExclusionTags>String</d2p1:ExclusionTags>
        <d2p1:Hidden>false</d2p1:Hidden>
        <d2p1:InclusionTags>String</d2p1:InclusionTags>
        <d2p1:MessageTemplateId>0</d2p1:MessageTemplateId>
        <d2p1:Modified>0001-01-01T00:00:00</d2p1:Modified>
        <d2p1:ModifiedBy>0</d2p1:ModifiedBy>
        <d2p1:Name>String</d2p1:Name>
        <d2p1:ParentMessageTemplateId>0</d2p1:ParentMessageTemplateId>
        <d2p1:ReportId>0</d2p1:ReportId>
        <d2p1:Subject>String</d2p1:Subject>
        <d2p1:TemplateType>0</d2p1:TemplateType>
      </d2p1:MessageTemplate>
      <d2p1:MessageTemplateId>0</d2p1:MessageTemplateId>
      <d2p1:OpenedDate>0001-01-01T00:00:00</d2p1:OpenedDate>
      <d2p1:Processed>false</d2p1:Processed>
      <d2p1:SentDate>0001-01-01T00:00:00</d2p1:SentDate>
      <d2p1:SpamReportDate>0001-01-01T00:00:00</d2p1:SpamReportDate>
      <d2p1:UnsubscribedDate>0001-01-01T00:00:00</d2p1:UnsubscribedDate>
      <d2p1:User>
        <d2p1:Activated>0001-01-01T00:00:00</d2p1:Activated>
        <d2p1:ChangePassword>0001-01-01T00:00:00</d2p1:ChangePassword>
        <d2p1:CoursesCompleted>0</d2p1:CoursesCompleted>
        <d2p1:Created>0001-01-01T00:00:00</d2p1:Created>
        <d2p1:Deleted>false</d2p1:Deleted>
        <d2p1:DisplayHomeNotification>false</d2p1:DisplayHomeNotification>
        <d2p1:Email>String</d2p1:Email>
        <d2p1:EmailConfirmed>false</d2p1:EmailConfirmed>
        <d2p1:Enabled>false</d2p1:Enabled>
        <d2p1:LastLogin>0001-01-01T00:00:00</d2p1:LastLogin>
        <d2p1:MobilePhone>String</d2p1:MobilePhone>
        <d2p1:MobilePhoneConfirmed>false</d2p1:MobilePhoneConfirmed>
        <d2p1:Name>String</d2p1:Name>
        <d2p1:Notifications>false</d2p1:Notifications>
        <d2p1:Training>false</d2p1:Training>
        <d2p1:TwoFactorEnabled>false</d2p1:TwoFactorEnabled>
        <d2p1:UserId>0</d2p1:UserId>
        <d2p1:UserName>String</d2p1:UserName>
      </d2p1:User>
      <d2p1:UserId>0</d2p1:UserId>
    </d2p1:MessageInstance>
  </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>
</QueryResponseOfMessageInstancePEZRWkv_P>