protected override void Execute(CodeActivityContext executionContext)
{
#region "Load CRM Service from context"
Common objCommon = new Common(executionContext);
objCommon.tracingService.Trace("Load CRM Service from context --- OK");
#endregion
#region "Read Parameters"
String _FieldName = this.FieldName.Get(executionContext);
String _ParentRecordURL = this.ParentRecordURL.Get(executionContext);
if (_ParentRecordURL == null || _ParentRecordURL == "")
{
return;
}
string[] urlParts = _ParentRecordURL.Split("?".ToArray());
string[] urlParams = urlParts[1].Split("&".ToCharArray());
string ParentObjectTypeCode = urlParams[0].Replace("etc=", "");
string ParentId = urlParams[1].Replace("id=", "");
objCommon.tracingService.Trace("ParentObjectTypeCode=" + ParentObjectTypeCode + "--ParentId=" + ParentId);
#endregion
#region "CalculateRollupField Execution"
string ParentEntityName = objCommon.sGetEntityNameFromCode(ParentObjectTypeCode, objCommon.service);
CalculateRollupFieldRequest calculateRollup = new CalculateRollupFieldRequest();
calculateRollup.FieldName = _FieldName;
calculateRollup.Target = new EntityReference(ParentEntityName, new Guid(ParentId));
CalculateRollupFieldResponse resp = (CalculateRollupFieldResponse)objCommon.service.Execute(calculateRollup);
#endregion
}
private CalculateRollupFieldResponse HandleCalculateRollupField(OrganizationRequest orgRequest, EntityReference userRef)
{
var request = MakeRequest <CalculateRollupFieldRequest>(orgRequest);
var resp = new CalculateRollupFieldResponse();
resp.Results["Entity"] = dataMethods.CalculateRollUpField(request.Target, request.FieldName, userRef);
return(resp);
}
public static void CalculateRollup(IOrganizationService _service, string fieldName, EntityReference targetRef)
{
// Execute the Request
CalculateRollupFieldRequest req = new CalculateRollupFieldRequest()
{
FieldName = fieldName,
Target = targetRef
};
CalculateRollupFieldResponse resp = (CalculateRollupFieldResponse)_service.Execute(req);
}
public static void HandleConfigs(CrmServiceClient svc, string entityName, int TypeConfig, int TypeError)
{
List <Entity> configs = getQuery(svc,
new[] { "np_rollupupdateconfigid", "np_fields_for_update" }, TypeConfig, entityName);
foreach (var config in configs)
{
if (!config.Attributes.Contains("np_fields_for_update"))
{
continue;
}
try
{
QueryExpression query = new QueryExpression(entityName)
{
ColumnSet = new ColumnSet($"{entityName}id")
};
List <Entity> recordsOfEntity = getDataOfQuery(svc, query);
foreach (var record in recordsOfEntity)
{
foreach (string fieldName in config.Attributes["np_fields_for_update"].ToString().Split(','))
{
Console.WriteLine($"Try to update record with ID = {record.Id}");
try
{
CalculateRollupFieldRequest crfr = new CalculateRollupFieldRequest
{
Target = new EntityReference(entityName, record.Id),
FieldName = fieldName
};
CalculateRollupFieldResponse
response = (CalculateRollupFieldResponse)svc.Execute(crfr);
}
catch (Exception ex)
{
Entity err = new Entity("np_rollupupdateconfig");
err["np_recordtype"] = new OptionSetValue(TypeError);
err["np_entitywithrollups"] = entityName;
err["np_recordid"] = record.Id.ToString();
svc.Create(err);
Console.WriteLine($"Can`t update record with ID = {record.Id}.Error was created!");
}
}
}
}
catch (Exception ex)
{
Console.WriteLine($"Erorr ocurred when tried to retrieve data from Entity with name {entityName}");
Console.WriteLine(ex.Message);
}
}
}
/// <summary>
/// Execute
/// </summary>
/// <param name="serviceProvider"></param>
public void Execute(IServiceProvider serviceProvider)
{
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
// Get execution context, tracing, and Org Service factory from the svc provider then use the factory to generate the Organization Service.
IPluginExecutionContext context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));
IOrganizationServiceFactory ServiceFactory = (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory));
IOrganizationService service = ServiceFactory.CreateOrganizationService(null);
ITracingService tracingService = (ITracingService)serviceProvider.GetService(typeof(ITracingService));
//create the service context
OrganizationServiceContext serviceContext = new OrganizationServiceContext(service);
//log
tracingService.Trace("Start logging");
tracingService.Trace("Context Message: " + context.MessageName.ToLower());
try
{
var detailclaimid = Guid.Empty;
var isdeletecontext = false;
if (context.MessageName.ToLower() == Constants.CONTEXT_CREATE || context.MessageName.ToLower() == Constants.CONTEXT_UPDATE)
{
tracingService.Trace("In Update/Create Context");
if (context.PrimaryEntityName == Constants.FINDING_ENTITY_NAME)
{
if (context.PostEntityImages[Constants.POSTIMAGE_ALIAS_NAME] == null)
{
throw new InvalidPluginExecutionException("The plugin needs a post image registered with alias '" + Constants.POSTIMAGE_ALIAS_NAME + "'.");
}
detailclaimid = ((EntityReference)(context.PostEntityImages[Constants.POSTIMAGE_ALIAS_NAME][Constants.FINDING_DETAILCLAIMID_FIELD])).Id;
}
else if (context.PrimaryEntityName == Constants.RECOVERY_ENTITY_NAME)
{
if (context.PostEntityImages[Constants.POSTIMAGE_ALIAS_NAME] == null)
{
throw new InvalidPluginExecutionException("The plugin needs a post image registered with alias '" + Constants.POSTIMAGE_ALIAS_NAME + "'.");
}
detailclaimid = ((EntityReference)(context.PostEntityImages[Constants.POSTIMAGE_ALIAS_NAME][Constants.RECOVERY_DETAILCLAIM_FIELD])).Id;
}
}
else if (context.InputParameters["Target"] is EntityReference)
{
tracingService.Trace("In Delete Context");
if (context.PreEntityImages[Constants.PREIMAGE_ALIAS_NAME] == null)
{
throw new InvalidPluginExecutionException("The plugin needs a pre image registered with alias '" + Constants.PREIMAGE_ALIAS_NAME + "'.");
}
if (context.PreEntityImages[Constants.PREIMAGE_ALIAS_NAME].Contains(Constants.FINDING_DETAILCLAIMID_FIELD))
{
detailclaimid = ((EntityReference)context.PreEntityImages[Constants.PREIMAGE_ALIAS_NAME][Constants.FINDING_DETAILCLAIMID_FIELD]).Id;
}
else if (context.PreEntityImages[Constants.PREIMAGE_ALIAS_NAME].Contains(Constants.RECOVERY_DETAILCLAIM_FIELD))
{
detailclaimid = ((EntityReference)context.PreEntityImages[Constants.PREIMAGE_ALIAS_NAME][Constants.RECOVERY_DETAILCLAIM_FIELD]).Id;
}
tracingService.Trace("Detailclaimid initialized");
isdeletecontext = true;
}
tracingService.Trace("DetailclaimId :" + detailclaimid.ToString());
if (detailclaimid == Guid.Empty)
{
tracingService.Trace("DetailClaimId cannot be initialized");
return;
}
#region detail claim totals
//Manually calculate rollup fields on detail claim entity record
//Request
tracingService.Trace("Detail Claim - Calculate Rollup Fields");
CalculateRollupFieldRequest findingtotalscorrectquantityrequest = new CalculateRollupFieldRequest {
Target = new EntityReference(Constants.DETAILCLAIM_ENTITY_NAME, detailclaimid), FieldName = Constants.DETAILCLAIM_TOTALCORRECTQUANTITY_FIELD
};
CalculateRollupFieldRequest findingtotalscorrectamountrequest = new CalculateRollupFieldRequest {
Target = new EntityReference(Constants.DETAILCLAIM_ENTITY_NAME, detailclaimid), FieldName = Constants.DETAILCLAIM_TOTALCORRECTAMOUNT_FIELD
};
CalculateRollupFieldRequest findinttotalsexceptionamountrequest = new CalculateRollupFieldRequest {
Target = new EntityReference(Constants.DETAILCLAIM_ENTITY_NAME, detailclaimid), FieldName = Constants.DETAILCLAIM_TOTALEXCEPTIONAMOUNT_FIELD
};
//Response
CalculateRollupFieldResponse findingtotalscorrectquantityresponse = (CalculateRollupFieldResponse)service.Execute(findingtotalscorrectquantityrequest);
CalculateRollupFieldResponse findingtotalscorrectamountresponse = (CalculateRollupFieldResponse)service.Execute(findingtotalscorrectamountrequest);
CalculateRollupFieldResponse findinttotalsexceptionamountresponse = (CalculateRollupFieldResponse)service.Execute(findinttotalsexceptionamountrequest);
tracingService.Trace("Detail Claim - Calculation Complete");
tracingService.Trace("Compute Recovery Amount");
CrmHelper crmHelper = new CrmHelper();
crmHelper.CalculateRecovery(serviceContext, service, tracingService, detailclaimid);
#endregion
#region header claim totals
//Rollup totals to header claim entity
var detailclaim = service.Retrieve(Constants.DETAILCLAIM_ENTITY_NAME, detailclaimid, new ColumnSet(Constants.DETAILCLAIM_SAKCLAIMID_FIELD));
if (!detailclaim.Contains(Constants.DETAILCLAIM_SAKCLAIMID_FIELD))
{
tracingService.Trace("Detail Claim - Id " + detailclaimid + " doesn't have associated header claim. Exiting code!");
return;
}
tracingService.Trace("Detail Claim - Header Claim Exists.");
var claimid = ((EntityReference)detailclaim[Constants.DETAILCLAIM_SAKCLAIMID_FIELD]).Id;
var findingtotalcorrectquantity = GetTotals(service, tracingService, Constants.DETAILCLAIM_ENTITY_NAME, Constants.DETAILCLAIM_TOTALCORRECTQUANTITY_FIELD, Constants.DETAILCLAIM_SAKCLAIMID_FIELD, claimid, isdeletecontext ? Constants.DETAILCLAIM_ID_FIELD : "", isdeletecontext ? detailclaimid.ToString() : "", false);
var findingtotalcorrectamount = GetTotals(service, tracingService, Constants.DETAILCLAIM_ENTITY_NAME, Constants.DETAILCLAIM_TOTALCORRECTAMOUNT_FIELD, Constants.DETAILCLAIM_SAKCLAIMID_FIELD, claimid, isdeletecontext ? Constants.DETAILCLAIM_ID_FIELD : "", isdeletecontext ? detailclaimid.ToString() : "");
var findingtotalexceptionamount = GetTotals(service, tracingService, Constants.DETAILCLAIM_ENTITY_NAME, Constants.DETAILCLAIM_TOTALEXCEPTIONAMOUNT_FIELD, Constants.DETAILCLAIM_SAKCLAIMID_FIELD, claimid, isdeletecontext ? Constants.DETAILCLAIM_ID_FIELD : "", isdeletecontext ? detailclaimid.ToString() : "");
var recoverytotalrecoveredamount = GetTotals(service, tracingService, Constants.DETAILCLAIM_ENTITY_NAME, Constants.DETAILCLAIM_TOTALRECOVEREDAMOUNT_FIELD, Constants.DETAILCLAIM_SAKCLAIMID_FIELD, claimid);
var recoverytotalremainingrecoveryamount = GetTotals(service, tracingService, Constants.DETAILCLAIM_ENTITY_NAME, Constants.DETAILCLAIM_TOTALREMAININGRECOVERYAMOUNT_FIELD, Constants.DETAILCLAIM_SAKCLAIMID_FIELD, claimid);
var recoverytotalidentifiedrecoveryamount = GetTotals(service, tracingService, Constants.DETAILCLAIM_ENTITY_NAME, Constants.DETAILCLAIM_TOTALIDENTIFIEDRECOVERYAMOUNT_FIELD, Constants.DETAILCLAIM_SAKCLAIMID_FIELD, claimid);
tracingService.Trace("Totals Completed");
//throw new InvalidPluginExecutionException("Debugging");
var headerclaim = new Entity(Constants.CLAIM_ENTITY_NAME);
headerclaim.Id = claimid;
//findings
headerclaim[Constants.CLAIM_TOTALCORRECTQUANTITY_FIELD] = findingtotalcorrectquantity;
headerclaim[Constants.CLAIM_TOTALCORRECTAMOUNT_FIELD] = new Money(findingtotalcorrectamount);
headerclaim[Constants.CLAIM_TOTALEXCEPTIONAMOUNT_FIELD] = new Money(findingtotalexceptionamount);
//recoveries
headerclaim[Constants.CLAIM_TOTALRECOVEREDAMOUNT_FIELD] = new Money(recoverytotalrecoveredamount);
headerclaim[Constants.CLAIM_TOTALREMAININGRECOVERYAMOUNT_FIELD] = new Money(recoverytotalremainingrecoveryamount);
headerclaim[Constants.CLAIM_TOTALIDENTIFIEDRECOVERYAMOUNT_FIELD] = new Money(recoverytotalidentifiedrecoveryamount);
service.Update(headerclaim);
tracingService.Trace("Claim - Header claim totals updated.");
#endregion
#region case provider
var caseproviderid = Guid.Empty;
var claim = service.Retrieve(Constants.CLAIM_ENTITY_NAME, claimid, new ColumnSet(Constants.CLAIM_CASEPROVIDERID_FIELD));
if (!claim.Contains(Constants.CLAIM_CASEPROVIDERID_FIELD))
{
tracingService.Trace("Claim - Id " + claimid + " doesn't have associated case provider. Exiting code!");
return;
}
else
{
caseproviderid = ((EntityReference)claim[Constants.CLAIM_CASEPROVIDERID_FIELD]).Id;
}
tracingService.Trace("Case Provider - Recovery Amount Calculation");
CalculateRollupFieldRequest totalidentifiedrecoveryamount = new CalculateRollupFieldRequest {
Target = new EntityReference(Constants.CASEPROVIDER_ENTITY_NAME, caseproviderid), FieldName = Constants.CASEPROVIDER_TOTALIDENTIFIEDRECOVERYAMOUNT_FIELD
};
CalculateRollupFieldRequest totalrecoveredamount = new CalculateRollupFieldRequest {
Target = new EntityReference(Constants.CASEPROVIDER_ENTITY_NAME, caseproviderid), FieldName = Constants.CASEPROVIDER_TOTALRECOVEREDAMOUNT_FIELD
};
CalculateRollupFieldRequest totalremainingrecoveryamount = new CalculateRollupFieldRequest {
Target = new EntityReference(Constants.CASEPROVIDER_ENTITY_NAME, caseproviderid), FieldName = Constants.CASEPROVIDER_TOTALREMAININGRECOVERYAMOUNT_FIELD
};
////Response
CalculateRollupFieldResponse totalidentifiedrecoveryamountresponse = (CalculateRollupFieldResponse)service.Execute(totalidentifiedrecoveryamount);
CalculateRollupFieldResponse totalrecoveredamountresponse = (CalculateRollupFieldResponse)service.Execute(totalrecoveredamount);
CalculateRollupFieldResponse totalremainingrecoveryamountresponse = (CalculateRollupFieldResponse)service.Execute(totalremainingrecoveryamount);
tracingService.Trace("Case Provider - Recovery Amount Calculation Complete");
#endregion
#region case
var caseid = Guid.Empty;
var caseprovider = service.Retrieve(Constants.CASEPROVIDER_ENTITY_NAME, caseproviderid, new ColumnSet(true));
if (!caseprovider.Contains(Constants.CASEPROVIDER_CASEID_FIELD))
{
tracingService.Trace("CaseProvider with Id " + caseproviderid + " doesn't have associated case. Exiting code!");
return;
}
else
{
caseid = ((EntityReference)caseprovider[Constants.CASEPROVIDER_CASEID_FIELD]).Id;
}
tracingService.Trace("Calculate case total recovery totals");
var casetotalidentifiedrecoveryamount = GetTotals(service, tracingService, Constants.CASEPROVIDER_ENTITY_NAME, Constants.CASEPROVIDER_TOTALIDENTIFIEDRECOVERYAMOUNT_FIELD, Constants.CASEPROVIDER_CASEID_FIELD, caseid);
var casetotalrecoveredamount = GetTotals(service, tracingService, Constants.CASEPROVIDER_ENTITY_NAME, Constants.CASEPROVIDER_TOTALRECOVEREDAMOUNT_FIELD, Constants.CASEPROVIDER_CASEID_FIELD, caseid);
var casetotalremainingrecoveryamount = GetTotals(service, tracingService, Constants.CASEPROVIDER_ENTITY_NAME, Constants.CASEPROVIDER_TOTALREMAININGRECOVERYAMOUNT_FIELD, Constants.CASEPROVIDER_CASEID_FIELD, caseid);
tracingService.Trace("Case total recoveries calculated");
//update case
tracingService.Trace("Update Case");
var caseentity = new Entity(Constants.CASE_ENTITY_NAME);
caseentity.Id = caseid;
caseentity[Constants.CASE_TOTALIDENTIFIEDRECOVERYAMOUNT_FIELD] = new Money(casetotalidentifiedrecoveryamount);
caseentity[Constants.CASE_TOTALRECOVEREDAMOUNT_FIELD] = new Money(casetotalrecoveredamount);
caseentity[Constants.CASE_TOTALREMAININGRECOVERYAMOUNT_FIELD] = new Money(casetotalremainingrecoveryamount);
service.Update(caseentity);
tracingService.Trace("Case Updated");
#endregion
}
catch (InvalidPluginExecutionException ex)
{
tracingService.Trace("Error in pluing " + PLUGIN_NAME + ". " + ex.Message);
throw;
}
}
protected override void Execute(CodeActivityContext activityContext)
{
//Create the tracing service.
ITracingService tracingService = activityContext.GetExtension <ITracingService>();
//Create the context.
IWorkflowContext workflowContext = activityContext.GetExtension <IWorkflowContext>();
IOrganizationServiceFactory serviceFactory = activityContext.GetExtension <IOrganizationServiceFactory>();
IOrganizationService service = serviceFactory.CreateOrganizationService(workflowContext.UserId);
//Check the InArgument value.
if (this.Arg_WO != null)
{
//Get the Work Order Record.
Entity workOrder = service.Retrieve("msdyn_workorder", this.Arg_WO.Get <EntityReference>(activityContext).Id, new ColumnSet(true));
//Retrieve the standards collection for this work order.
EntityCollection standards = getWorkOrderStandards(service, workOrder.Id);
//Retrieve the domains collection for this work order.
EntityCollection domains = getWorkOrderDomains(service, workOrder.Id);
//Retieve the elements collection for this work order.
EntityCollection elements = getWorkOrderElements(service, workOrder.Id);
#region Domain Calculation
if (domains != null)
{
//Retrieve each domain and update it.
foreach (Entity domain in domains.Entities)
{
Entity domainRecord = service.Retrieve("msdyn_workorderservice", domain.Id, new ColumnSet(true));
CalculateRollupFieldRequest totalApplicableElementRequest =
new CalculateRollupFieldRequest {
Target = new EntityReference("msdyn_workorderservice", domainRecord.Id), FieldName = "net_totalnumberofapplicableelements"
};
CalculateRollupFieldResponse totalApplicableElementResponse = (CalculateRollupFieldResponse)service.Execute(totalApplicableElementRequest);
domainRecord = totalApplicableElementResponse.Entity;
//service.Update(workOrder);
CalculateRollupFieldRequest SumOfJudgmentRequest =
new CalculateRollupFieldRequest {
Target = new EntityReference("msdyn_workorderservice", domainRecord.Id), FieldName = "net_sumofjudgment"
};
CalculateRollupFieldResponse sumOfJudgmentResponse = (CalculateRollupFieldResponse)service.Execute(SumOfJudgmentRequest);
domainRecord = sumOfJudgmentResponse.Entity;
service.Update(domainRecord);
Entity domainUpdated = service.Retrieve("msdyn_workorderservice", domainRecord.Id, new ColumnSet(true));
int totalApplicableELement = domainUpdated.GetAttributeValue <int>("net_totalnumberofapplicableelements");
int sumOfJudgement = domainUpdated.GetAttributeValue <int>("net_sumofjudgment");
int AgreePercentage = 0;
if (totalApplicableELement != 0)
{
AgreePercentage = sumOfJudgement * 100 / (totalApplicableELement * 2);
}
else
{
AgreePercentage = 0;
}
domainUpdated["net_agreepercentage"] = AgreePercentage;
service.Update(domainUpdated);
}
}
#endregion
#region Standard Calculation
if (standards != null)
{
//Retrieve the elements in each standard
foreach (Entity standard in standards.Entities)
{
//define the numebr of applicable element.
int totalNumberofApplicableElement = 0;
//define the sum of judgment.
int sumOfJudgment = 0;
//define the weight.
int sumOfWeight = 0;
//define the Overall Judgment Percentage
Decimal overallJudgmentPercentage = 0;
//define the weighted score.
Decimal weightedScore = 0;
//define the weighted score percentage.
Decimal weightedScorePercentage = 0;
//fetch all elements in the standard
EntityCollection elementStandards = getStandardElements(service, standard.Id);
foreach (Entity element in elementStandards.Entities)
{
//Get the compliance status
OptionSetValue complianceStatus = element.GetAttributeValue <OptionSetValue>("net_compliantcoordinator");
if (complianceStatus != null)
{
int elementStatus = complianceStatus.Value;
//if status != N/A
if (elementStatus != 3)
{
//increment the total number of applicable element.
totalNumberofApplicableElement = totalNumberofApplicableElement + 1;
}
}
int elementJudgment = element.GetAttributeValue <int>("net_inspectionjudgement");
//add the element judgment to the sum of judgment.
sumOfJudgment = sumOfJudgment + elementJudgment;
//get the weight.
int weight = element.GetAttributeValue <int>("net_weight");
//add the weight to the sumofweight.
sumOfWeight = sumOfWeight + weight;
weightedScore = weightedScore + (elementJudgment * weight);
}
if (totalNumberofApplicableElement != 0)
{
overallJudgmentPercentage = (Decimal)(sumOfJudgment) * (Decimal)100 / (Decimal)(2 * totalNumberofApplicableElement);
}
else
{
overallJudgmentPercentage = 0;
}
if (sumOfWeight != 0)
{
weightedScore = weightedScore / sumOfWeight;
}
else
{
weightedScore = 0;
}
weightedScorePercentage = weightedScore / 2 * 100;
standard["net_totalofapplicableelement"] = totalNumberofApplicableElement;
standard["net_sumofjudgment"] = sumOfJudgment;
standard["net_compliancepercentage"] = overallJudgmentPercentage;
standard["net_weightedscore"] = weightedScore;
standard["net_weightedscorepercentage"] = weightedScorePercentage;
service.Update(standard);
}
}
#endregion
#region Update the Rollup Fields
CalculateRollupFieldRequest rollupRequest =
new CalculateRollupFieldRequest {
Target = new EntityReference("msdyn_workorder", workOrder.Id), FieldName = "net_totalnumberofapplicableelements"
};
CalculateRollupFieldResponse response = (CalculateRollupFieldResponse)service.Execute(rollupRequest);
workOrder = response.Entity;
//service.Update(workOrder);
CalculateRollupFieldRequest rollupRequestSumOfJudgment =
new CalculateRollupFieldRequest {
Target = new EntityReference("msdyn_workorder", workOrder.Id), FieldName = "net_sumofjudgment"
};
CalculateRollupFieldResponse responseSumOfJudgment = (CalculateRollupFieldResponse)service.Execute(rollupRequestSumOfJudgment);
workOrder = responseSumOfJudgment.Entity;
service.Update(workOrder);
#endregion
#region Work Order Calculation
Entity updatedWorkOrder = service.Retrieve("msdyn_workorder", workOrder.Id, new ColumnSet(true));
int totalOfApplicableElements = updatedWorkOrder.GetAttributeValue <int>("net_totalnumberofapplicableelements");
int workOrderSumOfJudgment = updatedWorkOrder.GetAttributeValue <int>("net_sumofjudgment");
//int maxPossibleScore = workOrder.GetAttributeValue<int>("net_maxpossiblescore");
int maxPossibleScore = totalOfApplicableElements * 2;
Decimal overallCompliancePercentage = 0;
if (maxPossibleScore != 0)
{
overallCompliancePercentage = (Decimal)((Decimal)workOrderSumOfJudgment * 100 / (Decimal)maxPossibleScore);
}
else
{
overallCompliancePercentage = 0;
}
//define the weighted score.
Decimal workOrderWeightedScore = 0;
//define the weight.
int workOrderSumOfWeight = 0;
if (elements != null)
{
string elementsID = "";
Decimal RiskLevelPercentage = 0;
foreach (Entity element in elements.Entities)
{
elementsID = (elementsID + "<value>" + element.Id + "</value>");
int elementJudgment = element.GetAttributeValue <int>("net_inspectionjudgement");
//get the weight.
int weight = element.GetAttributeValue <int>("net_weight");
//add the weight to the sumofweight.
workOrderSumOfWeight = workOrderSumOfWeight + weight;
workOrderWeightedScore = workOrderWeightedScore + (elementJudgment * weight);
}
if (workOrderSumOfWeight != 0)
{
workOrderWeightedScore = workOrderWeightedScore / workOrderSumOfWeight;
}
else
{
workOrderWeightedScore = 0;
}
//retrieve the number of critical element definition.
//EntityCollection criticalElementDefinition = getCriticalElementsDefinitionByElementInstance(service, elementsID);
//int numberOfCriticalElementsDefinition = criticalElementDefinition.Entities.Count;
string fetch = $@"<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='true'>
<entity name='net_element'>
<attribute name='net_elementid' />
<attribute name='net_name' />
<attribute name='createdon' />
<order attribute='net_name' descending='false' />
<filter type='and'>
<condition attribute='net_critical' operator='eq' value='1' />
</filter>
<link-entity name='msdyn_workorderservicetask' from='net_element' to='net_elementid' alias='ab'>
<filter type='and'>
<condition attribute='msdyn_workorderservicetaskid' operator='in'>"
+ elementsID +
"</condition>" +
"</filter>" +
"</link-entity>" +
"</entity>" +
"</fetch>";
EntityCollection criticalElementsDefinition = service.RetrieveMultiple(new FetchExpression(fetch));
int numberOfCriticalElementsDefinition = criticalElementsDefinition.Entities.Count;
//Retrieve the number of critical elements.
int numberOfCriticalElements = getWorkOrderCriticalElements(service, workOrder.Id).Entities.Count;
if (numberOfCriticalElementsDefinition == 0)
{
RiskLevelPercentage = 0;
}
else
{
RiskLevelPercentage = (Decimal)numberOfCriticalElements * (Decimal)100 / (Decimal)numberOfCriticalElementsDefinition;
}
//update the work order.
updatedWorkOrder["net_overallcompliance"] = overallCompliancePercentage;
updatedWorkOrder["net_weightedscore"] = workOrderWeightedScore;
updatedWorkOrder["net_numberofcriticalinspectionelements"] = numberOfCriticalElements;
updatedWorkOrder["net_numberofcriticalelementdefinition"] = numberOfCriticalElementsDefinition;
updatedWorkOrder["net_riskslevelpercentage"] = RiskLevelPercentage;
service.Update(updatedWorkOrder);
}
#endregion
}
}
internal override OrganizationResponse Execute(OrganizationRequest orgRequest, EntityReference userRef)
{
var request = MakeRequest <CalculateRollupFieldRequest>(orgRequest);
var dbEntity = db.GetEntity(request.Target);
var metadata = this.metadata.EntityMetadata.GetMetadata(dbEntity.LogicalName);
var field = metadata.Attributes.FirstOrDefault(a => a.LogicalName == request.FieldName);
if (field == null)
{
throw new FaultException($"Couldn't find the field '{request.FieldName}' on the entity '{dbEntity.LogicalName}'");
}
else
{
string definition = (field as BooleanAttributeMetadata)?.FormulaDefinition;
if ((field as BooleanAttributeMetadata)?.SourceType == 2)
{
definition = (field as BooleanAttributeMetadata).FormulaDefinition;
}
else if ((field as DateTimeAttributeMetadata)?.SourceType == 2)
{
definition = (field as DateTimeAttributeMetadata).FormulaDefinition;
}
else if ((field as DecimalAttributeMetadata)?.SourceType == 2)
{
definition = (field as DecimalAttributeMetadata).FormulaDefinition;
}
else if ((field as IntegerAttributeMetadata)?.SourceType == 2)
{
definition = (field as IntegerAttributeMetadata).FormulaDefinition;
}
else if ((field as MoneyAttributeMetadata)?.SourceType == 2)
{
definition = (field as MoneyAttributeMetadata).FormulaDefinition;
}
else if ((field as PicklistAttributeMetadata)?.SourceType == 2)
{
definition = (field as PicklistAttributeMetadata).FormulaDefinition;
}
else if ((field as StringAttributeMetadata)?.SourceType == 2)
{
definition = (field as StringAttributeMetadata).FormulaDefinition;
}
if (definition == null)
{
throw new FaultException($"Field '{request.FieldName}' on entity '{dbEntity.LogicalName}' is not a rollup field");
}
else
{
var tree = WorkflowConstructor.ParseRollUp(definition);
var factory = core.ServiceFactory;
var resultTree = tree.Execute(dbEntity, core.TimeOffset, core.GetWorkflowService(), factory, factory.GetService(typeof(ITracingService)) as ITracingService);
var resultLocaltion = ((resultTree.StartActivity as RollUp).Aggregation[1] as Aggregate).VariableName;
var result = resultTree.Variables[resultLocaltion];
if (result != null)
{
dbEntity[request.FieldName] = result;
}
}
}
Utility.HandleCurrencies(this.metadata, db, dbEntity);
db.Update(dbEntity);
var resp = new CalculateRollupFieldResponse();
resp.Results["Entity"] = db.GetEntity(request.Target);
return(resp);
}
