| Requires any of the roles: | Agent, Administrator |
| POST,OPTIONS | /v1/Rfp/{RfpDocumentUID}/Estimate/Subcontracts |
|---|
import 'package:servicestack/servicestack.dart';
import 'dart:typed_data';
class EstimateSettingsView implements IConvertible
{
int? RfpEstimateID;
DateTime? StartDate;
DateTime? DeadlineDate;
int? WorkdaysPerWeek;
double? HoursPerDay;
double? WeatherPct;
double? OhpPct;
double? ContingencyPct;
double? BondPct;
List<DateTime>? Holidays = [];
DateTime? AppliedStartDate;
EstimateSettingsView({this.RfpEstimateID,this.StartDate,this.DeadlineDate,this.WorkdaysPerWeek,this.HoursPerDay,this.WeatherPct,this.OhpPct,this.ContingencyPct,this.BondPct,this.Holidays,this.AppliedStartDate});
EstimateSettingsView.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
RfpEstimateID = json['RfpEstimateID'];
StartDate = JsonConverters.fromJson(json['StartDate'],'DateTime',context!);
DeadlineDate = JsonConverters.fromJson(json['DeadlineDate'],'DateTime',context!);
WorkdaysPerWeek = json['WorkdaysPerWeek'];
HoursPerDay = JsonConverters.toDouble(json['HoursPerDay']);
WeatherPct = JsonConverters.toDouble(json['WeatherPct']);
OhpPct = JsonConverters.toDouble(json['OhpPct']);
ContingencyPct = JsonConverters.toDouble(json['ContingencyPct']);
BondPct = JsonConverters.toDouble(json['BondPct']);
Holidays = JsonConverters.fromJson(json['Holidays'],'List<DateTime>',context!);
AppliedStartDate = JsonConverters.fromJson(json['AppliedStartDate'],'DateTime',context!);
return this;
}
Map<String, dynamic> toJson() => {
'RfpEstimateID': RfpEstimateID,
'StartDate': JsonConverters.toJson(StartDate,'DateTime',context!),
'DeadlineDate': JsonConverters.toJson(DeadlineDate,'DateTime',context!),
'WorkdaysPerWeek': WorkdaysPerWeek,
'HoursPerDay': HoursPerDay,
'WeatherPct': WeatherPct,
'OhpPct': OhpPct,
'ContingencyPct': ContingencyPct,
'BondPct': BondPct,
'Holidays': JsonConverters.toJson(Holidays,'List<DateTime>',context!),
'AppliedStartDate': JsonConverters.toJson(AppliedStartDate,'DateTime',context!)
};
getTypeName() => "EstimateSettingsView";
TypeContext? context = _ctx;
}
class SpecRefView implements IConvertible
{
String? Section;
String? Title;
String? Url;
SpecRefView({this.Section,this.Title,this.Url});
SpecRefView.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Section = json['Section'];
Title = json['Title'];
Url = json['Url'];
return this;
}
Map<String, dynamic> toJson() => {
'Section': Section,
'Title': Title,
'Url': Url
};
getTypeName() => "SpecRefView";
TypeContext? context = _ctx;
}
class DodItemView implements IConvertible
{
String? Key;
String? Text;
bool? Checked;
String? Source;
DodItemView({this.Key,this.Text,this.Checked,this.Source});
DodItemView.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Key = json['Key'];
Text = json['Text'];
Checked = json['Checked'];
Source = json['Source'];
return this;
}
Map<String, dynamic> toJson() => {
'Key': Key,
'Text': Text,
'Checked': Checked,
'Source': Source
};
getTypeName() => "DodItemView";
TypeContext? context = _ctx;
}
class WorkPackageView implements IConvertible
{
bool? HasPackage;
String? Scope;
String? LimitsOfWork;
List<SpecRefView>? SpecRefs = [];
List<String>? Constraints = [];
List<String>? HoldPoints = [];
List<DodItemView>? Dod = [];
String? SafetyNote;
String? Provenance;
String? SpecBook;
bool? UserEdited;
String? RedraftNote;
WorkPackageView({this.HasPackage,this.Scope,this.LimitsOfWork,this.SpecRefs,this.Constraints,this.HoldPoints,this.Dod,this.SafetyNote,this.Provenance,this.SpecBook,this.UserEdited,this.RedraftNote});
WorkPackageView.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
HasPackage = json['HasPackage'];
Scope = json['Scope'];
LimitsOfWork = json['LimitsOfWork'];
SpecRefs = JsonConverters.fromJson(json['SpecRefs'],'List<SpecRefView>',context!);
Constraints = JsonConverters.fromJson(json['Constraints'],'List<String>',context!);
HoldPoints = JsonConverters.fromJson(json['HoldPoints'],'List<String>',context!);
Dod = JsonConverters.fromJson(json['Dod'],'List<DodItemView>',context!);
SafetyNote = json['SafetyNote'];
Provenance = json['Provenance'];
SpecBook = json['SpecBook'];
UserEdited = json['UserEdited'];
RedraftNote = json['RedraftNote'];
return this;
}
Map<String, dynamic> toJson() => {
'HasPackage': HasPackage,
'Scope': Scope,
'LimitsOfWork': LimitsOfWork,
'SpecRefs': JsonConverters.toJson(SpecRefs,'List<SpecRefView>',context!),
'Constraints': JsonConverters.toJson(Constraints,'List<String>',context!),
'HoldPoints': JsonConverters.toJson(HoldPoints,'List<String>',context!),
'Dod': JsonConverters.toJson(Dod,'List<DodItemView>',context!),
'SafetyNote': SafetyNote,
'Provenance': Provenance,
'SpecBook': SpecBook,
'UserEdited': UserEdited,
'RedraftNote': RedraftNote
};
getTypeName() => "WorkPackageView";
TypeContext? context = _ctx;
}
class EstimateCrewLineView implements IConvertible
{
String? Role;
double? Hours;
double? StHours;
double? OtHours;
bool? HasOt;
bool? PremiumApplied;
bool? NeedsRate;
String? RateKey;
String? Chip;
double? Rrop;
double? StCost;
double? OtCost;
double? Cost;
double? FringeCost;
EstimateCrewLineView({this.Role,this.Hours,this.StHours,this.OtHours,this.HasOt,this.PremiumApplied,this.NeedsRate,this.RateKey,this.Chip,this.Rrop,this.StCost,this.OtCost,this.Cost,this.FringeCost});
EstimateCrewLineView.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Role = json['Role'];
Hours = JsonConverters.toDouble(json['Hours']);
StHours = JsonConverters.toDouble(json['StHours']);
OtHours = JsonConverters.toDouble(json['OtHours']);
HasOt = json['HasOt'];
PremiumApplied = json['PremiumApplied'];
NeedsRate = json['NeedsRate'];
RateKey = json['RateKey'];
Chip = json['Chip'];
Rrop = JsonConverters.toDouble(json['Rrop']);
StCost = JsonConverters.toDouble(json['StCost']);
OtCost = JsonConverters.toDouble(json['OtCost']);
Cost = JsonConverters.toDouble(json['Cost']);
FringeCost = JsonConverters.toDouble(json['FringeCost']);
return this;
}
Map<String, dynamic> toJson() => {
'Role': Role,
'Hours': Hours,
'StHours': StHours,
'OtHours': OtHours,
'HasOt': HasOt,
'PremiumApplied': PremiumApplied,
'NeedsRate': NeedsRate,
'RateKey': RateKey,
'Chip': Chip,
'Rrop': Rrop,
'StCost': StCost,
'OtCost': OtCost,
'Cost': Cost,
'FringeCost': FringeCost
};
getTypeName() => "EstimateCrewLineView";
TypeContext? context = _ctx;
}
class EstimateEquipmentLineView implements IConvertible
{
String? Name;
double? Quantity;
double? Rate;
bool? NeedsRate;
double? MobCost;
double? Cost;
bool? IsAvailabilityTracked;
bool? IsOwned;
String? AvailabilityLabel;
String? FreedFromProject;
DateTime? AvailableFrom;
String? RateKey;
String? Chip;
String? RentalExplain;
double? UsageDays;
double? BilledDays;
EstimateEquipmentLineView({this.Name,this.Quantity,this.Rate,this.NeedsRate,this.MobCost,this.Cost,this.IsAvailabilityTracked,this.IsOwned,this.AvailabilityLabel,this.FreedFromProject,this.AvailableFrom,this.RateKey,this.Chip,this.RentalExplain,this.UsageDays,this.BilledDays});
EstimateEquipmentLineView.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Name = json['Name'];
Quantity = JsonConverters.toDouble(json['Quantity']);
Rate = JsonConverters.toDouble(json['Rate']);
NeedsRate = json['NeedsRate'];
MobCost = JsonConverters.toDouble(json['MobCost']);
Cost = JsonConverters.toDouble(json['Cost']);
IsAvailabilityTracked = json['IsAvailabilityTracked'];
IsOwned = json['IsOwned'];
AvailabilityLabel = json['AvailabilityLabel'];
FreedFromProject = json['FreedFromProject'];
AvailableFrom = JsonConverters.fromJson(json['AvailableFrom'],'DateTime',context!);
RateKey = json['RateKey'];
Chip = json['Chip'];
RentalExplain = json['RentalExplain'];
UsageDays = JsonConverters.toDouble(json['UsageDays']);
BilledDays = JsonConverters.toDouble(json['BilledDays']);
return this;
}
Map<String, dynamic> toJson() => {
'Name': Name,
'Quantity': Quantity,
'Rate': Rate,
'NeedsRate': NeedsRate,
'MobCost': MobCost,
'Cost': Cost,
'IsAvailabilityTracked': IsAvailabilityTracked,
'IsOwned': IsOwned,
'AvailabilityLabel': AvailabilityLabel,
'FreedFromProject': FreedFromProject,
'AvailableFrom': JsonConverters.toJson(AvailableFrom,'DateTime',context!),
'RateKey': RateKey,
'Chip': Chip,
'RentalExplain': RentalExplain,
'UsageDays': UsageDays,
'BilledDays': BilledDays
};
getTypeName() => "EstimateEquipmentLineView";
TypeContext? context = _ctx;
}
class EstimateMaterialLineView implements IConvertible
{
String? Name;
double? Quantity;
String? Unit;
double? Rate;
bool? NeedsRate;
double? Cost;
String? RateKey;
String? Chip;
EstimateMaterialLineView({this.Name,this.Quantity,this.Unit,this.Rate,this.NeedsRate,this.Cost,this.RateKey,this.Chip});
EstimateMaterialLineView.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Name = json['Name'];
Quantity = JsonConverters.toDouble(json['Quantity']);
Unit = json['Unit'];
Rate = JsonConverters.toDouble(json['Rate']);
NeedsRate = json['NeedsRate'];
Cost = JsonConverters.toDouble(json['Cost']);
RateKey = json['RateKey'];
Chip = json['Chip'];
return this;
}
Map<String, dynamic> toJson() => {
'Name': Name,
'Quantity': Quantity,
'Unit': Unit,
'Rate': Rate,
'NeedsRate': NeedsRate,
'Cost': Cost,
'RateKey': RateKey,
'Chip': Chip
};
getTypeName() => "EstimateMaterialLineView";
TypeContext? context = _ctx;
}
class EstimateSubcontractView implements IConvertible
{
int? EstimateSubcontractID;
int? TaskSeq;
String? Vendor;
double? Amount;
String? Scope;
EstimateSubcontractView({this.EstimateSubcontractID,this.TaskSeq,this.Vendor,this.Amount,this.Scope});
EstimateSubcontractView.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
EstimateSubcontractID = json['EstimateSubcontractID'];
TaskSeq = json['TaskSeq'];
Vendor = json['Vendor'];
Amount = JsonConverters.toDouble(json['Amount']);
Scope = json['Scope'];
return this;
}
Map<String, dynamic> toJson() => {
'EstimateSubcontractID': EstimateSubcontractID,
'TaskSeq': TaskSeq,
'Vendor': Vendor,
'Amount': Amount,
'Scope': Scope
};
getTypeName() => "EstimateSubcontractView";
TypeContext? context = _ctx;
}
class EstimateJobView implements IConvertible
{
int? Seq;
WorkPackageView? WorkPackage;
String? ItemNo;
String? Name;
String? Category;
String? SourceRef;
String? Unit;
double? Quantity;
String? PatternCode;
int? Workdays;
double? HoursPerDay;
bool? IsNight;
double? WeeklyHours;
double? OtFraction;
double? Days;
double? EffectiveProdPerDay;
bool? CrewPremiumApplied;
double? CrewCost;
double? FringeCost;
double? EquipmentCost;
double? MaterialCost;
double? SubcontractCost;
double? Direct;
String? PricingBasis;
double? BenchmarkUnitPrice;
List<EstimateCrewLineView>? Crew = [];
List<EstimateEquipmentLineView>? Equipment = [];
List<EstimateMaterialLineView>? Materials = [];
List<EstimateSubcontractView>? Subcontracts = [];
EstimateJobView({this.Seq,this.WorkPackage,this.ItemNo,this.Name,this.Category,this.SourceRef,this.Unit,this.Quantity,this.PatternCode,this.Workdays,this.HoursPerDay,this.IsNight,this.WeeklyHours,this.OtFraction,this.Days,this.EffectiveProdPerDay,this.CrewPremiumApplied,this.CrewCost,this.FringeCost,this.EquipmentCost,this.MaterialCost,this.SubcontractCost,this.Direct,this.PricingBasis,this.BenchmarkUnitPrice,this.Crew,this.Equipment,this.Materials,this.Subcontracts});
EstimateJobView.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Seq = json['Seq'];
WorkPackage = JsonConverters.fromJson(json['WorkPackage'],'WorkPackageView',context!);
ItemNo = json['ItemNo'];
Name = json['Name'];
Category = json['Category'];
SourceRef = json['SourceRef'];
Unit = json['Unit'];
Quantity = JsonConverters.toDouble(json['Quantity']);
PatternCode = json['PatternCode'];
Workdays = json['Workdays'];
HoursPerDay = JsonConverters.toDouble(json['HoursPerDay']);
IsNight = json['IsNight'];
WeeklyHours = JsonConverters.toDouble(json['WeeklyHours']);
OtFraction = JsonConverters.toDouble(json['OtFraction']);
Days = JsonConverters.toDouble(json['Days']);
EffectiveProdPerDay = JsonConverters.toDouble(json['EffectiveProdPerDay']);
CrewPremiumApplied = json['CrewPremiumApplied'];
CrewCost = JsonConverters.toDouble(json['CrewCost']);
FringeCost = JsonConverters.toDouble(json['FringeCost']);
EquipmentCost = JsonConverters.toDouble(json['EquipmentCost']);
MaterialCost = JsonConverters.toDouble(json['MaterialCost']);
SubcontractCost = JsonConverters.toDouble(json['SubcontractCost']);
Direct = JsonConverters.toDouble(json['Direct']);
PricingBasis = json['PricingBasis'];
BenchmarkUnitPrice = JsonConverters.toDouble(json['BenchmarkUnitPrice']);
Crew = JsonConverters.fromJson(json['Crew'],'List<EstimateCrewLineView>',context!);
Equipment = JsonConverters.fromJson(json['Equipment'],'List<EstimateEquipmentLineView>',context!);
Materials = JsonConverters.fromJson(json['Materials'],'List<EstimateMaterialLineView>',context!);
Subcontracts = JsonConverters.fromJson(json['Subcontracts'],'List<EstimateSubcontractView>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'Seq': Seq,
'WorkPackage': JsonConverters.toJson(WorkPackage,'WorkPackageView',context!),
'ItemNo': ItemNo,
'Name': Name,
'Category': Category,
'SourceRef': SourceRef,
'Unit': Unit,
'Quantity': Quantity,
'PatternCode': PatternCode,
'Workdays': Workdays,
'HoursPerDay': HoursPerDay,
'IsNight': IsNight,
'WeeklyHours': WeeklyHours,
'OtFraction': OtFraction,
'Days': Days,
'EffectiveProdPerDay': EffectiveProdPerDay,
'CrewPremiumApplied': CrewPremiumApplied,
'CrewCost': CrewCost,
'FringeCost': FringeCost,
'EquipmentCost': EquipmentCost,
'MaterialCost': MaterialCost,
'SubcontractCost': SubcontractCost,
'Direct': Direct,
'PricingBasis': PricingBasis,
'BenchmarkUnitPrice': BenchmarkUnitPrice,
'Crew': JsonConverters.toJson(Crew,'List<EstimateCrewLineView>',context!),
'Equipment': JsonConverters.toJson(Equipment,'List<EstimateEquipmentLineView>',context!),
'Materials': JsonConverters.toJson(Materials,'List<EstimateMaterialLineView>',context!),
'Subcontracts': JsonConverters.toJson(Subcontracts,'List<EstimateSubcontractView>',context!)
};
getTypeName() => "EstimateJobView";
TypeContext? context = _ctx;
}
class BidScheduleLine implements IConvertible
{
String? ItemNo;
String? Description;
String? Unit;
double? Quantity;
double? UnitPrice;
double? Extension;
String? PricingBasis;
double? BenchmarkDeltaPct;
bool? BenchmarkFlagged;
BidScheduleLine({this.ItemNo,this.Description,this.Unit,this.Quantity,this.UnitPrice,this.Extension,this.PricingBasis,this.BenchmarkDeltaPct,this.BenchmarkFlagged});
BidScheduleLine.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
ItemNo = json['ItemNo'];
Description = json['Description'];
Unit = json['Unit'];
Quantity = JsonConverters.toDouble(json['Quantity']);
UnitPrice = JsonConverters.toDouble(json['UnitPrice']);
Extension = JsonConverters.toDouble(json['Extension']);
PricingBasis = json['PricingBasis'];
BenchmarkDeltaPct = JsonConverters.toDouble(json['BenchmarkDeltaPct']);
BenchmarkFlagged = json['BenchmarkFlagged'];
return this;
}
Map<String, dynamic> toJson() => {
'ItemNo': ItemNo,
'Description': Description,
'Unit': Unit,
'Quantity': Quantity,
'UnitPrice': UnitPrice,
'Extension': Extension,
'PricingBasis': PricingBasis,
'BenchmarkDeltaPct': BenchmarkDeltaPct,
'BenchmarkFlagged': BenchmarkFlagged
};
getTypeName() => "BidScheduleLine";
TypeContext? context = _ctx;
}
class EstimateVarianceLine implements IConvertible
{
int? Seq;
String? ItemNo;
String? Name;
String? Unit;
double? Quantity;
double? OurUnitPrice;
double? OurTotal;
double? BenchmarkUnitPrice;
double? MarketTotal;
double? DeltaPct;
double? RateMin;
double? RateMax;
int? SampleSize;
bool? OutsideRange;
bool? IsFloor;
String? Severity;
String? Note;
EstimateVarianceLine({this.Seq,this.ItemNo,this.Name,this.Unit,this.Quantity,this.OurUnitPrice,this.OurTotal,this.BenchmarkUnitPrice,this.MarketTotal,this.DeltaPct,this.RateMin,this.RateMax,this.SampleSize,this.OutsideRange,this.IsFloor,this.Severity,this.Note});
EstimateVarianceLine.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Seq = json['Seq'];
ItemNo = json['ItemNo'];
Name = json['Name'];
Unit = json['Unit'];
Quantity = JsonConverters.toDouble(json['Quantity']);
OurUnitPrice = JsonConverters.toDouble(json['OurUnitPrice']);
OurTotal = JsonConverters.toDouble(json['OurTotal']);
BenchmarkUnitPrice = JsonConverters.toDouble(json['BenchmarkUnitPrice']);
MarketTotal = JsonConverters.toDouble(json['MarketTotal']);
DeltaPct = JsonConverters.toDouble(json['DeltaPct']);
RateMin = JsonConverters.toDouble(json['RateMin']);
RateMax = JsonConverters.toDouble(json['RateMax']);
SampleSize = json['SampleSize'];
OutsideRange = json['OutsideRange'];
IsFloor = json['IsFloor'];
Severity = json['Severity'];
Note = json['Note'];
return this;
}
Map<String, dynamic> toJson() => {
'Seq': Seq,
'ItemNo': ItemNo,
'Name': Name,
'Unit': Unit,
'Quantity': Quantity,
'OurUnitPrice': OurUnitPrice,
'OurTotal': OurTotal,
'BenchmarkUnitPrice': BenchmarkUnitPrice,
'MarketTotal': MarketTotal,
'DeltaPct': DeltaPct,
'RateMin': RateMin,
'RateMax': RateMax,
'SampleSize': SampleSize,
'OutsideRange': OutsideRange,
'IsFloor': IsFloor,
'Severity': Severity,
'Note': Note
};
getTypeName() => "EstimateVarianceLine";
TypeContext? context = _ctx;
}
class EstimateVarianceView implements IConvertible
{
List<EstimateVarianceLine>? Lines = [];
int? ItemsTotal;
int? ItemsBenchmarked;
double? CoverageValuePct;
double? OursTotal;
double? MarketTotal;
double? AggregateDeltaPct;
int? FlooredCount;
int? WatchCount;
int? OutlierCount;
int? CriticalCount;
String? Note;
EstimateVarianceView({this.Lines,this.ItemsTotal,this.ItemsBenchmarked,this.CoverageValuePct,this.OursTotal,this.MarketTotal,this.AggregateDeltaPct,this.FlooredCount,this.WatchCount,this.OutlierCount,this.CriticalCount,this.Note});
EstimateVarianceView.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Lines = JsonConverters.fromJson(json['Lines'],'List<EstimateVarianceLine>',context!);
ItemsTotal = json['ItemsTotal'];
ItemsBenchmarked = json['ItemsBenchmarked'];
CoverageValuePct = JsonConverters.toDouble(json['CoverageValuePct']);
OursTotal = JsonConverters.toDouble(json['OursTotal']);
MarketTotal = JsonConverters.toDouble(json['MarketTotal']);
AggregateDeltaPct = JsonConverters.toDouble(json['AggregateDeltaPct']);
FlooredCount = json['FlooredCount'];
WatchCount = json['WatchCount'];
OutlierCount = json['OutlierCount'];
CriticalCount = json['CriticalCount'];
Note = json['Note'];
return this;
}
Map<String, dynamic> toJson() => {
'Lines': JsonConverters.toJson(Lines,'List<EstimateVarianceLine>',context!),
'ItemsTotal': ItemsTotal,
'ItemsBenchmarked': ItemsBenchmarked,
'CoverageValuePct': CoverageValuePct,
'OursTotal': OursTotal,
'MarketTotal': MarketTotal,
'AggregateDeltaPct': AggregateDeltaPct,
'FlooredCount': FlooredCount,
'WatchCount': WatchCount,
'OutlierCount': OutlierCount,
'CriticalCount': CriticalCount,
'Note': Note
};
getTypeName() => "EstimateVarianceView";
TypeContext? context = _ctx;
}
class IndicativeLine implements IConvertible
{
int? Seq;
String? ItemNo;
String? Name;
String? Unit;
double? Quantity;
String? Source;
double? UnitPrice;
double? LineTotal;
IndicativeLine({this.Seq,this.ItemNo,this.Name,this.Unit,this.Quantity,this.Source,this.UnitPrice,this.LineTotal});
IndicativeLine.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Seq = json['Seq'];
ItemNo = json['ItemNo'];
Name = json['Name'];
Unit = json['Unit'];
Quantity = JsonConverters.toDouble(json['Quantity']);
Source = json['Source'];
UnitPrice = JsonConverters.toDouble(json['UnitPrice']);
LineTotal = JsonConverters.toDouble(json['LineTotal']);
return this;
}
Map<String, dynamic> toJson() => {
'Seq': Seq,
'ItemNo': ItemNo,
'Name': Name,
'Unit': Unit,
'Quantity': Quantity,
'Source': Source,
'UnitPrice': UnitPrice,
'LineTotal': LineTotal
};
getTypeName() => "IndicativeLine";
TypeContext? context = _ctx;
}
class IndicativeBidView implements IConvertible
{
List<IndicativeLine>? Lines = [];
int? BottomUpCount;
double? BottomUpTotal;
int? BenchmarkCount;
double? BenchmarkTotal;
int? UncoveredCount;
double? UncoveredFloorTotal;
double? IndicativeTotal;
double? FloorTotal;
String? Note;
IndicativeBidView({this.Lines,this.BottomUpCount,this.BottomUpTotal,this.BenchmarkCount,this.BenchmarkTotal,this.UncoveredCount,this.UncoveredFloorTotal,this.IndicativeTotal,this.FloorTotal,this.Note});
IndicativeBidView.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Lines = JsonConverters.fromJson(json['Lines'],'List<IndicativeLine>',context!);
BottomUpCount = json['BottomUpCount'];
BottomUpTotal = JsonConverters.toDouble(json['BottomUpTotal']);
BenchmarkCount = json['BenchmarkCount'];
BenchmarkTotal = JsonConverters.toDouble(json['BenchmarkTotal']);
UncoveredCount = json['UncoveredCount'];
UncoveredFloorTotal = JsonConverters.toDouble(json['UncoveredFloorTotal']);
IndicativeTotal = JsonConverters.toDouble(json['IndicativeTotal']);
FloorTotal = JsonConverters.toDouble(json['FloorTotal']);
Note = json['Note'];
return this;
}
Map<String, dynamic> toJson() => {
'Lines': JsonConverters.toJson(Lines,'List<IndicativeLine>',context!),
'BottomUpCount': BottomUpCount,
'BottomUpTotal': BottomUpTotal,
'BenchmarkCount': BenchmarkCount,
'BenchmarkTotal': BenchmarkTotal,
'UncoveredCount': UncoveredCount,
'UncoveredFloorTotal': UncoveredFloorTotal,
'IndicativeTotal': IndicativeTotal,
'FloorTotal': FloorTotal,
'Note': Note
};
getTypeName() => "IndicativeBidView";
TypeContext? context = _ctx;
}
class EstimateSummaryView implements IConvertible
{
double? Direct;
double? OhpPct;
double? OhpAmount;
double? BondPct;
double? BondAmount;
double? ContingencyPct;
double? ContingencyAmount;
double? BidTotal;
double? LoadFactor;
double? MarginPct;
EstimateSummaryView({this.Direct,this.OhpPct,this.OhpAmount,this.BondPct,this.BondAmount,this.ContingencyPct,this.ContingencyAmount,this.BidTotal,this.LoadFactor,this.MarginPct});
EstimateSummaryView.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Direct = JsonConverters.toDouble(json['Direct']);
OhpPct = JsonConverters.toDouble(json['OhpPct']);
OhpAmount = JsonConverters.toDouble(json['OhpAmount']);
BondPct = JsonConverters.toDouble(json['BondPct']);
BondAmount = JsonConverters.toDouble(json['BondAmount']);
ContingencyPct = JsonConverters.toDouble(json['ContingencyPct']);
ContingencyAmount = JsonConverters.toDouble(json['ContingencyAmount']);
BidTotal = JsonConverters.toDouble(json['BidTotal']);
LoadFactor = JsonConverters.toDouble(json['LoadFactor']);
MarginPct = JsonConverters.toDouble(json['MarginPct']);
return this;
}
Map<String, dynamic> toJson() => {
'Direct': Direct,
'OhpPct': OhpPct,
'OhpAmount': OhpAmount,
'BondPct': BondPct,
'BondAmount': BondAmount,
'ContingencyPct': ContingencyPct,
'ContingencyAmount': ContingencyAmount,
'BidTotal': BidTotal,
'LoadFactor': LoadFactor,
'MarginPct': MarginPct
};
getTypeName() => "EstimateSummaryView";
TypeContext? context = _ctx;
}
class EstimateTimingView implements IConvertible
{
double? TotalWorkdays;
int? CalendarDays;
DateTime? Finish;
bool? Feasible;
DateTime? Deadline;
EstimateTimingView({this.TotalWorkdays,this.CalendarDays,this.Finish,this.Feasible,this.Deadline});
EstimateTimingView.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
TotalWorkdays = JsonConverters.toDouble(json['TotalWorkdays']);
CalendarDays = json['CalendarDays'];
Finish = JsonConverters.fromJson(json['Finish'],'DateTime',context!);
Feasible = json['Feasible'];
Deadline = JsonConverters.fromJson(json['Deadline'],'DateTime',context!);
return this;
}
Map<String, dynamic> toJson() => {
'TotalWorkdays': TotalWorkdays,
'CalendarDays': CalendarDays,
'Finish': JsonConverters.toJson(Finish,'DateTime',context!),
'Feasible': Feasible,
'Deadline': JsonConverters.toJson(Deadline,'DateTime',context!)
};
getTypeName() => "EstimateTimingView";
TypeContext? context = _ctx;
}
class EstimateReviewItemView implements IConvertible
{
int? TaskSeq;
String? TaskName;
String? Reason;
String? Status;
EstimateReviewItemView({this.TaskSeq,this.TaskName,this.Reason,this.Status});
EstimateReviewItemView.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
TaskSeq = json['TaskSeq'];
TaskName = json['TaskName'];
Reason = json['Reason'];
Status = json['Status'];
return this;
}
Map<String, dynamic> toJson() => {
'TaskSeq': TaskSeq,
'TaskName': TaskName,
'Reason': Reason,
'Status': Status
};
getTypeName() => "EstimateReviewItemView";
TypeContext? context = _ctx;
}
class EstimatingView implements IConvertible
{
int? RfpDocumentID;
String? ProjectName;
String? ClientName;
String? BidDueDate;
String? ProjectType;
EstimateSettingsView? Settings;
List<EstimateJobView>? Jobs = [];
List<BidScheduleLine>? Schedule = [];
double? ScheduleTotal;
EstimateVarianceView? Variance;
IndicativeBidView? Indicative;
EstimateSummaryView? Summary;
EstimateTimingView? Timing;
int? NeedsRateCount;
List<String>? NeedsRateKeys = [];
List<EstimateReviewItemView>? ReviewItems = [];
int? NeedsReviewCount;
bool? CanApprove;
bool? CanSeePay;
EstimatingView({this.RfpDocumentID,this.ProjectName,this.ClientName,this.BidDueDate,this.ProjectType,this.Settings,this.Jobs,this.Schedule,this.ScheduleTotal,this.Variance,this.Indicative,this.Summary,this.Timing,this.NeedsRateCount,this.NeedsRateKeys,this.ReviewItems,this.NeedsReviewCount,this.CanApprove,this.CanSeePay});
EstimatingView.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
RfpDocumentID = json['RfpDocumentID'];
ProjectName = json['ProjectName'];
ClientName = json['ClientName'];
BidDueDate = json['BidDueDate'];
ProjectType = json['ProjectType'];
Settings = JsonConverters.fromJson(json['Settings'],'EstimateSettingsView',context!);
Jobs = JsonConverters.fromJson(json['Jobs'],'List<EstimateJobView>',context!);
Schedule = JsonConverters.fromJson(json['Schedule'],'List<BidScheduleLine>',context!);
ScheduleTotal = JsonConverters.toDouble(json['ScheduleTotal']);
Variance = JsonConverters.fromJson(json['Variance'],'EstimateVarianceView',context!);
Indicative = JsonConverters.fromJson(json['Indicative'],'IndicativeBidView',context!);
Summary = JsonConverters.fromJson(json['Summary'],'EstimateSummaryView',context!);
Timing = JsonConverters.fromJson(json['Timing'],'EstimateTimingView',context!);
NeedsRateCount = json['NeedsRateCount'];
NeedsRateKeys = JsonConverters.fromJson(json['NeedsRateKeys'],'List<String>',context!);
ReviewItems = JsonConverters.fromJson(json['ReviewItems'],'List<EstimateReviewItemView>',context!);
NeedsReviewCount = json['NeedsReviewCount'];
CanApprove = json['CanApprove'];
CanSeePay = json['CanSeePay'];
return this;
}
Map<String, dynamic> toJson() => {
'RfpDocumentID': RfpDocumentID,
'ProjectName': ProjectName,
'ClientName': ClientName,
'BidDueDate': BidDueDate,
'ProjectType': ProjectType,
'Settings': JsonConverters.toJson(Settings,'EstimateSettingsView',context!),
'Jobs': JsonConverters.toJson(Jobs,'List<EstimateJobView>',context!),
'Schedule': JsonConverters.toJson(Schedule,'List<BidScheduleLine>',context!),
'ScheduleTotal': ScheduleTotal,
'Variance': JsonConverters.toJson(Variance,'EstimateVarianceView',context!),
'Indicative': JsonConverters.toJson(Indicative,'IndicativeBidView',context!),
'Summary': JsonConverters.toJson(Summary,'EstimateSummaryView',context!),
'Timing': JsonConverters.toJson(Timing,'EstimateTimingView',context!),
'NeedsRateCount': NeedsRateCount,
'NeedsRateKeys': JsonConverters.toJson(NeedsRateKeys,'List<String>',context!),
'ReviewItems': JsonConverters.toJson(ReviewItems,'List<EstimateReviewItemView>',context!),
'NeedsReviewCount': NeedsReviewCount,
'CanApprove': CanApprove,
'CanSeePay': CanSeePay
};
getTypeName() => "EstimatingView";
TypeContext? context = _ctx;
}
class EstimateResponse implements IConvertible
{
ResponseStatus? ResponseStatus;
EstimatingView? View;
EstimateResponse({this.ResponseStatus,this.View});
EstimateResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
ResponseStatus = JsonConverters.fromJson(json['ResponseStatus'],'ResponseStatus',context!);
View = JsonConverters.fromJson(json['View'],'EstimatingView',context!);
return this;
}
Map<String, dynamic> toJson() => {
'ResponseStatus': JsonConverters.toJson(ResponseStatus,'ResponseStatus',context!),
'View': JsonConverters.toJson(View,'EstimatingView',context!)
};
getTypeName() => "EstimateResponse";
TypeContext? context = _ctx;
}
class EstimateSubcontractAddRequest implements IConvertible
{
String? RfpDocumentUID;
int? TaskSeq;
String? Vendor;
double? Amount;
String? Scope;
EstimateSubcontractAddRequest({this.RfpDocumentUID,this.TaskSeq,this.Vendor,this.Amount,this.Scope});
EstimateSubcontractAddRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
RfpDocumentUID = json['RfpDocumentUID'];
TaskSeq = json['TaskSeq'];
Vendor = json['Vendor'];
Amount = JsonConverters.toDouble(json['Amount']);
Scope = json['Scope'];
return this;
}
Map<String, dynamic> toJson() => {
'RfpDocumentUID': RfpDocumentUID,
'TaskSeq': TaskSeq,
'Vendor': Vendor,
'Amount': Amount,
'Scope': Scope
};
getTypeName() => "EstimateSubcontractAddRequest";
TypeContext? context = _ctx;
}
TypeContext _ctx = TypeContext(library: 'api.dev.dynamics.trendsic.com', types: <String, TypeInfo> {
'EstimateSettingsView': TypeInfo(TypeOf.Class, create:() => EstimateSettingsView()),
'List<DateTime>': TypeInfo(TypeOf.Class, create:() => <DateTime>[]),
'SpecRefView': TypeInfo(TypeOf.Class, create:() => SpecRefView()),
'DodItemView': TypeInfo(TypeOf.Class, create:() => DodItemView()),
'WorkPackageView': TypeInfo(TypeOf.Class, create:() => WorkPackageView()),
'List<SpecRefView>': TypeInfo(TypeOf.Class, create:() => <SpecRefView>[]),
'List<DodItemView>': TypeInfo(TypeOf.Class, create:() => <DodItemView>[]),
'EstimateCrewLineView': TypeInfo(TypeOf.Class, create:() => EstimateCrewLineView()),
'EstimateEquipmentLineView': TypeInfo(TypeOf.Class, create:() => EstimateEquipmentLineView()),
'EstimateMaterialLineView': TypeInfo(TypeOf.Class, create:() => EstimateMaterialLineView()),
'EstimateSubcontractView': TypeInfo(TypeOf.Class, create:() => EstimateSubcontractView()),
'EstimateJobView': TypeInfo(TypeOf.Class, create:() => EstimateJobView()),
'List<EstimateCrewLineView>': TypeInfo(TypeOf.Class, create:() => <EstimateCrewLineView>[]),
'List<EstimateEquipmentLineView>': TypeInfo(TypeOf.Class, create:() => <EstimateEquipmentLineView>[]),
'List<EstimateMaterialLineView>': TypeInfo(TypeOf.Class, create:() => <EstimateMaterialLineView>[]),
'List<EstimateSubcontractView>': TypeInfo(TypeOf.Class, create:() => <EstimateSubcontractView>[]),
'BidScheduleLine': TypeInfo(TypeOf.Class, create:() => BidScheduleLine()),
'EstimateVarianceLine': TypeInfo(TypeOf.Class, create:() => EstimateVarianceLine()),
'EstimateVarianceView': TypeInfo(TypeOf.Class, create:() => EstimateVarianceView()),
'List<EstimateVarianceLine>': TypeInfo(TypeOf.Class, create:() => <EstimateVarianceLine>[]),
'IndicativeLine': TypeInfo(TypeOf.Class, create:() => IndicativeLine()),
'IndicativeBidView': TypeInfo(TypeOf.Class, create:() => IndicativeBidView()),
'List<IndicativeLine>': TypeInfo(TypeOf.Class, create:() => <IndicativeLine>[]),
'EstimateSummaryView': TypeInfo(TypeOf.Class, create:() => EstimateSummaryView()),
'EstimateTimingView': TypeInfo(TypeOf.Class, create:() => EstimateTimingView()),
'EstimateReviewItemView': TypeInfo(TypeOf.Class, create:() => EstimateReviewItemView()),
'EstimatingView': TypeInfo(TypeOf.Class, create:() => EstimatingView()),
'List<EstimateJobView>': TypeInfo(TypeOf.Class, create:() => <EstimateJobView>[]),
'List<BidScheduleLine>': TypeInfo(TypeOf.Class, create:() => <BidScheduleLine>[]),
'List<EstimateReviewItemView>': TypeInfo(TypeOf.Class, create:() => <EstimateReviewItemView>[]),
'EstimateResponse': TypeInfo(TypeOf.Class, create:() => EstimateResponse()),
'EstimateSubcontractAddRequest': TypeInfo(TypeOf.Class, create:() => EstimateSubcontractAddRequest()),
});
Dart EstimateSubcontractAddRequest DTOs
To override the Content-type in your clients, use the HTTP Accept Header, append the .jsv suffix or ?format=jsv
The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.
POST /v1/Rfp/{RfpDocumentUID}/Estimate/Subcontracts HTTP/1.1
Host: api.dev.dynamics.trendsic.com
Accept: text/jsv
Content-Type: text/jsv
Content-Length: length
{
RfpDocumentUID: 00000000000000000000000000000000,
TaskSeq: 0,
Vendor: String,
Amount: 0,
Scope: String
}
HTTP/1.1 200 OK
Content-Type: text/jsv
Content-Length: length
{
ResponseStatus:
{
ErrorCode: String,
Message: String,
StackTrace: String,
Errors:
[
{
ErrorCode: String,
FieldName: String,
Message: String,
Meta:
{
String: String
}
}
],
Meta:
{
String: String
}
},
View:
{
RfpDocumentID: 0,
ProjectName: String,
ClientName: String,
BidDueDate: String,
ProjectType: String,
Settings:
{
RfpEstimateID: 0,
StartDate: 0001-01-01,
DeadlineDate: 0001-01-01,
WorkdaysPerWeek: 0,
HoursPerDay: 0,
WeatherPct: 0,
OhpPct: 0,
ContingencyPct: 0,
BondPct: 0,
Holidays:
[
0001-01-01
],
AppliedStartDate: 0001-01-01
},
Jobs:
[
{
Seq: 0,
WorkPackage:
{
HasPackage: False,
Scope: String,
LimitsOfWork: String,
SpecRefs:
[
{
Section: String,
Title: String,
Url: String
}
],
Constraints:
[
String
],
HoldPoints:
[
String
],
Dod:
[
{
Key: String,
Text: String,
Checked: False,
Source: String
}
],
SafetyNote: String,
Provenance: String,
SpecBook: String,
UserEdited: False,
RedraftNote: String
},
ItemNo: String,
Name: String,
Category: String,
SourceRef: String,
Unit: String,
Quantity: 0,
PatternCode: String,
Workdays: 0,
HoursPerDay: 0,
IsNight: False,
WeeklyHours: 0,
OtFraction: 0,
Days: 0,
EffectiveProdPerDay: 0,
CrewPremiumApplied: False,
CrewCost: 0,
FringeCost: 0,
EquipmentCost: 0,
MaterialCost: 0,
SubcontractCost: 0,
Direct: 0,
PricingBasis: String,
BenchmarkUnitPrice: 0,
Crew:
[
{
Role: String,
Hours: 0,
StHours: 0,
OtHours: 0,
HasOt: False,
PremiumApplied: False,
NeedsRate: False,
RateKey: String,
Chip: String,
Rrop: 0,
StCost: 0,
OtCost: 0,
Cost: 0,
FringeCost: 0
}
],
Equipment:
[
{
Name: String,
Quantity: 0,
Rate: 0,
NeedsRate: False,
MobCost: 0,
Cost: 0,
IsAvailabilityTracked: False,
IsOwned: False,
AvailabilityLabel: String,
FreedFromProject: String,
AvailableFrom: 0001-01-01,
RateKey: String,
Chip: String,
RentalExplain: String,
UsageDays: 0,
BilledDays: 0
}
],
Materials:
[
{
Name: String,
Quantity: 0,
Unit: String,
Rate: 0,
NeedsRate: False,
Cost: 0,
RateKey: String,
Chip: String
}
],
Subcontracts:
[
{
EstimateSubcontractID: 0,
TaskSeq: 0,
Vendor: String,
Amount: 0,
Scope: String
}
]
}
],
Schedule:
[
{
ItemNo: String,
Description: String,
Unit: String,
Quantity: 0,
UnitPrice: 0,
Extension: 0,
PricingBasis: String,
BenchmarkDeltaPct: 0,
BenchmarkFlagged: False
}
],
ScheduleTotal: 0,
Variance:
{
Lines:
[
{
Seq: 0,
ItemNo: String,
Name: String,
Unit: String,
Quantity: 0,
OurUnitPrice: 0,
OurTotal: 0,
BenchmarkUnitPrice: 0,
MarketTotal: 0,
DeltaPct: 0,
RateMin: 0,
RateMax: 0,
SampleSize: 0,
OutsideRange: False,
IsFloor: False,
Severity: String,
Note: String
}
],
ItemsTotal: 0,
ItemsBenchmarked: 0,
CoverageValuePct: 0,
OursTotal: 0,
MarketTotal: 0,
AggregateDeltaPct: 0,
FlooredCount: 0,
WatchCount: 0,
OutlierCount: 0,
CriticalCount: 0,
Note: String
},
Indicative:
{
Lines:
[
{
Seq: 0,
ItemNo: String,
Name: String,
Unit: String,
Quantity: 0,
Source: String,
UnitPrice: 0,
LineTotal: 0
}
],
BottomUpCount: 0,
BottomUpTotal: 0,
BenchmarkCount: 0,
BenchmarkTotal: 0,
UncoveredCount: 0,
UncoveredFloorTotal: 0,
IndicativeTotal: 0,
FloorTotal: 0,
Note: String
},
Summary:
{
Direct: 0,
OhpPct: 0,
OhpAmount: 0,
BondPct: 0,
BondAmount: 0,
ContingencyPct: 0,
ContingencyAmount: 0,
BidTotal: 0,
LoadFactor: 0,
MarginPct: 0
},
Timing:
{
TotalWorkdays: 0,
CalendarDays: 0,
Finish: 0001-01-01,
Feasible: False,
Deadline: 0001-01-01
},
NeedsRateCount: 0,
NeedsRateKeys:
[
String
],
ReviewItems:
[
{
TaskSeq: 0,
TaskName: String,
Reason: String,
Status: String
}
],
NeedsReviewCount: 0,
CanApprove: False,
CanSeePay: False
}
}