Trendsic Platform Service

PlanningRequest

The following routes are available for this service:
GET	/v1/workforce/planning

import 'package:servicestack/servicestack.dart';

class OtRow implements IConvertible
{
    int? ContactID;
    String? WorkerName;
    String? ClassCode;
    String? Crew;
    String? Job;
    String? PatternLabel;
    double? ProjHours;
    double? OtHours;
    double? DtHours;
    double? OtCost;
    String? State;
    String? Tone;

    OtRow({this.ContactID,this.WorkerName,this.ClassCode,this.Crew,this.Job,this.PatternLabel,this.ProjHours,this.OtHours,this.DtHours,this.OtCost,this.State,this.Tone});
    OtRow.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ContactID = json['ContactID'];
        WorkerName = json['WorkerName'];
        ClassCode = json['ClassCode'];
        Crew = json['Crew'];
        Job = json['Job'];
        PatternLabel = json['PatternLabel'];
        ProjHours = JsonConverters.toDouble(json['ProjHours']);
        OtHours = JsonConverters.toDouble(json['OtHours']);
        DtHours = JsonConverters.toDouble(json['DtHours']);
        OtCost = JsonConverters.toDouble(json['OtCost']);
        State = json['State'];
        Tone = json['Tone'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ContactID': ContactID,
        'WorkerName': WorkerName,
        'ClassCode': ClassCode,
        'Crew': Crew,
        'Job': Job,
        'PatternLabel': PatternLabel,
        'ProjHours': ProjHours,
        'OtHours': OtHours,
        'DtHours': DtHours,
        'OtCost': OtCost,
        'State': State,
        'Tone': Tone
    };

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

class OtExposureBoard implements IConvertible
{
    double? TotalOtCost;
    double? TotalOtHours;
    int? OverCount;
    int? WorkerCount;
    List<OtRow>? Rows = [];

    OtExposureBoard({this.TotalOtCost,this.TotalOtHours,this.OverCount,this.WorkerCount,this.Rows});
    OtExposureBoard.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        TotalOtCost = JsonConverters.toDouble(json['TotalOtCost']);
        TotalOtHours = JsonConverters.toDouble(json['TotalOtHours']);
        OverCount = json['OverCount'];
        WorkerCount = json['WorkerCount'];
        Rows = JsonConverters.fromJson(json['Rows'],'List<OtRow>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'TotalOtCost': TotalOtCost,
        'TotalOtHours': TotalOtHours,
        'OverCount': OverCount,
        'WorkerCount': WorkerCount,
        'Rows': JsonConverters.toJson(Rows,'List<OtRow>',context!)
    };

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

class PerDiemJobRow implements IConvertible
{
    String? Job;
    double? Total;
    double? NonTax;
    double? Tax;
    int? Days;
    int? AwayCount;
    bool? DayRateFlag;

    PerDiemJobRow({this.Job,this.Total,this.NonTax,this.Tax,this.Days,this.AwayCount,this.DayRateFlag});
    PerDiemJobRow.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Job = json['Job'];
        Total = JsonConverters.toDouble(json['Total']);
        NonTax = JsonConverters.toDouble(json['NonTax']);
        Tax = JsonConverters.toDouble(json['Tax']);
        Days = json['Days'];
        AwayCount = json['AwayCount'];
        DayRateFlag = json['DayRateFlag'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Job': Job,
        'Total': Total,
        'NonTax': NonTax,
        'Tax': Tax,
        'Days': Days,
        'AwayCount': AwayCount,
        'DayRateFlag': DayRateFlag
    };

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

class PerDiemBoard implements IConvertible
{
    double? TotalCost;
    double? NonTaxable;
    double? Taxable;
    int? AwayCount;
    List<PerDiemJobRow>? Jobs = [];

    PerDiemBoard({this.TotalCost,this.NonTaxable,this.Taxable,this.AwayCount,this.Jobs});
    PerDiemBoard.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        TotalCost = JsonConverters.toDouble(json['TotalCost']);
        NonTaxable = JsonConverters.toDouble(json['NonTaxable']);
        Taxable = JsonConverters.toDouble(json['Taxable']);
        AwayCount = json['AwayCount'];
        Jobs = JsonConverters.fromJson(json['Jobs'],'List<PerDiemJobRow>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'TotalCost': TotalCost,
        'NonTaxable': NonTaxable,
        'Taxable': Taxable,
        'AwayCount': AwayCount,
        'Jobs': JsonConverters.toJson(Jobs,'List<PerDiemJobRow>',context!)
    };

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

class MarginJobRow implements IConvertible
{
    String? Job;
    double? BasePct;
    double? ProjPct;
    double? FadePts;
    String? Severity;
    double? OtCost;
    double? PerDiem;

    MarginJobRow({this.Job,this.BasePct,this.ProjPct,this.FadePts,this.Severity,this.OtCost,this.PerDiem});
    MarginJobRow.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Job = json['Job'];
        BasePct = JsonConverters.toDouble(json['BasePct']);
        ProjPct = JsonConverters.toDouble(json['ProjPct']);
        FadePts = JsonConverters.toDouble(json['FadePts']);
        Severity = json['Severity'];
        OtCost = JsonConverters.toDouble(json['OtCost']);
        PerDiem = JsonConverters.toDouble(json['PerDiem']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Job': Job,
        'BasePct': BasePct,
        'ProjPct': ProjPct,
        'FadePts': FadePts,
        'Severity': Severity,
        'OtCost': OtCost,
        'PerDiem': PerDiem
    };

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

class MarginBoard implements IConvertible
{
    int? JobCount;
    double? TotalFade;
    List<MarginJobRow>? Jobs = [];

    MarginBoard({this.JobCount,this.TotalFade,this.Jobs});
    MarginBoard.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        JobCount = json['JobCount'];
        TotalFade = JsonConverters.toDouble(json['TotalFade']);
        Jobs = JsonConverters.fromJson(json['Jobs'],'List<MarginJobRow>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'JobCount': JobCount,
        'TotalFade': TotalFade,
        'Jobs': JsonConverters.toJson(Jobs,'List<MarginJobRow>',context!)
    };

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

class UtilRow implements IConvertible
{
    int? ContactID;
    String? WorkerName;
    String? Crew;
    double? ProjHours;
    double? BaselineHours;
    double? Pct;
    String? Band;

    UtilRow({this.ContactID,this.WorkerName,this.Crew,this.ProjHours,this.BaselineHours,this.Pct,this.Band});
    UtilRow.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ContactID = json['ContactID'];
        WorkerName = json['WorkerName'];
        Crew = json['Crew'];
        ProjHours = JsonConverters.toDouble(json['ProjHours']);
        BaselineHours = JsonConverters.toDouble(json['BaselineHours']);
        Pct = JsonConverters.toDouble(json['Pct']);
        Band = json['Band'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ContactID': ContactID,
        'WorkerName': WorkerName,
        'Crew': Crew,
        'ProjHours': ProjHours,
        'BaselineHours': BaselineHours,
        'Pct': Pct,
        'Band': Band
    };

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

class UtilizationBoard implements IConvertible
{
    int? UnderCount;
    int? OverCount;
    List<UtilRow>? Rows = [];

    UtilizationBoard({this.UnderCount,this.OverCount,this.Rows});
    UtilizationBoard.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        UnderCount = json['UnderCount'];
        OverCount = json['OverCount'];
        Rows = JsonConverters.fromJson(json['Rows'],'List<UtilRow>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'UnderCount': UnderCount,
        'OverCount': OverCount,
        'Rows': JsonConverters.toJson(Rows,'List<UtilRow>',context!)
    };

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

class PlanningSuggestion implements IConvertible
{
    String? Id;
    String? Kind;
    String? Title;
    String? Detail;
    String? SaveText;
    String? Effect;
    String? RuleId;
    String? LegalNote;
    String? ApplyLabel;
    String? Severity;

    PlanningSuggestion({this.Id,this.Kind,this.Title,this.Detail,this.SaveText,this.Effect,this.RuleId,this.LegalNote,this.ApplyLabel,this.Severity});
    PlanningSuggestion.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Id = json['Id'];
        Kind = json['Kind'];
        Title = json['Title'];
        Detail = json['Detail'];
        SaveText = json['SaveText'];
        Effect = json['Effect'];
        RuleId = json['RuleId'];
        LegalNote = json['LegalNote'];
        ApplyLabel = json['ApplyLabel'];
        Severity = json['Severity'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Id': Id,
        'Kind': Kind,
        'Title': Title,
        'Detail': Detail,
        'SaveText': SaveText,
        'Effect': Effect,
        'RuleId': RuleId,
        'LegalNote': LegalNote,
        'ApplyLabel': ApplyLabel,
        'Severity': Severity
    };

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

class PlanningSurface implements IConvertible
{
    String? WeekLabel;
    DateTime? WeekStart;
    int? WorkerCount;
    OtExposureBoard? Ot;
    PerDiemBoard? PerDiem;
    MarginBoard? Margin;
    UtilizationBoard? Utilization;
    List<PlanningSuggestion>? Suggestions = [];

    PlanningSurface({this.WeekLabel,this.WeekStart,this.WorkerCount,this.Ot,this.PerDiem,this.Margin,this.Utilization,this.Suggestions});
    PlanningSurface.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        WeekLabel = json['WeekLabel'];
        WeekStart = JsonConverters.fromJson(json['WeekStart'],'DateTime',context!);
        WorkerCount = json['WorkerCount'];
        Ot = JsonConverters.fromJson(json['Ot'],'OtExposureBoard',context!);
        PerDiem = JsonConverters.fromJson(json['PerDiem'],'PerDiemBoard',context!);
        Margin = JsonConverters.fromJson(json['Margin'],'MarginBoard',context!);
        Utilization = JsonConverters.fromJson(json['Utilization'],'UtilizationBoard',context!);
        Suggestions = JsonConverters.fromJson(json['Suggestions'],'List<PlanningSuggestion>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'WeekLabel': WeekLabel,
        'WeekStart': JsonConverters.toJson(WeekStart,'DateTime',context!),
        'WorkerCount': WorkerCount,
        'Ot': JsonConverters.toJson(Ot,'OtExposureBoard',context!),
        'PerDiem': JsonConverters.toJson(PerDiem,'PerDiemBoard',context!),
        'Margin': JsonConverters.toJson(Margin,'MarginBoard',context!),
        'Utilization': JsonConverters.toJson(Utilization,'UtilizationBoard',context!),
        'Suggestions': JsonConverters.toJson(Suggestions,'List<PlanningSuggestion>',context!)
    };

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

class PlanningResponse implements IConvertible
{
    PlanningSurface? Surface;
    bool? CanSeePay;
    ResponseStatus? ResponseStatus;

    PlanningResponse({this.Surface,this.CanSeePay,this.ResponseStatus});
    PlanningResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'Surface': JsonConverters.toJson(Surface,'PlanningSurface',context!),
        'CanSeePay': CanSeePay,
        'ResponseStatus': JsonConverters.toJson(ResponseStatus,'ResponseStatus',context!)
    };

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

class PlanningRequest implements IConvertible
{
    DateTime? AsOf;

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

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

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

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

TypeContext _ctx = TypeContext(library: 'api.dev.dynamics.trendsic.com', types: <String, TypeInfo> {
    'OtRow': TypeInfo(TypeOf.Class, create:() => OtRow()),
    'OtExposureBoard': TypeInfo(TypeOf.Class, create:() => OtExposureBoard()),
    'List<OtRow>': TypeInfo(TypeOf.Class, create:() => <OtRow>[]),
    'PerDiemJobRow': TypeInfo(TypeOf.Class, create:() => PerDiemJobRow()),
    'PerDiemBoard': TypeInfo(TypeOf.Class, create:() => PerDiemBoard()),
    'List<PerDiemJobRow>': TypeInfo(TypeOf.Class, create:() => <PerDiemJobRow>[]),
    'MarginJobRow': TypeInfo(TypeOf.Class, create:() => MarginJobRow()),
    'MarginBoard': TypeInfo(TypeOf.Class, create:() => MarginBoard()),
    'List<MarginJobRow>': TypeInfo(TypeOf.Class, create:() => <MarginJobRow>[]),
    'UtilRow': TypeInfo(TypeOf.Class, create:() => UtilRow()),
    'UtilizationBoard': TypeInfo(TypeOf.Class, create:() => UtilizationBoard()),
    'List<UtilRow>': TypeInfo(TypeOf.Class, create:() => <UtilRow>[]),
    'PlanningSuggestion': TypeInfo(TypeOf.Class, create:() => PlanningSuggestion()),
    'PlanningSurface': TypeInfo(TypeOf.Class, create:() => PlanningSurface()),
    'List<PlanningSuggestion>': TypeInfo(TypeOf.Class, create:() => <PlanningSuggestion>[]),
    'PlanningResponse': TypeInfo(TypeOf.Class, create:() => PlanningResponse()),
    'PlanningRequest': TypeInfo(TypeOf.Class, create:() => PlanningRequest()),
});

Dart PlanningRequest 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 /v1/workforce/planning HTTP/1.1 
Host: api.dev.dynamics.trendsic.com 
Accept: application/xml

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

<PlanningResponse xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/CRM.AgencyPlatform.API.Internal">
  <CanSeePay>false</CanSeePay>
  <ResponseStatus xmlns:d2p1="http://schemas.servicestack.net/types">
    <d2p1:ErrorCode>String</d2p1:ErrorCode>
    <d2p1:Message>String</d2p1:Message>
    <d2p1:StackTrace>String</d2p1:StackTrace>
    <d2p1:Errors>
      <d2p1:ResponseError>
        <d2p1:ErrorCode>String</d2p1:ErrorCode>
        <d2p1:FieldName>String</d2p1:FieldName>
        <d2p1:Message>String</d2p1:Message>
        <d2p1: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>
        </d2p1:Meta>
      </d2p1:ResponseError>
    </d2p1:Errors>
    <d2p1: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>
    </d2p1:Meta>
  </ResponseStatus>
  <Surface>
    <Margin>
      <JobCount>0</JobCount>
      <Jobs>
        <MarginJobRow>
          <BasePct>0</BasePct>
          <FadePts>0</FadePts>
          <Job>String</Job>
          <OtCost>0</OtCost>
          <PerDiem>0</PerDiem>
          <ProjPct>0</ProjPct>
          <Severity>String</Severity>
        </MarginJobRow>
      </Jobs>
      <TotalFade>0</TotalFade>
    </Margin>
    <Ot>
      <OverCount>0</OverCount>
      <Rows>
        <OtRow>
          <ClassCode>String</ClassCode>
          <ContactID>0</ContactID>
          <Crew>String</Crew>
          <DtHours>0</DtHours>
          <Job>String</Job>
          <OtCost>0</OtCost>
          <OtHours>0</OtHours>
          <PatternLabel>String</PatternLabel>
          <ProjHours>0</ProjHours>
          <State>String</State>
          <Tone>String</Tone>
          <WorkerName>String</WorkerName>
        </OtRow>
      </Rows>
      <TotalOtCost>0</TotalOtCost>
      <TotalOtHours>0</TotalOtHours>
      <WorkerCount>0</WorkerCount>
    </Ot>
    <PerDiem>
      <AwayCount>0</AwayCount>
      <Jobs>
        <PerDiemJobRow>
          <AwayCount>0</AwayCount>
          <DayRateFlag>false</DayRateFlag>
          <Days>0</Days>
          <Job>String</Job>
          <NonTax>0</NonTax>
          <Tax>0</Tax>
          <Total>0</Total>
        </PerDiemJobRow>
      </Jobs>
      <NonTaxable>0</NonTaxable>
      <Taxable>0</Taxable>
      <TotalCost>0</TotalCost>
    </PerDiem>
    <Suggestions>
      <PlanningSuggestion>
        <ApplyLabel>String</ApplyLabel>
        <Detail>String</Detail>
        <Effect>String</Effect>
        <Id>String</Id>
        <Kind>String</Kind>
        <LegalNote>String</LegalNote>
        <RuleId>String</RuleId>
        <SaveText>String</SaveText>
        <Severity>String</Severity>
        <Title>String</Title>
      </PlanningSuggestion>
    </Suggestions>
    <Utilization>
      <OverCount>0</OverCount>
      <Rows>
        <UtilRow>
          <Band>String</Band>
          <BaselineHours>0</BaselineHours>
          <ContactID>0</ContactID>
          <Crew>String</Crew>
          <Pct>0</Pct>
          <ProjHours>0</ProjHours>
          <WorkerName>String</WorkerName>
        </UtilRow>
      </Rows>
      <UnderCount>0</UnderCount>
    </Utilization>
    <WeekLabel>String</WeekLabel>
    <WeekStart>0001-01-01T00:00:00</WeekStart>
    <WorkerCount>0</WorkerCount>
  </Surface>
</PlanningResponse>