/// <summary>
/// Executes the plug-in.
/// </summary>
/// <param name="localContext">The <see cref="LocalPluginContext"/> which contains the
/// <see cref="IPluginExecutionContext"/>,
/// <see cref="IOrganizationService"/>
/// and <see cref="ITracingService"/>
/// </param>
/// <remarks>
/// For improved performance, Microsoft Dynamics CRM caches plug-in instances.
/// The plug-in's Execute method should be written to be stateless as the constructor
/// is not called for every invocation of the plug-in. Also, multiple system threads
/// could execute the plug-in at the same time. All per invocation state information
/// is stored in the context. This means that you should not use global variables in plug-ins.
/// </remarks>
protected void ExecutePreReceivingTransactionCreate(LocalPluginContext localContext)
{
if (localContext == null)
{
throw new ArgumentNullException("localContext");
}
IPluginExecutionContext context = localContext.PluginExecutionContext;
IOrganizationService service = localContext.OrganizationService;
ITracingService trace = localContext.TracingService;
Entity receivingTransactionEntity = (Entity)context.InputParameters["Target"];
string message = context.MessageName;
string error = "";
try
{
ReceivingTransactionHandler receivingTransactionHandler = new ReceivingTransactionHandler(service, trace);
receivingTransactionHandler.ReplicatePurchaseOrderFields(receivingTransactionEntity);
receivingTransactionHandler.IsWBNoUnique(receivingTransactionEntity);
receivingTransactionHandler.ValidateInvoiceNo(receivingTransactionEntity);
}
catch (Exception ex)
{
throw new InvalidPluginExecutionException(ex.Message);
//throw new InvalidPluginExecutionException(String.Concat("(Exception)\n", ex.Message, Environment.NewLine, ex.StackTrace, Environment.NewLine, error));
}
}
/// <summary>
/// Executes the plug-in.
/// </summary>
/// <param name="localContext">The <see cref="LocalPluginContext"/> which contains the
/// <see cref="IPluginExecutionContext"/>,
/// <see cref="IOrganizationService"/>
/// and <see cref="ITracingService"/>
/// </param>
/// <remarks>
/// For improved performance, Microsoft Dynamics CRM caches plug-in instances.
/// The plug-in's Execute method should be written to be stateless as the constructor
/// is not called for every invocation of the plug-in. Also, multiple system threads
/// could execute the plug-in at the same time. All per invocation state information
/// is stored in the context. This means that you should not use global variables in plug-ins.
/// </remarks>
protected void ExecutePreValidateReceivingTransactionDelete(LocalPluginContext localContext)
{
if (localContext == null)
{
throw new ArgumentNullException("localContext");
}
IPluginExecutionContext context = localContext.PluginExecutionContext;
IOrganizationService service = localContext.OrganizationService;
ITracingService trace = localContext.TracingService;
var ReceivingTransactionTargetEntity = (EntityReference)context.InputParameters["Target"];
try
{
ReceivingTransactionHandler ReceivingTransaction = new ReceivingTransactionHandler(service, trace);
EntityCollection ReceivingTransactionEC = CommonHandler.RetrieveRecordsByOneValue(ReceivingTransactionTargetEntity.LogicalName, "gsc_cmn_receivingtransactionid", ReceivingTransactionTargetEntity.Id, service,
null, OrderType.Ascending, new[] { "gsc_cmn_receivingtransactionid", "gsc_receivingstatus", "gsc_purchaseorderid" });
if (ReceivingTransactionEC.Entities.Count > 0)
{
Entity ReceivingTransactionEntity = ReceivingTransactionEC.Entities[0];
var status = ReceivingTransactionEntity.Contains("gsc_receivingstatus")
? ReceivingTransactionEntity.GetAttributeValue <OptionSetValue>("gsc_receivingstatus").Value
: 0;
if (status == 100000003)
{
if (ReceivingTransaction.IsAllocatedVehicle(ReceivingTransactionEntity) == true)
{
throw new InvalidPluginExecutionException("Vehicle is currently allocated, remove the allocation to delete the record.");
}
}
else if (status == 100000000)
{
throw new InvalidPluginExecutionException("Cannot delete cancelled transaction.");
}
else if (status == 100000004)
{
throw new InvalidPluginExecutionException("Cannot delete received transaction.");
}
//ReceivingTransaction.TagVPOReceivingStatusCreated(ReceivingTransactionEntity);
ReceivingTransaction.DeleteReceivingTransaction(ReceivingTransactionEntity);
ReceivingTransaction.DeleteReceivingComponents(ReceivingTransactionEntity);
}
}
catch (Exception ex)
{
throw new InvalidPluginExecutionException(ex.Message);
//throw new InvalidPluginExecutionException(String.Concat("(Exception)\n", ex.Message, Environment.NewLine, ex.StackTrace, Environment.NewLine));
}
}
/// <summary>
/// Executes the plug-in.
/// </summary>
/// <param name="localContext">The <see cref="LocalPluginContext"/> which contains the
/// <see cref="IPluginExecutionContext"/>,
/// <see cref="IOrganizationService"/>
/// and <see cref="ITracingService"/>
/// </param>
/// <remarks>
/// For improved performance, Microsoft Dynamics CRM caches plug-in instances.
/// The plug-in's Execute method should be written to be stateless as the constructor
/// is not called for every invocation of the plug-in. Also, multiple system threads
/// could execute the plug-in at the same time. All per invocation state information
/// is stored in the context. This means that you should not use global variables in plug-ins.
/// </remarks>
protected void ExecutePostReceivingTransactionCreate(LocalPluginContext localContext)
{
if (localContext == null)
{
throw new ArgumentNullException("localContext");
}
IPluginExecutionContext context = localContext.PluginExecutionContext;
IOrganizationService service = localContext.OrganizationService;
ITracingService trace = localContext.TracingService;
Entity receivingTransactionEntity = (Entity)context.InputParameters["Target"];
string message = context.MessageName;
string error = "";
try
{
EntityCollection receivingTransactionRecords = CommonHandler.RetrieveRecordsByOneValue("gsc_cmn_receivingtransaction", "gsc_cmn_receivingtransactionid", receivingTransactionEntity.Id, service, null, OrderType.Ascending,
new[] { "gsc_purchaseorderid", "gsc_receivingstatus", "gsc_isintegrated", "gsc_receivingtransactionpn", "gsc_vehiclebasemodelid", "gsc_pulloutdate" });
if (receivingTransactionRecords != null && receivingTransactionRecords.Entities.Count > 0)
{
ReceivingTransactionHandler receivingTransactionHandler = new ReceivingTransactionHandler(service, trace);
Entity receivingTransaction = receivingTransactionRecords.Entities[0];
receivingTransactionHandler.ReplicatePurchaseOrderDetailFields(receivingTransaction);
receivingTransactionHandler.PopulateVehicleComponentChecklist(receivingTransaction);
receivingTransactionHandler.TagVPOReceivingStatusCreated(receivingTransaction);
}
}
catch (Exception ex)
{
//throw new InvalidPluginExecutionException(String.Concat("(Exception)\n", ex.Message, Environment.NewLine, ex.StackTrace, Environment.NewLine, error));
throw new InvalidPluginExecutionException(ex.Message);
}
}
/// <summary>
/// Executes the plug-in.
/// </summary>
/// <param name="localContext">The <see cref="LocalPluginContext"/> which contains the
/// <see cref="IPluginExecutionContext"/>,
/// <see cref="IOrganizationService"/>
/// and <see cref="ITracingService"/>
/// </param>
/// <remarks>
/// For improved performance, Microsoft Dynamics CRM caches plug-in instances.
/// The plug-in's Execute method should be written to be stateless as the constructor
/// is not called for every invocation of the plug-in. Also, multiple system threads
/// could execute the plug-in at the same time. All per invocation state information
/// is stored in the context. This means that you should not use global variables in plug-ins.
/// </remarks>
protected void ExecutePostReceivingTransactionUpdate(LocalPluginContext localContext)
{
if (localContext == null)
{
throw new ArgumentNullException("localContext");
}
IPluginExecutionContext context = localContext.PluginExecutionContext;
Entity preImageEntity = (context.PreEntityImages != null && context.PreEntityImages.Contains(this.preImageAlias)) ? context.PreEntityImages[this.preImageAlias] : null;
Entity postImageEntity = (context.PostEntityImages != null && context.PostEntityImages.Contains(this.postImageAlias)) ? context.PostEntityImages[this.postImageAlias] : null;
IOrganizationService service = localContext.OrganizationService;
ITracingService trace = localContext.TracingService;
Entity receivingTransactionEntity = (Entity)context.InputParameters["Target"];
if (!(context.InputParameters.Contains("Target") && context.InputParameters["Target"] is Entity)) { return; }
if (receivingTransactionEntity.LogicalName != "gsc_cmn_receivingtransaction") { return; }
if (context.Mode == 0) //Synchronous Plug-in
{
string message = context.MessageName;
try
{
#region Pre-images
var preImageReceivingStatus = preImageEntity.Contains("gsc_receivingstatus")
? preImageEntity.GetAttributeValue<OptionSetValue>("gsc_receivingstatus").Value
: 0;
var preImageWBNo = preImageEntity.Contains("gsc_warrantybookletno")
? preImageEntity.GetAttributeValue<String>("gsc_warrantybookletno")
: String.Empty;
var preImagInvoiceNo = preImageEntity.Contains("gsc_invoiceno")
? preImageEntity.GetAttributeValue<String>("gsc_invoiceno")
: String.Empty;
#endregion
#region Post-images
var postImageReceivingStatus = postImageEntity.Contains("gsc_receivingstatus")
? postImageEntity.GetAttributeValue<OptionSetValue>("gsc_receivingstatus").Value
: 0;
var postImageWBNo = postImageEntity.Contains("gsc_warrantybookletno")
? postImageEntity.GetAttributeValue<String>("gsc_warrantybookletno")
: String.Empty;
var postImagInvoiceNo = postImageEntity.Contains("gsc_invoiceno")
? postImageEntity.GetAttributeValue<String>("gsc_invoiceno")
: String.Empty;
#endregion
ReceivingTransactionHandler receivingTransactionHandler = new ReceivingTransactionHandler(service, trace);
if (preImageWBNo != postImageWBNo)
{
receivingTransactionHandler.IsWBNoUnique(postImageEntity);
receivingTransactionHandler.UpdateInventoryWBNo(postImageEntity);
}
if (preImagInvoiceNo != postImagInvoiceNo)
{
receivingTransactionHandler.ValidateInvoiceNo(postImageEntity);
}
if (preImageReceivingStatus != postImageReceivingStatus)
{
receivingTransactionHandler.UpdatePOItem(postImageEntity);
receivingTransactionHandler.UpdateVPOSatus(postImageEntity);
receivingTransactionHandler.SubtractinUnservedPO(postImageEntity);
receivingTransactionHandler.InventoryMovementUponReceiving(postImageEntity);
if (postImageReceivingStatus == 100000000)
{
if (receivingTransactionHandler.IsAllocatedVehicle(postImageEntity) == true)
{
postImageEntity["gsc_receivingstatus"] = new OptionSetValue(100000003);
throw new InvalidPluginExecutionException("Vehicle is currently allocated, remove the allocation to cancel the record.");
}
receivingTransactionHandler.CancelReceivingTransaction(postImageEntity);
}
if (postImageReceivingStatus == 100000003 || postImageReceivingStatus == 100000004)
{
receivingTransactionHandler.UpdateVPOSatusinVPO(postImageEntity);
}
}
}
catch (Exception ex)
{
//if (ex.Message.Contains("Vehicle is currently allocated, remove the allocation to cancel the record."))
throw new InvalidPluginExecutionException(ex.Message);
// else
// throw new InvalidPluginExecutionException(String.Concat("(Exception)\n", ex.Message, Environment.NewLine, ex.StackTrace));
}
}
}
public void CancelReceivingTransaction()
{
#region 1. Setup / Arrange
var orgServiceMock = new Mock <IOrganizationService>();
var orgService = orgServiceMock.Object;
var orgTracingMock = new Mock <ITracingService>();
var orgTracing = orgTracingMock.Object;
#region Purchase Order EntityCollection
var PurchaseOrderCollection = new EntityCollection
{
EntityName = "gsc_cmn_purchaseorder",
Entities =
{
new Entity
{
Id = Guid.NewGuid(),
LogicalName = "gsc_cmn_purchaseorder",
EntityState = EntityState.Created,
Attributes = new AttributeCollection
{
{ "gsc_vpostatus", new OptionSetValue(100000002) }
}
}
}
};
#endregion
#region Receiving Transaction EntityCollection
var ReceivingTransactionCollection = new EntityCollection
{
EntityName = "gsc_cmn_receivingtransaction",
Entities =
{
new Entity
{
Id = Guid.NewGuid(),
LogicalName = "gsc_cmn_receivingtransaction",
EntityState = EntityState.Created,
Attributes = new AttributeCollection
{
{ "gsc_mmpcstatus", "Inactive" },
{ "gsc_vpostatus", "In-Transit" },
{ "gsc_purchaseorderid", PurchaseOrderCollection.Entities[0].Id }
}
}
}
};
#endregion
#region Product Quantity EntityCollection
var ProductQuantityCollection = new EntityCollection
{
EntityName = "gsc_iv_productquantity",
Entities =
{
new Entity
{
Id = Guid.NewGuid(),
LogicalName = "gsc_iv_productquantiy",
EntityState = EntityState.Created,
Attributes = new AttributeCollection
{
{ "gsc_onhand", (Int32)2 },
{ "gsc_available", (Int32)2 },
{ "gsc_onorder", (Int32)11 }
}
}
}
};
#endregion
#region Inventory EntityCollection
var InventoryCollection = new EntityCollection
{
EntityName = "gsc_iv_inventory",
Entities =
{
new Entity
{
Id = Guid.NewGuid(),
LogicalName = "gsc_iv_inventory",
EntityState = EntityState.Created,
Attributes = new AttributeCollection
{
{ "gsc_productquantityid", Guid.NewGuid() }
}
}
}
};
#endregion
#region Receiving Transaction Detail EntityCollection
var ReceivingTransactionDetailCollection = new EntityCollection
{
EntityName = "gsc_cmn_receivingtransactiondetail",
Entities =
{
new Entity
{
Id = Guid.NewGuid(),
LogicalName = "gsc_cmn_receivingtransactiondetail",
EntityState = EntityState.Created,
Attributes = new AttributeCollection
{
{ "gsc_receivingtransactionid", ReceivingTransactionCollection.Entities[0].Id },
{ "gsc_inventoryid", InventoryCollection.Entities[0].Id }
}
}
}
};
#endregion
orgServiceMock.Setup((service => service.RetrieveMultiple(
It.Is <QueryExpression>(expression => expression.EntityName == ProductQuantityCollection.EntityName)
))).Returns(ProductQuantityCollection);
orgServiceMock.Setup((service => service.RetrieveMultiple(
It.Is <QueryExpression>(expression => expression.EntityName == ReceivingTransactionCollection.EntityName)
))).Returns(ReceivingTransactionCollection);
orgServiceMock.Setup((service => service.RetrieveMultiple(
It.Is <QueryExpression>(expression => expression.EntityName == InventoryCollection.EntityName)
))).Returns(InventoryCollection);
orgServiceMock.Setup((service => service.RetrieveMultiple(
It.Is <QueryExpression>(expression => expression.EntityName == ReceivingTransactionDetailCollection.EntityName)
))).Returns(ReceivingTransactionDetailCollection);
#endregion
#region 2. Call / Action
var ReceivingTransactionHandler = new ReceivingTransactionHandler(orgService, orgTracing);
Entity receivingTransaction = ReceivingTransactionHandler.CancelReceivingTransaction(ReceivingTransactionCollection.Entities[0]);
#endregion
#region 3. Verify
Assert.AreEqual("", "");
#endregion
}
public void ReplicatePurchaseOrderFields()
{
#region 1. Setup / Arrange
var orgServiceMock = new Mock <IOrganizationService>();
var orgService = orgServiceMock.Object;
var orgTracingMock = new Mock <ITracingService>();
var orgTracing = orgTracingMock.Object;
#region Purchase Order EntityCollection
var PurchaseOrderCollection = new EntityCollection
{
EntityName = "gsc_cmn_purchaseorder",
Entities =
{
new Entity
{
Id = Guid.NewGuid(),
LogicalName = "gsc_cmn_purchaseorder",
EntityState = EntityState.Created,
Attributes = new AttributeCollection
{
{ "gsc_vendorid", new EntityReference("gsc_cmn_vendor", Guid.NewGuid()) },
{ "gsc_vendorname", "PO1234" },
{ "gsc_siteid", new EntityReference("gsc_iv_site", Guid.NewGuid()) },
{ "gsc_vpostatus", new OptionSetValue(0) },
{ "gsc_mmpcstatus", new OptionSetValue(0) }
},
FormattedValues =
{
{ "gsc_vpostatus", "Open" },
{ "gsc_mmpcstatus", "Invoice Not Pulled Out" }
}
}
}
};
#endregion
#region Receiving Transaction EntityCollection
var ReceivingTransactionCollection = new EntityCollection
{
EntityName = "gsc_cmn_receivingtransaction",
Entities =
{
new Entity
{
Id = Guid.NewGuid(),
LogicalName = "gsc_cmn_receivingtransaction",
EntityState = EntityState.Created,
Attributes = new AttributeCollection
{
{ "gsc_purchaseorderid", new EntityReference("gsc_cmn_purchaseorder", PurchaseOrderCollection.Entities[0].Id) }
}
}
}
};
#endregion
orgServiceMock.Setup((service => service.RetrieveMultiple(
It.Is <QueryExpression>(expression => expression.EntityName == PurchaseOrderCollection.EntityName)
))).Returns(PurchaseOrderCollection);
orgServiceMock.Setup((service => service.RetrieveMultiple(
It.Is <QueryExpression>(expression => expression.EntityName == ReceivingTransactionCollection.EntityName)
))).Returns(ReceivingTransactionCollection);
#endregion
#region 2. Call / Action
var ReceivingTransactionHandler = new ReceivingTransactionHandler(orgService, orgTracing);
Entity receivingTransaction = ReceivingTransactionHandler.ReplicatePurchaseOrderFields(ReceivingTransactionCollection.Entities[0]);
#endregion
#region 3. Verify
Assert.AreEqual(PurchaseOrderCollection.Entities[0].FormattedValues["gsc_vpostatus"], receivingTransaction.GetAttributeValue <String>("gsc_vpostatus"));
Assert.AreEqual(PurchaseOrderCollection.Entities[0].FormattedValues["gsc_mmpcstatus"], receivingTransaction.GetAttributeValue <String>("gsc_mmpcstatus"));
Assert.AreEqual(PurchaseOrderCollection.Entities[0].GetAttributeValue <EntityReference>("gsc_vendorid").Id, receivingTransaction.GetAttributeValue <EntityReference>("gsc_vendorid").Id);
Assert.AreEqual(PurchaseOrderCollection.Entities[0].GetAttributeValue <String>("gsc_vendorname"), receivingTransaction.GetAttributeValue <String>("gsc_vendorname"));
Assert.AreEqual(PurchaseOrderCollection.Entities[0].GetAttributeValue <EntityReference>("gsc_siteid").Id, receivingTransaction.GetAttributeValue <EntityReference>("gsc_siteid").Id);
#endregion
}
//Created By : Jerome Anthony Gerero, Created On : 2/3/2017
/*Purpose: Create Inventory record on Receiving Transaction Detail update
* Registration Details:
* Event/Message:
* Pre/Create:
* Post/Update: Model Code, Option Code, CS No, VIN, Production No, Engine No
* Post/Create:
* Primary Entity: Receiving Transaction Detail
*/
public Entity CreateUpdateInventoryRecord(Entity receivingTransactionDetail)
{
_tracingService.Trace("Started CreateUpdateInventoryRecord Method...");
ReceivingTransactionHandler receivingHandler = new ReceivingTransactionHandler(_organizationService, _tracingService);
Guid receivingTransactionId = receivingTransactionDetail.GetAttributeValue <EntityReference>("gsc_receivingtransactionid").Id;
//Retrieve In-Transit Site field from Receiving Transaction record
Entity receivingTransaction = _organizationService.Retrieve("gsc_cmn_receivingtransaction", receivingTransactionId, new ColumnSet("gsc_intransitsiteid", "gsc_receivingstatus", "gsc_receivingtransactionpn", "gsc_vendorid", "gsc_vendorname", "gsc_intransitreceiptdate"));
if (!receivingTransaction.FormattedValues["gsc_receivingstatus"].Equals("Open"))
{
_tracingService.Trace("Status not Open.");
return(null);
}
String productName = receivingTransactionDetail.Contains("gsc_productid")
? receivingTransactionDetail.GetAttributeValue <EntityReference>("gsc_productid").Name
: String.Empty;
String colorName = receivingTransactionDetail.Contains("gsc_vehiclecolorid")
? receivingTransactionDetail.GetAttributeValue <EntityReference>("gsc_vehiclecolorid").Name
: String.Empty;
String inTransitSiteName = receivingTransaction.Contains("gsc_intransitsiteid")
? receivingTransaction.GetAttributeValue <EntityReference>("gsc_intransitsiteid").Name
: String.Empty;
EntityReference inventoryId = receivingTransactionDetail.Contains("gsc_inventoryid")
? receivingTransactionDetail.GetAttributeValue <EntityReference>("gsc_inventoryid")
: null;
Guid inTransitSite = receivingTransaction.Contains("gsc_intransitsiteid") ? receivingTransaction.GetAttributeValue <EntityReference>("gsc_intransitsiteid").Id
: Guid.Empty;
DateTime transactionDate = receivingTransaction.Contains("gsc_intransitreceiptdate") ? receivingTransaction.GetAttributeValue <DateTime>("gsc_intransitreceiptdate") : DateTime.MinValue;
if (inventoryId == null)
{
_tracingService.Trace("Create Inventory.");
Int32 onHand = 0;
Int32 available = 0;
//Create new inventory record
Entity inventory = new Entity("gsc_iv_inventory");
inventory["gsc_inventorypn"] = productName + "-" + colorName + "-" + inTransitSiteName;
inventory["gsc_color"] = colorName;
inventory["gsc_vin"] = receivingTransactionDetail.Contains("gsc_vin")
? receivingTransactionDetail.GetAttributeValue <String>("gsc_vin")
: String.Empty;
inventory["gsc_engineno"] = receivingTransactionDetail.Contains("gsc_engineno")
? receivingTransactionDetail.GetAttributeValue <String>("gsc_engineno")
: String.Empty;
inventory["gsc_optioncode"] = receivingTransactionDetail.Contains("gsc_optioncode")
? receivingTransactionDetail.GetAttributeValue <String>("gsc_optioncode")
: String.Empty;
inventory["gsc_csno"] = receivingTransactionDetail.Contains("gsc_csno")
? receivingTransactionDetail.GetAttributeValue <String>("gsc_csno")
: String.Empty;
inventory["gsc_modelcode"] = receivingTransactionDetail.Contains("gsc_modelcode")
? receivingTransactionDetail.GetAttributeValue <String>("gsc_modelcode")
: String.Empty;
inventory["gsc_productionno"] = receivingTransactionDetail.Contains("gsc_productionno")
? receivingTransactionDetail.GetAttributeValue <String>("gsc_productionno")
: String.Empty;
inventory["gsc_modelyear"] = receivingTransactionDetail.Contains("gsc_modelyear")
? receivingTransactionDetail.GetAttributeValue <String>("gsc_modelyear")
: String.Empty;
inventory["gsc_siteid"] = receivingTransaction.Contains("gsc_intransitsiteid")
? receivingTransaction.GetAttributeValue <EntityReference>("gsc_intransitsiteid")
: null;
Guid newInventory = _organizationService.Create(inventory);
_tracingService.Trace("Inventory Created");
Entity newInventoryEntity = _organizationService.Retrieve("gsc_iv_inventory", newInventory, new ColumnSet("gsc_productquantityid"));
receivingTransactionDetail["gsc_inventoryid"] = new EntityReference("gsc_iv_inventory", newInventory);
_organizationService.Update(receivingTransactionDetail);
_tracingService.Trace("Updated Receiving Item Inventory");
//Reference inventory to product quantity
Guid productId = receivingTransactionDetail.Contains("gsc_productid")
? receivingTransactionDetail.GetAttributeValue <EntityReference>("gsc_productid").Id
: Guid.Empty;
Guid inTransitSiteId = receivingTransaction.Contains("gsc_intransitsiteid")
? receivingTransaction.GetAttributeValue <EntityReference>("gsc_intransitsiteid").Id
: Guid.Empty;
Guid colorId = receivingTransactionDetail.Contains("gsc_vehiclecolorid")
? receivingTransactionDetail.GetAttributeValue <EntityReference>("gsc_vehiclecolorid").Id
: Guid.Empty;
var productQuantityFilter = new List <ConditionExpression>
{
new ConditionExpression("gsc_productid", ConditionOperator.Equal, productId),
new ConditionExpression("gsc_siteid", ConditionOperator.Equal, inTransitSiteId),
new ConditionExpression("gsc_vehiclecolorid", ConditionOperator.Equal, colorId),
new ConditionExpression("gsc_isonorder", ConditionOperator.Equal, false)
};
EntityCollection productQuantityRecords = CommonHandler.RetrieveRecordsByConditions("gsc_iv_productquantity", productQuantityFilter, _organizationService, null, OrderType.Ascending,
new[] { "gsc_iv_productquantityid", "gsc_onhand", "gsc_available", "gsc_allocated", "gsc_onorder", "gsc_sold", "gsc_intransit", "gsc_damaged", "gsc_backorder" });
_tracingService.Trace("Product Quantity record/s retrieved : " + productQuantityRecords.Entities.Count);
if (productQuantityRecords != null && productQuantityRecords.Entities.Count > 0)
{
_tracingService.Trace("Retrieve Product Quantity");
Entity productQuantity = productQuantityRecords.Entities[0];
newInventoryEntity["gsc_productquantityid"] = new EntityReference("gsc_iv_productquantity", productQuantity.Id);
_organizationService.Update(newInventoryEntity);
_tracingService.Trace("Inventory Product Quantity Updated");
onHand = productQuantity.GetAttributeValue <Int32>("gsc_onhand") + 1;
available = productQuantity.GetAttributeValue <Int32>("gsc_available") + 1;
productQuantity["gsc_onhand"] = onHand;
productQuantity["gsc_available"] = available;
_organizationService.Update(productQuantity);
_tracingService.Trace("Product Quantity Updated");
}
else
{
_tracingService.Trace("Create Product Quantity");
Entity productQuantity = new Entity("gsc_iv_productquantity");
productQuantity["gsc_productquantitypn"] = productName;
productQuantity["gsc_siteid"] = receivingTransaction.Contains("gsc_intransitsiteid")
? receivingTransaction.GetAttributeValue <EntityReference>("gsc_intransitsiteid")
: null;
productQuantity["gsc_productid"] = receivingTransactionDetail.Contains("gsc_productid")
? receivingTransactionDetail.GetAttributeValue <EntityReference>("gsc_productid")
: null;
productQuantity["gsc_vehiclecolorid"] = receivingTransactionDetail.Contains("gsc_vehiclecolorid")
? receivingTransactionDetail.GetAttributeValue <EntityReference>("gsc_vehiclecolorid")
: null;
productQuantity["gsc_vehiclemodelid"] = receivingTransactionDetail.Contains("gsc_basemodelid")
? receivingTransactionDetail.GetAttributeValue <EntityReference>("gsc_basemodelid")
: null;
Guid newProductQuantity = _organizationService.Create(productQuantity);
newInventoryEntity["gsc_productquantityid"] = new EntityReference("gsc_iv_productquantity", newProductQuantity);
_organizationService.Update(newInventoryEntity);
_tracingService.Trace("Inventory Product Quantity Updated");
EntityCollection productQuantity2Records = CommonHandler.RetrieveRecordsByOneValue("gsc_iv_productquantity", "gsc_iv_productquantityid", newProductQuantity, _organizationService, null, OrderType.Ascending,
new[] { "gsc_onhand", "gsc_available", "gsc_allocated", "gsc_onorder", "gsc_sold", "gsc_intransit", "gsc_damaged", "gsc_backorder" });
if (productQuantity2Records != null && productQuantity2Records.Entities.Count > 0)
{
Entity productQuantity2 = productQuantity2Records.Entities[0];
onHand = productQuantity2.GetAttributeValue <Int32>("gsc_onhand") + 1;
available = productQuantity2.GetAttributeValue <Int32>("gsc_available") + 1;
productQuantity2["gsc_onhand"] = onHand;
productQuantity2["gsc_available"] = available;
_organizationService.Update(productQuantity2);
_tracingService.Trace("Product Quantity Updated");
}
}
receivingHandler.CreateReceivingInventoryHistory(receivingTransaction, transactionDate, 1, 0, inTransitSite, Guid.Empty, inTransitSite, onHand, true);
}
else
{
_tracingService.Trace("Update Inventory");
//Update existing inventory record
EntityCollection inventoryRecords = CommonHandler.RetrieveRecordsByOneValue("gsc_iv_inventory", "gsc_iv_inventoryid", inventoryId.Id, _organizationService, null, OrderType.Ascending,
new[] { "gsc_productquantityid" });
if (inventoryRecords != null && inventoryRecords.Entities.Count > 0)
{
_tracingService.Trace("Retrieve Inventory");
Entity inventory = inventoryRecords.Entities[0];
inventory["gsc_inventorypn"] = productName + "-" + colorName + "-" + inTransitSiteName;
inventory["gsc_color"] = receivingTransactionDetail.Contains("gsc_vehiclecolorid")
? receivingTransactionDetail.GetAttributeValue <EntityReference>("gsc_vehiclecolorid").Name
: String.Empty;
inventory["gsc_vin"] = receivingTransactionDetail.Contains("gsc_vin")
? receivingTransactionDetail.GetAttributeValue <String>("gsc_vin")
: String.Empty;
inventory["gsc_engineno"] = receivingTransactionDetail.Contains("gsc_engineno")
? receivingTransactionDetail.GetAttributeValue <String>("gsc_engineno")
: String.Empty;
inventory["gsc_optioncode"] = receivingTransactionDetail.Contains("gsc_optioncode")
? receivingTransactionDetail.GetAttributeValue <String>("gsc_optioncode")
: String.Empty;
inventory["gsc_csno"] = receivingTransactionDetail.Contains("gsc_csno")
? receivingTransactionDetail.GetAttributeValue <String>("gsc_csno")
: String.Empty;
inventory["gsc_modelcode"] = receivingTransactionDetail.Contains("gsc_modelcode")
? receivingTransactionDetail.GetAttributeValue <String>("gsc_modelcode")
: String.Empty;
inventory["gsc_productionno"] = receivingTransactionDetail.Contains("gsc_productionno")
? receivingTransactionDetail.GetAttributeValue <String>("gsc_productionno")
: String.Empty;
inventory["gsc_modelyear"] = receivingTransactionDetail.Contains("gsc_modelyear")
? receivingTransactionDetail.GetAttributeValue <String>("gsc_modelyear")
: String.Empty;
inventory["gsc_siteid"] = receivingTransaction.Contains("gsc_intransitsiteid")
? receivingTransaction.GetAttributeValue <EntityReference>("gsc_intransitsiteid")
: null;
_organizationService.Update(inventory);
_tracingService.Trace("Inventory Updated");
}
//receivingHandler.CreateReceivingInventoryHistory(receivingTransaction, 1, 0, inTransitSite, Guid.Empty, inTransitSite, 1);
}
_tracingService.Trace("Created Receiving Inventory History...");
receivingTransaction["gsc_receivingstatus"] = new OptionSetValue(100000003);
_organizationService.Update(receivingTransaction);
_tracingService.Trace("Receving Status Updated");
_tracingService.Trace("Ended CreateUpdateInventoryRecord Method...");
return(receivingTransactionDetail);
}
