Trendsic Platform Service

RfpPricingRequest

**Requires Authentication**
Requires any of the roles:	Agent, Administrator

The following routes are available for this service:
GET,OPTIONS	/v1/Rfp/{RfpDocumentUID}/Pricing

import 'package:servicestack/servicestack.dart';

class CostRange implements IConvertible
{
    double? Min;
    double? Max;
    double? Mid;

    CostRange({this.Min,this.Max,this.Mid});
    CostRange.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Min = JsonConverters.toDouble(json['Min']);
        Max = JsonConverters.toDouble(json['Max']);
        Mid = JsonConverters.toDouble(json['Mid']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Min': Min,
        'Max': Max,
        'Mid': Mid
    };

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

class PricedPosition implements IConvertible
{
    String? PositionTag;
    double? Hours;
    bool? HasInternalRate;
    double? RateMin;
    double? RateMax;
    double? RateAvg;
    int? ContactCount;
    CostRange? Cost;
    double? MarketRateReference;

    PricedPosition({this.PositionTag,this.Hours,this.HasInternalRate,this.RateMin,this.RateMax,this.RateAvg,this.ContactCount,this.Cost,this.MarketRateReference});
    PricedPosition.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        PositionTag = json['PositionTag'];
        Hours = JsonConverters.toDouble(json['Hours']);
        HasInternalRate = json['HasInternalRate'];
        RateMin = JsonConverters.toDouble(json['RateMin']);
        RateMax = JsonConverters.toDouble(json['RateMax']);
        RateAvg = JsonConverters.toDouble(json['RateAvg']);
        ContactCount = json['ContactCount'];
        Cost = JsonConverters.fromJson(json['Cost'],'CostRange',context!);
        MarketRateReference = JsonConverters.toDouble(json['MarketRateReference']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'PositionTag': PositionTag,
        'Hours': Hours,
        'HasInternalRate': HasInternalRate,
        'RateMin': RateMin,
        'RateMax': RateMax,
        'RateAvg': RateAvg,
        'ContactCount': ContactCount,
        'Cost': JsonConverters.toJson(Cost,'CostRange',context!),
        'MarketRateReference': MarketRateReference
    };

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

class PricedEquipment implements IConvertible
{
    int? EquipmentID;
    String? EquipmentName;
    double? Quantity;
    double? DurationDays;
    String? RateType;
    double? BilledRate;
    double? CostRate;
    bool? HasRate;
    bool? IsInCatalog;
    double? Cost;
    double? CompanyCost;
    double? Margin;

    PricedEquipment({this.EquipmentID,this.EquipmentName,this.Quantity,this.DurationDays,this.RateType,this.BilledRate,this.CostRate,this.HasRate,this.IsInCatalog,this.Cost,this.CompanyCost,this.Margin});
    PricedEquipment.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        EquipmentID = json['EquipmentID'];
        EquipmentName = json['EquipmentName'];
        Quantity = JsonConverters.toDouble(json['Quantity']);
        DurationDays = JsonConverters.toDouble(json['DurationDays']);
        RateType = json['RateType'];
        BilledRate = JsonConverters.toDouble(json['BilledRate']);
        CostRate = JsonConverters.toDouble(json['CostRate']);
        HasRate = json['HasRate'];
        IsInCatalog = json['IsInCatalog'];
        Cost = JsonConverters.toDouble(json['Cost']);
        CompanyCost = JsonConverters.toDouble(json['CompanyCost']);
        Margin = JsonConverters.toDouble(json['Margin']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'EquipmentID': EquipmentID,
        'EquipmentName': EquipmentName,
        'Quantity': Quantity,
        'DurationDays': DurationDays,
        'RateType': RateType,
        'BilledRate': BilledRate,
        'CostRate': CostRate,
        'HasRate': HasRate,
        'IsInCatalog': IsInCatalog,
        'Cost': Cost,
        'CompanyCost': CompanyCost,
        'Margin': Margin
    };

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

class PricedMaterial implements IConvertible
{
    int? MaterialID;
    String? MaterialName;
    double? Quantity;
    double? UnitCost;
    bool? HasRate;
    bool? IsInCatalog;
    double? Cost;

    PricedMaterial({this.MaterialID,this.MaterialName,this.Quantity,this.UnitCost,this.HasRate,this.IsInCatalog,this.Cost});
    PricedMaterial.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        MaterialID = json['MaterialID'];
        MaterialName = json['MaterialName'];
        Quantity = JsonConverters.toDouble(json['Quantity']);
        UnitCost = JsonConverters.toDouble(json['UnitCost']);
        HasRate = json['HasRate'];
        IsInCatalog = json['IsInCatalog'];
        Cost = JsonConverters.toDouble(json['Cost']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'MaterialID': MaterialID,
        'MaterialName': MaterialName,
        'Quantity': Quantity,
        'UnitCost': UnitCost,
        'HasRate': HasRate,
        'IsInCatalog': IsInCatalog,
        'Cost': Cost
    };

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

class PricedTask implements IConvertible
{
    String? Name;
    String? Category;
    List<PricedPosition>? Positions = [];
    List<PricedEquipment>? Equipment = [];
    List<PricedMaterial>? Materials = [];
    CostRange? Subtotal;

    PricedTask({this.Name,this.Category,this.Positions,this.Equipment,this.Materials,this.Subtotal});
    PricedTask.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Name = json['Name'];
        Category = json['Category'];
        Positions = JsonConverters.fromJson(json['Positions'],'List<PricedPosition>',context!);
        Equipment = JsonConverters.fromJson(json['Equipment'],'List<PricedEquipment>',context!);
        Materials = JsonConverters.fromJson(json['Materials'],'List<PricedMaterial>',context!);
        Subtotal = JsonConverters.fromJson(json['Subtotal'],'CostRange',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Name': Name,
        'Category': Category,
        'Positions': JsonConverters.toJson(Positions,'List<PricedPosition>',context!),
        'Equipment': JsonConverters.toJson(Equipment,'List<PricedEquipment>',context!),
        'Materials': JsonConverters.toJson(Materials,'List<PricedMaterial>',context!),
        'Subtotal': JsonConverters.toJson(Subtotal,'CostRange',context!)
    };

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

class PricedProposal implements IConvertible
{
    int? RfpDocumentID;
    String? ProjectName;
    String? Currency;
    List<PricedTask>? Tasks = [];
    CostRange? Total;
    int? PositionsNeedingRate;
    int? EquipmentNotInCatalog;
    int? MaterialsNotInCatalog;
    int? PositionsNotInCatalog;
    double? EquipmentMargin;

    PricedProposal({this.RfpDocumentID,this.ProjectName,this.Currency,this.Tasks,this.Total,this.PositionsNeedingRate,this.EquipmentNotInCatalog,this.MaterialsNotInCatalog,this.PositionsNotInCatalog,this.EquipmentMargin});
    PricedProposal.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        RfpDocumentID = json['RfpDocumentID'];
        ProjectName = json['ProjectName'];
        Currency = json['Currency'];
        Tasks = JsonConverters.fromJson(json['Tasks'],'List<PricedTask>',context!);
        Total = JsonConverters.fromJson(json['Total'],'CostRange',context!);
        PositionsNeedingRate = json['PositionsNeedingRate'];
        EquipmentNotInCatalog = json['EquipmentNotInCatalog'];
        MaterialsNotInCatalog = json['MaterialsNotInCatalog'];
        PositionsNotInCatalog = json['PositionsNotInCatalog'];
        EquipmentMargin = JsonConverters.toDouble(json['EquipmentMargin']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'RfpDocumentID': RfpDocumentID,
        'ProjectName': ProjectName,
        'Currency': Currency,
        'Tasks': JsonConverters.toJson(Tasks,'List<PricedTask>',context!),
        'Total': JsonConverters.toJson(Total,'CostRange',context!),
        'PositionsNeedingRate': PositionsNeedingRate,
        'EquipmentNotInCatalog': EquipmentNotInCatalog,
        'MaterialsNotInCatalog': MaterialsNotInCatalog,
        'PositionsNotInCatalog': PositionsNotInCatalog,
        'EquipmentMargin': EquipmentMargin
    };

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

class RfpPricingResponse implements IConvertible
{
    ResponseStatus? ResponseStatus;
    int? RfpDocumentID;
    PricedProposal? Pricing;

    RfpPricingResponse({this.ResponseStatus,this.RfpDocumentID,this.Pricing});
    RfpPricingResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'ResponseStatus': JsonConverters.toJson(ResponseStatus,'ResponseStatus',context!),
        'RfpDocumentID': RfpDocumentID,
        'Pricing': JsonConverters.toJson(Pricing,'PricedProposal',context!)
    };

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

class RfpPricingRequest implements IConvertible
{
    String? RfpDocumentUID;

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

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

    Map<String, dynamic> toJson() => {
        'RfpDocumentUID': RfpDocumentUID
    };

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

TypeContext _ctx = TypeContext(library: 'api.dev.dynamics.trendsic.com', types: <String, TypeInfo> {
    'CostRange': TypeInfo(TypeOf.Class, create:() => CostRange()),
    'PricedPosition': TypeInfo(TypeOf.Class, create:() => PricedPosition()),
    'PricedEquipment': TypeInfo(TypeOf.Class, create:() => PricedEquipment()),
    'PricedMaterial': TypeInfo(TypeOf.Class, create:() => PricedMaterial()),
    'PricedTask': TypeInfo(TypeOf.Class, create:() => PricedTask()),
    'List<PricedPosition>': TypeInfo(TypeOf.Class, create:() => <PricedPosition>[]),
    'List<PricedEquipment>': TypeInfo(TypeOf.Class, create:() => <PricedEquipment>[]),
    'List<PricedMaterial>': TypeInfo(TypeOf.Class, create:() => <PricedMaterial>[]),
    'PricedProposal': TypeInfo(TypeOf.Class, create:() => PricedProposal()),
    'List<PricedTask>': TypeInfo(TypeOf.Class, create:() => <PricedTask>[]),
    'RfpPricingResponse': TypeInfo(TypeOf.Class, create:() => RfpPricingResponse()),
    'RfpPricingRequest': TypeInfo(TypeOf.Class, create:() => RfpPricingRequest()),
});

Dart RfpPricingRequest 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/Rfp/{RfpDocumentUID}/Pricing HTTP/1.1 
Host: api.dev.dynamics.trendsic.com 
Accept: application/xml

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

<RfpPricingResponse xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/CRM.AgencyPlatform.API.Internal">
  <Pricing>
    <Currency>String</Currency>
    <EquipmentMargin>0</EquipmentMargin>
    <EquipmentNotInCatalog>0</EquipmentNotInCatalog>
    <MaterialsNotInCatalog>0</MaterialsNotInCatalog>
    <PositionsNeedingRate>0</PositionsNeedingRate>
    <PositionsNotInCatalog>0</PositionsNotInCatalog>
    <ProjectName>String</ProjectName>
    <RfpDocumentID>0</RfpDocumentID>
    <Tasks>
      <PricedTask>
        <Category>String</Category>
        <Equipment>
          <PricedEquipment>
            <BilledRate>0</BilledRate>
            <CompanyCost>0</CompanyCost>
            <Cost>0</Cost>
            <CostRate>0</CostRate>
            <DurationDays>0</DurationDays>
            <EquipmentID>0</EquipmentID>
            <EquipmentName>String</EquipmentName>
            <HasRate>false</HasRate>
            <IsInCatalog>false</IsInCatalog>
            <Quantity>0</Quantity>
            <RateType>String</RateType>
          </PricedEquipment>
        </Equipment>
        <Materials>
          <PricedMaterial>
            <Cost>0</Cost>
            <HasRate>false</HasRate>
            <IsInCatalog>false</IsInCatalog>
            <MaterialID>0</MaterialID>
            <MaterialName>String</MaterialName>
            <Quantity>0</Quantity>
            <UnitCost>0</UnitCost>
          </PricedMaterial>
        </Materials>
        <Name>String</Name>
        <Positions>
          <PricedPosition>
            <ContactCount>0</ContactCount>
            <Cost>
              <Max>0</Max>
              <Min>0</Min>
            </Cost>
            <HasInternalRate>false</HasInternalRate>
            <Hours>0</Hours>
            <MarketRateReference>0</MarketRateReference>
            <PositionTag>String</PositionTag>
            <RateAvg>0</RateAvg>
            <RateMax>0</RateMax>
            <RateMin>0</RateMin>
          </PricedPosition>
        </Positions>
        <Subtotal>
          <Max>0</Max>
          <Min>0</Min>
        </Subtotal>
      </PricedTask>
    </Tasks>
    <Total>
      <Max>0</Max>
      <Min>0</Min>
    </Total>
  </Pricing>
  <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>
  <RfpDocumentID>0</RfpDocumentID>
</RfpPricingResponse>