public void processResponseElement(InboundInterfaceResponseElement inboundResponseElement)
{
if (inboundResponseElement.report != null)
{
ReportMessageElement[] reportMessages = inboundResponseElement.report;
WorkOrderModel workOrderModel = new WorkOrderModel();
if (null != reportMessages && reportMessages.Length > 0)
{
_log.Notice("Processing Report Element for WorkOrder");
foreach (ReportMessageElement reportMessage in reportMessages)
{
workOrderModel.AddReportMessage(reportMessage.result, reportMessage.type, reportMessage.code, reportMessage.description);
if (!reportMessage.code.Equals(ActivityProperty.TOA_Report_Success_Code))
{
_resultCode = Common.ToaRequestResultCode.Failure;
_log.Error("Error creating appointment ",
"Result:" + reportMessage.result + ", Type:" + reportMessage.type + ", Code:" + reportMessage.code + ", Description:" + reportMessage.description);
}
}
_log.Notice("Processing of Report Element for WorkOrder is done");
}
_dataModels.Add(workOrderModel);
}
else if (inboundResponseElement.data != null)
{
CommandResponseElement[] commands = inboundResponseElement.data.commands;
_resultCode = Common.ToaRequestResultCode.Success;
if (null != commands && commands.Length > 0)
{
foreach (CommandResponseElement command in commands)
{
WorkOrderModel workOrderModel = new WorkOrderModel();
ReportMessageElement[] reportMessages = command.appointment.report;
if (null != reportMessages && reportMessages.Length > 0)
{
_log.Notice("Processing Report Element for WorkOrder");
foreach (ReportMessageElement reportMessage in reportMessages)
{
workOrderModel.AddReportMessage(reportMessage.result, reportMessage.type, reportMessage.code, reportMessage.description);
if (!reportMessage.code.Equals(ActivityProperty.TOA_Report_Success_Code))
{
_resultCode = Common.ToaRequestResultCode.Failure;
_log.Error("Error creating appointment:" + command.appointment.appt_number,
"Result:" + reportMessage.result + ", Type:" + reportMessage.type + ", Code:" + reportMessage.code + ", Description:" + reportMessage.description);
}
else
{
_log.Notice("Appointment created:" + command.appointment.appt_number,
"Result:" + reportMessage.result + ", Type:" + reportMessage.type + ", Code:" + reportMessage.code + ", Description:" + reportMessage.description);
}
}
_log.Notice("Processing of Report Element for WorkOrder is done");
}
workOrderModel.AppointmentNumber = command.appointment.appt_number;
_log.Notice("WorkOrder Id:" + command.appointment.appt_number);
workOrderModel.TOA_AID = command.appointment.aid;
_log.Notice("ETA Direct Activity Id:" + command.appointment.aid);
workOrderModel.CustomerNumber = command.appointment.customer_number;
workOrderModel.CommandType = ToaEnumsUtil.GetActivityCommandTypeEnum(command.type);
workOrderModel.AssignedDate = command.date;
workOrderModel.ExternalId = command.external_id;
_dataModels.Add(workOrderModel);
//Processing Inventories
InventoryResponseElement[] inventoriesResponseElement = command.appointment.inventories;
if (null != inventoriesResponseElement && inventoriesResponseElement.Length > 0)
{
List <InventoryModel> inventoryResponseModels = new List <InventoryModel>();
foreach (InventoryResponseElement inventoryResponseElement in inventoriesResponseElement)
{
ReportMessageElement[] inventoryReportMessages = inventoryResponseElement.report;
InventoryModel responseInventoryModel = new InventoryModel();
if (inventoryResponseElement.invid > 0)
{
responseInventoryModel.InventoryID = inventoryResponseElement.invid;
_log.Notice("Inventory ID is:" + inventoryResponseElement.invid);
}
_log.Notice("Processing Report Element for Inventory");
if (null != inventoryReportMessages)
{
foreach (ReportMessageElement reportMessage in inventoryReportMessages)
{
responseInventoryModel.AddReportMessage(reportMessage.result, reportMessage.type, reportMessage.code, reportMessage.description);
if (!reportMessage.code.Equals(ActivityProperty.TOA_Report_Success_Code))
{
_resultCode = Common.ToaRequestResultCode.Failure;
_log.Error("Error creating/updating inventory",
"Result:" + reportMessage.result + ", Type:" + reportMessage.type + ", Code:" + reportMessage.code + ", Description:" + reportMessage.description);
}
else
{
_log.Notice("Inventory added/updated",
"Result:" + reportMessage.result + ", Type:" + reportMessage.type + ", Code:" + reportMessage.code + ", Description:" + reportMessage.description);
}
}
}
_log.Notice("Processing of Report Element for Inventory is done");
if (null != inventoryResponseElement.properties)
{
foreach (PropertyElement inventoryProperty in inventoryResponseElement.properties)
{
switch (inventoryProperty.label)
{
case "invsn":
responseInventoryModel.SerialNumber = inventoryProperty.value;
_log.Notice("Inventory Serial Number is:" + inventoryProperty.value);
break;
case "invtype_label":
responseInventoryModel.Type = inventoryProperty.value;
_log.Notice("Inventory Type is:" + inventoryProperty.value);
break;
default:
break;
}
}
}
//Adding individual inventory to list
inventoryResponseModels.Add(responseInventoryModel);
}
//Adding list to WorkOrder Model
workOrderModel.ActivityInventories = inventoryResponseModels;
}
}
}
}
}
public async Task Update(WorkOrderModel workOrder)
{
await _httpClient.PostJsonAsync(PathHelper.GetApiServerPath(controller, "update"), workOrder);
}
public void UpdateWorkOrder(WorkOrderModel model)
{
this._clients.All.UpdateWorkOrder(model);
}
public int?ProcessInboundResult(ToaRequestResult inboundResult)
{
int?aid = null;
HashSet <string> errors = new HashSet <string>();
bool ErrorDialogShown = false;
{
if (inboundResult.DataModels.Count > 0)
{
WorkOrderModel workOrderModel = null;
List <IToaModel> .Enumerator e = inboundResult.DataModels.GetEnumerator();
while (e.MoveNext())
{
IToaModel model = e.Current;
if (model is WorkOrderModel)
{
workOrderModel = (WorkOrderModel)model;
foreach (ReportMessageModel reportMessage in workOrderModel.ReportMessages)
{
if (!reportMessage.Code.Equals(ActivityProperty.TOA_Report_Success_Code))
{
errors.Add(reportMessage.Code);
_log.Error(reportMessage.Code, reportMessage.Description);
}
}
List <InventoryModel> inventories = workOrderModel.ActivityInventories;
if (null != inventories && inventories.Count > 0)
{
foreach (InventoryModel inventory in inventories)
{
List <ReportMessageModel> reportMessages = inventory.ReportMessages;
foreach (ReportMessageModel reportMessage in reportMessages)
{
if (!reportMessage.Code.Equals(ActivityProperty.TOA_Report_Success_Code))
{
errors.Add(reportMessage.Code);
_log.Error(reportMessage.Code, reportMessage.Description);
}
}
}
}
foreach (string errorcode in errors)
{
if (!ErrorDialogShown)
{
ShowErrorOrWarningDialog(errorcode);
ErrorDialogShown = true;
}
if (ErrorsNotToSave.Contains(errorcode))
{
return(null);
}
}
aid = workOrderModel.TOA_AID;
}
}
}
}
return(aid);
}
public void Handler()
{
InboundRequest inboundRequest = null;
ToaRequestResult inboundResult = null;
int? aid = null;
WorkOrderModel workOrderModel = null;
try
{
_log.Notice("Starting WorkOrderSave Handler.");
object wotype = EventHandlerServices.GetEventHandlerService().getFieldFromWorOrderRecord(_workOrderRecord, "WO_Type");
object overrideRequest = EventHandlerServices.GetEventHandlerService().getFieldFromWorOrderRecord(_workOrderRecord, "Override_Request");
object timeSlot = EventHandlerServices.GetEventHandlerService().getFieldFromWorOrderRecord(_workOrderRecord, "WO_Time_Slot");
object wodate = EventHandlerServices.GetEventHandlerService().getFieldFromWorOrderRecord(_workOrderRecord, "WO_Date");
object resolutionDue = EventHandlerServices.GetEventHandlerService().getFieldFromWorOrderRecord(_workOrderRecord, "Resolution_Due");
if (null == wotype)
{
return;
}
if (overrideRequest != null)
{
if (timeSlot == null || wodate == null)
{
return;
}
}
else
{
if (timeSlot == null || wodate == null)
{
if (resolutionDue == null)
{
return;
}
}
}
_log.Notice("Converting from RecordContext to WorkOrder Model started");
workOrderModel = EventHandlerServices.GetEventHandlerService().GetWorkOrderModel(_recordContext);
_log.Notice("Convertion from RecordContext to WorkOrder Model completed");
//Appointments 'key' fields are set in the constuctor of below object
var activitySettings = new ActivitySettingsModel();
//Inventory 'key' fields are set in the constuctor of below object
var inventorySettings = new InventorySettingsModel();
_log.Notice("Initialize InboundRequest");
inboundRequest = new InboundRequest(new List <IToaModel>()
{
workOrderModel
});
inboundRequest.PropertiesMode = Client.Common.PropertiesMode.Replace;
inboundRequest.AllowChangeDate = Client.Common.AllowChangeDate.Yes;
inboundRequest.ActivitySettings = activitySettings;
inboundRequest.InventorySettings = inventorySettings;
_log.Notice("Invoking TOA Server using Inbound API Started");
inboundResult = InboundService.GetService().BeginSyncRequest(inboundRequest);
if (inboundResult != null)
{
_log.Notice("Invoking TOA Server using Inbound API Completed");
ToaExceptionManager manager = new ToaExceptionManager();
_log.Notice("Processing Inbound API Response Result");
aid = manager.ProcessInboundResult(inboundResult);
_log.Notice("Completed Processing Inbound API Response Result");
if (aid == null)
{
_cancelEventArgs.Cancel = true;
return;
}
}
else
{
foreach (IGenericField field in _workOrderRecord.GenericFields)
{
if (field.Name.Equals("WO_Status"))
{
TextInfo textInfo = new CultureInfo("en-US", false).TextInfo;
field.DataValue.Value = textInfo.ToTitleCase(ToaStringsUtil.GetString(Client.Common.ActivityStatus.NotCreated));
break;
}
}
}
}
catch (Exception ex)
{
_log.Error(ex.Message, ex.StackTrace);
MessageBox.Show(ToaExceptionMessages.UnexpectedError, ToaExceptionMessages.TitleError,
MessageBoxButton.OK, MessageBoxImage.Error);
}
try
{
_log.Notice("Updating WorkOrder Record.");
workOrderModel.TOA_AID = (aid != null) ? aid : 0;
UpdateWorkOrderRecord(inboundResult, workOrderModel);
_log.Notice("WorkOrder Record Updated.");
_log.Notice("Exiting WorkOrderSave Handler.");
}
catch (Exception ex)
{
_log.Error(ex.Message, ex.StackTrace);
MessageBox.Show(ToaExceptionMessages.UnexpectedError, ToaExceptionMessages.TitleError,
MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public void Update(WorkOrderModel model)
{
Description = model.Description;
OpenedDate = model.OpenedDate;
ClosedDate = model.ClosedDate;
}
public void UpdateWorkOrder(WorkOrderModel orderModel)
{
new WorkOrderDAL().UpdateWorkOrder(orderModel);
}
private async void ConfirmCalibrationSubmitt_Clicked(object sender, EventArgs e)
{
actIndicator2.IsRunning = true;
StackVinDisplay.SetValue(IsVisibleProperty, false);
var httpClientHandler = new HttpClientHandler();
client = new HttpClient();
// LabMessage.Text = Application.Current.Properties["token"].ToString();
// token = Application.Current.Properties["token"].ToString();
// Debug.WriteLine("TokenPass from Azure", token);
var VinNumber = VinEnteredNumber.Text;
WorkOrderModel workOrderModel = new WorkOrderModel();
workOrderModel.id = VinNumber;
workOrderModel.vinnumber = VinNumber;
workOrderModel.workorder = vehicleVinResponse.Results[6].ValueId;;
workOrderModel.model = vehicleVinResponse.Results[6].Value;
workOrderModel.startdate = "03032019";
workOrderModel.enddate = "13032019";
workOrderModel.totalcalibration = "2";
workOrderModel.numberofcalibrationcompleted = "1";
workOrderModel.totalactiveworkorder = "2";
workOrderModel.iscompletedcalibration = true;
workOrderModel.isactive = true;
workOrderModel.createdby = "ADASAdmin";
workOrderModel.createddate = "030319";
workOrderModel.lastupdatedby = "040404";
workOrderModel.lastupdateddate = "040404";
workOrderModel.lastupdatedby = "040404";
CalibrationDetailRowlList = new List <CalibrationDetailRow>();
// CalibrationDetailRow calibrationDetailRows = new CalibrationDetailRow();
CalibrationDetailRowlList.Add(new CalibrationDetailRow()
{
adasModuleName = "Module111",
moduleAvailability = "Available",
targetAvailability = "Standard",
status = "Progress"
});
CalibrationDetailRowlList.Add(new CalibrationDetailRow()
{
adasModuleName = "Module3333",
moduleAvailability = "Available",
targetAvailability = "Standard",
status = "Progress"
});
CalibrationDetailRowlList.Add(new CalibrationDetailRow()
{
adasModuleName = "Module44444",
moduleAvailability = "Available",
targetAvailability = "Standard",
status = "Progress"
});
CalibrationDetailRowlList.Add(new CalibrationDetailRow()
{
adasModuleName = "Module555",
moduleAvailability = "Available",
targetAvailability = "Standard",
status = "Progress"
});
workOrderModel.calibrationDetailRows = CalibrationDetailRowlList;
try
{
System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls;
var json = JsonConvert.SerializeObject(workOrderModel);
var content = new StringContent(json, Encoding.UTF8, "application/json");
HttpResponseMessage response = null;
response = await client.PostAsync(Constants.BaseUrlLocal + "/api/entity/workorder", content);
if (response.IsSuccessStatusCode)
{
Debug.WriteLine(@" TodoItem successfully saved.");
actIndicator2.IsRunning = false;
await Navigation.PushAsync(new GrideListPage());
}
else
{
Debug.WriteLine(@" Faied to update data .");
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception Error ", ex.ToString());
}
}
public ActionResult Edit(int id)
{
var model = new WorkOrderModel().GetWorkOrderDeatails(id);
return(View("..\\WorkOrder\\Edit", model));
}
public void CreateWorkOrder(WorkOrderModel orderModel)
{
WorkOrderDAL workOrder = new WorkOrderDAL();
workOrder.CreateWorkOrder(orderModel);
}
private void ResolveWorkOrderItems(WorkOrderModel model)
{
var workOrderItems = Mapper.Map <IEnumerable <SageWorkOrderItem> >(model.PartsAndLabors);
var workOrderFromMongo = _repository.SearchFor <SageWorkOrder>(x => x.WorkOrder == model.WorkOrder).Single();
if (workOrderItems != null)
{
foreach (var workOrderItem in workOrderItems)
{
if ((workOrderFromMongo.WorkOrderItems != null && workOrderFromMongo.WorkOrderItems.Contains(workOrderItem)))
{
_sageApiProxy.EditWorkOrderItem(workOrderItem);
}
else
{
workOrderItem.WorkOrder = Convert.ToInt32(model.WorkOrder);
workOrderItem.TotalSale = workOrderItem.Quantity * workOrderItem.UnitSale;
if (workOrderItem.ItemType == "Parts")
{
workOrderItem.PartsSale = workOrderItem.UnitSale;
}
else
{
workOrderItem.LaborSale = workOrderItem.UnitSale;
}
if (workOrderItem.WorkOrderItem == 0)
{
_sageApiProxy.AddWorkOrderItem(workOrderItem);
}
else
{
_sageApiProxy.EditWorkOrderItem(workOrderItem);
}
}
}
if (workOrderFromMongo.WorkOrderItems != null)
{
var idsToRemove = new List <long>();
foreach (var woItem in workOrderFromMongo.WorkOrderItems)
{
if (!workOrderItems.Select(x => x.WorkOrderItem).Contains(woItem.WorkOrderItem))
{
idsToRemove.Add(woItem.WorkOrderItem);
}
}
if (idsToRemove.Any())
{
_sageApiProxy.DeleteWorkOrderItems(Convert.ToInt32(workOrderFromMongo.WorkOrder), idsToRemove);
}
}
}
else
{
if (workOrderFromMongo.WorkOrderItems != null)
{
var idsToRemove = workOrderFromMongo.WorkOrderItems.Select(x => x.WorkOrderItem);
if (idsToRemove.Any())
{
_sageApiProxy.DeleteWorkOrderItems(Convert.ToInt32(workOrderFromMongo.WorkOrder), idsToRemove);
}
}
}
}
public ActionResult CreateWorkOrder(WorkOrderModel model)
{
_log.InfoFormat("Method: CreateWorkOrder. Model ID {0}", model.Id);
if (string.IsNullOrEmpty(model.Calltype))
{
return(Error("Call Type is required"));
}
var workorder = new SageWorkOrder()
{
ARCustomer = model.Customer,
Location = model.Location,
CallType = model.Calltype,
CallDate = model.Calldate.GetLocalDate(),
Problem = model.Problem,
RateSheet = model.Ratesheet,
Employee = model.Emploee.ToString(),
EstimatedRepairHours = Convert.ToDecimal(model.Estimatehours),
NottoExceed = model.Nottoexceed,
Comments = model.Locationcomments,
CustomerPO = model.Customerpo,
PermissionCode = model.Permissiocode,
PayMethod = model.Paymentmethods,
JCJob = model.JCJob,
Contact = model.Contact,
Equipment = model.Equipment,
};
var result = _sageApiProxy.AddWorkOrder(workorder);
result.Entity.LocationNumber = long.Parse(model.Location);
if (!result.IsSucceed)
{
_log.ErrorFormat("Was not able to save workorder to sage. !result.IsSucceed");
return(Error(result.ErrorMassage));
}
var assignment = result.RelatedAssignment;
assignment.IsValid = true;
if (model.Emploee == 0)
{
result.Entity.AssignmentId = assignment.Assignment;
_repository.Add(assignment);
}
else
{
var employee = _repository.SearchFor <SageEmployee>(x => x.Employee == model.Emploee).SingleOrDefault();
assignment.EmployeeId = employee?.Employee ?? 0;
assignment.Start = (model.AssignmentDate.Date).Add((model.AssignmentTime).TimeOfDay).ToString();
assignment.End = model.AssignmentDate.Date.Add((model.AssignmentTime).TimeOfDay).AddHours(assignment.EstimatedRepairHours.AsDouble() == 0 ? 1 : assignment.EstimatedRepairHours.AsDouble()).ToString();
assignment.Color = employee?.Color ?? "";
assignment.Customer = result.Entity.ARCustomer;
assignment.Location = result.Entity.Location;
var locations = _repository.GetAll <SageLocation>().ToArray();
var itemLocation = locations.FirstOrDefault(l => l.Name == result.Entity.Location);
result.Entity.ScheduleDate = assignment.ScheduleDate;
result.Entity.Latitude = itemLocation.Latitude;
result.Entity.Longitude = itemLocation.Longitude;
_repository.Add(assignment);
_hub.CreateAssignment(new MapViewModel()
{
WorkOrder = result.Entity,
DateEntered = assignment.ScheduleDate,
Employee = employee?.Employee ?? 0,
Color = employee?.Color ?? ""
});
}
_repository.Add(result.Entity);
_log.InfoFormat("Workorder added to repository. ID: {0}, Name: {1}", workorder.Id, workorder.Name);
_notification.SendNotification(string.Format("{0} was created", workorder.WorkOrder));
return(Success());
}
public ActionResult SaveWorkOrder(WorkOrderModel model)
{
_log.InfoFormat("Method: SaveWorkOrder. Model ID {0}", model.Id);
if (model.Emploee == 0)
{
return(Error("Employee is required"));
}
if (model.Location == null)
{
return(Error("Location is required"));
}
if (model.Problem == null)
{
return(Error("Problem is required"));
}
var workorder = new SageWorkOrder()
{
ARCustomer = model.Customer,
Location = model.Location,
CallType = model.Calltype,
CallDate = model.Calldate.GetLocalDate(),
Problem = model.Problem,
RateSheet = model.Ratesheet,
Employee = model.Emploee.ToString(),
EstimatedRepairHours = Convert.ToDecimal(model.Estimatehours),
NottoExceed = model.Nottoexceed,
Comments = model.Locationcomments,
CustomerPO = model.Customerpo,
PermissionCode = model.Permissiocode,
PayMethod = model.Paymentmethods,
WorkOrder = model.WorkOrder,
Id = model.Id,
Status = WorkOrderStatus.ById(model.Status),
JCJob = model.JCJob,
Contact = model.Contact,
Equipment = model.Equipment
};
var workOrderResult = _sageApiProxy.EditWorkOrder(workorder);
workOrderResult.Entity.LocationNumber = long.Parse(model.Location);
if (!workOrderResult.IsSucceed)
{
_log.ErrorFormat("Was not able to update workorder to sage. !result.IsSucceed");
return(Error("Was not able to update workorder to sage"));
}
if (model.Emploee != 0)
{
var assignmentDb = _repository.SearchFor <SageAssignment>(x => x.WorkOrder == model.WorkOrder).Single();
var editedAssignment = new AssignmentViewModel();
editedAssignment.Employee = model.Emploee;
editedAssignment.EndDate = model.AssignmentDate.Date.Add((model.AssignmentTime).TimeOfDay).AddHours(assignmentDb.EstimatedRepairHours.AsDouble() == 0 ? 1 : assignmentDb.EstimatedRepairHours.AsDouble());
editedAssignment.EstimatedRepairHours = workorder.EstimatedRepairHours.ToString();
editedAssignment.Id = assignmentDb.Id;
editedAssignment.ScheduleDate = model.AssignmentDate.Date.Add((model.AssignmentTime).TimeOfDay);
editedAssignment.WorkOrder = assignmentDb.WorkOrder;
_scheduleService.CerateAssignment(editedAssignment);
var locations = _repository.GetAll <SageLocation>().ToArray();
var itemLocation = locations.FirstOrDefault(l => l.Name == workOrderResult.Entity.Location);
workOrderResult.Entity.ScheduleDate = model.AssignmentDate.Date.Add((model.AssignmentTime).TimeOfDay);
workOrderResult.Entity.Latitude = itemLocation.Latitude;
workOrderResult.Entity.Longitude = itemLocation.Longitude;
}
this.ResolveWorkOrderItems(model);
this.ResolveWorkOrderNotes(model);
workOrderResult.Entity.Status = WorkOrderStatus.ById(model.Status);
workOrderResult.Entity.Id = workorder.Id;
workOrderResult.Entity.IsValid = true;
workOrderResult.Entity.WorkOrderItems = _sageApiProxy.GetWorkorderItemsByWorkOrderId(workorder.WorkOrder).Entities;
workOrderResult.Entity.WorkNotes = this._sageApiProxy.GetNotes(workorder.WorkOrder).Entities;
_repository.Update(workOrderResult.Entity);
_log.InfoFormat("Repository update workorder. Name {0}, ID {1}", workorder.Name, workorder.Id);
_hub.UpdateWorkOrder(model);
if (model.Status == WorkOrderStatus.WorkCompleteId)
{
_hub.ShowAlert(new SweetAlertModel()
{
Message = $"Workorder #{model.WorkOrder} closed",
Title = "Workorder completed",
Type = "success"
});
}
return(Success());
}
public WorkOrder(WorkOrderModel model)
{
this.Update(model);
}
public void IntegrationTest()
{
var connection = TestSession.GetConnection();
connection.Open();
#region good insertion and select by id test
WorkOrderModel inserted = new WorkOrderModel();
inserted.ProductID = TestSession.Random.Next();
inserted.OrderQty = TestSession.Random.Next();
inserted.StockedQty = TestSession.Random.Next();
inserted.ScrappedQty = TestSession.Random.RandomShort();
inserted.StartDate = TestSession.Random.RandomDateTime();
inserted.EndDate = TestSession.Random.RandomDateTime();
inserted.DueDate = TestSession.Random.RandomDateTime();
inserted.ScrapReasonID = TestSession.Random.RandomShort();
inserted.ModifiedDate = TestSession.Random.RandomDateTime();
_tested.Insert(connection, new[] { inserted });
var selectedAfterInsertion = _tested.GetByPrimaryKey(connection, new WorkOrderModelPrimaryKey()
{
WorkOrderID = inserted.WorkOrderID,
});
CollectionAssert.IsNotEmpty(selectedAfterInsertion);
var selectedAfterInsert = selectedAfterInsertion.Single();
Assert.AreEqual(inserted.WorkOrderID, selectedAfterInsert.WorkOrderID);
Assert.AreEqual(inserted.ProductID, selectedAfterInsert.ProductID);
Assert.AreEqual(inserted.OrderQty, selectedAfterInsert.OrderQty);
Assert.AreEqual(inserted.StockedQty, selectedAfterInsert.StockedQty);
Assert.AreEqual(inserted.ScrappedQty, selectedAfterInsert.ScrappedQty);
Assert.AreEqual(inserted.StartDate, selectedAfterInsert.StartDate);
Assert.AreEqual(inserted.EndDate, selectedAfterInsert.EndDate);
Assert.AreEqual(inserted.DueDate, selectedAfterInsert.DueDate);
Assert.AreEqual(inserted.ScrapReasonID, selectedAfterInsert.ScrapReasonID);
Assert.AreEqual(inserted.ModifiedDate, selectedAfterInsert.ModifiedDate);
#endregion
#region update and select by id test
inserted.ProductID = TestSession.Random.Next();
inserted.OrderQty = TestSession.Random.Next();
inserted.StockedQty = TestSession.Random.Next();
inserted.ScrappedQty = TestSession.Random.RandomShort();
inserted.StartDate = TestSession.Random.RandomDateTime();
inserted.EndDate = TestSession.Random.RandomDateTime();
inserted.DueDate = TestSession.Random.RandomDateTime();
inserted.ScrapReasonID = TestSession.Random.RandomShort();
inserted.ModifiedDate = TestSession.Random.RandomDateTime();
_tested.Update(connection, new[] { inserted });
var selectedAfterUpdateAddresss = _tested.GetByPrimaryKey(connection, new WorkOrderModelPrimaryKey()
{
WorkOrderID = inserted.WorkOrderID,
});
CollectionAssert.IsNotEmpty(selectedAfterUpdateAddresss);
var selectedAfterUpdate = selectedAfterUpdateAddresss.Single();
Assert.AreEqual(inserted.WorkOrderID, selectedAfterUpdate.WorkOrderID);
Assert.AreEqual(inserted.ProductID, selectedAfterUpdate.ProductID);
Assert.AreEqual(inserted.OrderQty, selectedAfterUpdate.OrderQty);
Assert.AreEqual(inserted.StockedQty, selectedAfterUpdate.StockedQty);
Assert.AreEqual(inserted.ScrappedQty, selectedAfterUpdate.ScrappedQty);
Assert.AreEqual(inserted.StartDate, selectedAfterUpdate.StartDate);
Assert.AreEqual(inserted.EndDate, selectedAfterUpdate.EndDate);
Assert.AreEqual(inserted.DueDate, selectedAfterUpdate.DueDate);
Assert.AreEqual(inserted.ScrapReasonID, selectedAfterUpdate.ScrapReasonID);
Assert.AreEqual(inserted.ModifiedDate, selectedAfterUpdate.ModifiedDate);
#endregion
#region delete test
_tested.Delete(connection, new[] { inserted });
var selectedAfterDeleteAddresss = _tested.GetByPrimaryKey(connection, new WorkOrderModelPrimaryKey()
{
WorkOrderID = inserted.WorkOrderID,
});
CollectionAssert.IsEmpty(selectedAfterDeleteAddresss);
#endregion
connection.Close();
}
public static WorkOrder ToEntity(this WorkOrderModel model)
{
return(model.MapTo <WorkOrderModel, WorkOrder>());
}
public WorkOrderModel GetWorkOrderModel(IRecordContext RecordContext)
{
ICustomObject workOrder = RecordContext.GetWorkspaceRecord(RecordContext.WorkspaceTypeName) as ICustomObject;
IContact contact = RecordContext.GetWorkspaceRecord(WorkspaceRecordType.Contact) as IContact;
WorkOrderModel workOrderModel = new WorkOrderModel();
_log.Notice("Processing WorkOrder:" + workOrder.Id.ToString());
if (workOrder != null)
{
IList <IGenericField> fields = workOrder.GenericFields;
workOrderModel.AppointmentNumber = workOrder.Id.ToString();
InventoryModel primaryAssetInventoryModel = null;
int workorderTypeId = (Int32)getFieldFromWorOrderRecord(workOrder, "WO_Type");
string[] workordertype = RightNowConnectService.GetService().GetWorkOrderTypeFromID(workorderTypeId);
_log.Notice("WorkOrder Type ID:" + workordertype[0]);
foreach (IGenericField field in fields)
{
if (field.DataValue.Value != null)
{
switch (field.Name)
{
case "Asset":
//cannot use record context here as Asset WorkspaceType is not exposed through RightNow.AddIns.Common.
//TODO Un-Comment below lines when RN Connect Services are available
if (null != field.DataValue.Value)
{
primaryAssetInventoryModel = new InventoryModel();
int assetid = (int)field.DataValue.Value;
_log.Notice("WorkOrder Primary Asset ID:" + assetid);
string[] details = RightNowConnectService.GetService().GetAssetDetailsFromAssetID(assetid.ToString());
string[] productDetails = RightNowConnectService.GetService().GetProductDetailsFromProductID(details[0]); //Type = Product's ID (i.e. SalesProduct.PartNumber)
if (null != productDetails && productDetails.Length > 0)
{
primaryAssetInventoryModel.Type = productDetails[0];
}
else
{
_log.Warning("invtype_label is not valid for primary asset.");
}
if (details.Length > 1)
{
primaryAssetInventoryModel.SerialNumber = details[1]; //model = Serial Number
}
}
break;
case "Case_Note":
workOrderModel.SetPropertyValue("XA_CASE_NOTES", field.DataValue.Value.ToString());
break;
case "Cancel_Reason":
workOrderModel.CancelReason = field.DataValue.Value.ToString();
break;
case "Contact":
if (contact != null)
{
workOrderModel.CustomerNumber = contact.ID.ToString();
_log.Notice("WorkOrder Contact ID:" + contact.ID.ToString());
workOrderModel.Name = contact.NameFirst + " " + contact.NameLast;
}
break;
case "Contact_City":
workOrderModel.City = field.DataValue.Value.ToString();
break;
case "Contact_Email":
workOrderModel.EmailAddress = field.DataValue.Value.ToString();
break;
case "Contact_Mobile_Phone":
workOrderModel.MobileNumber = field.DataValue.Value.ToString();
break;
case "Contact_Phone":
workOrderModel.PhoneNumber = field.DataValue.Value.ToString();
break;
case "Contact_Postal_Code":
workOrderModel.ZipCode = field.DataValue.Value.ToString();
break;
case "Contact_Province_State":
int province_id = (Int32)field.DataValue.Value;
string name = RightNowConnectService.GetService().GetProvinceName(province_id);
if (name != null)
{
workOrderModel.State = name;
}
break;
case "Contact_Street":
workOrderModel.Address = field.DataValue.Value.ToString();
break;
case "Duration":
if (null == field.DataValue.Value)
{
if (workordertype[1].Equals("1"))
{
workOrderModel.Duration = workordertype[2];
}
_log.Notice("WorkOrder Duration :" + workOrderModel.Duration);
}
else
{
workOrderModel.Duration = field.DataValue.Value.ToString();
_log.Notice("WorkOrder Duration :" + workOrderModel.Duration);
}
break;
case "Reminder_Time":
if (null != field.DataValue.Value)
{
int id = Convert.ToInt32(field.DataValue.Value);
string[] remindertime1 = RightNowConnectService.GetService().GetReminder_TimeFromID(id);
workOrderModel.ReminderTime = Convert.ToInt32(remindertime1[0]);
}
break;
case "Requested_Service_End":
workOrderModel.ServiceWindowEnd = field.DataValue.Value.ToString();
break;
case "Requested_Service_Start":
workOrderModel.ServiceWindowStart = field.DataValue.Value.ToString();
break;
case "Resolution_Due":
workOrderModel.SlaWindowEnd = Convert.ToDateTime(field.DataValue.Value);
break;
case "WO_Area":
workOrderModel.ExternalId = field.DataValue.Value.ToString();
break;
case "WO_Date":
workOrderModel.AssignedDate = ((DateTime)field.DataValue.Value).ToString("yyyy-MM-dd");
break;
case "WO_Status":
//Set it for each handler and not in generic code.
break;
case "WO_Time_Slot":
workOrderModel.TimeSlot = field.DataValue.Value.ToString();
break;
case "WO_Type":
workOrderModel.WorkType = workordertype[0];
break;
}
}
}
//Set Duration
if (workOrderModel.Duration == null)
{
if (workordertype[1].Equals("1"))
{
workOrderModel.Duration = workordertype[2];
}
_log.Notice("WorkOrder Duration :" + workOrderModel.Duration);
}
// Set Cancel Activity
if (workOrderModel.CancelReason != null && !workOrderModel.CancelReason.Trim().Equals(""))
{
workOrderModel.CommandType = Client.Common.ActivityCommandType.Cancel;
}
else // Set Update Activity
{
workOrderModel.Status = Client.Common.ActivityStatus.Pending;
workOrderModel.CommandType = Client.Common.ActivityCommandType.Update;
}
_log.Notice("WorOrder Command Type is set as " + ToaStringsUtil.GetString(workOrderModel.CommandType));
workOrderModel.SetActionIfCompleted = Client.Common.ActionIfCompleted.CreateIfAssignOrReschedule;
//TODO UnComment below code
SetInventoryModel(workOrderModel, workOrder.Id, primaryAssetInventoryModel, workorderTypeId);
}
return(workOrderModel);
}
