protected override void Execute(System.Activities.CodeActivityContext context)
{
var workflowContext = context.GetExtension <IWorkflowContext>();
var service = this.RetrieveOrganizationService(context);
QueryResult queryResult = ExecuteQueryForRecords(context);
Microsoft.Xrm.Sdk.Messages.RetrieveEntityRequest metadataRequest = new Microsoft.Xrm.Sdk.Messages.RetrieveEntityRequest()
{
LogicalName = workflowContext.PrimaryEntityName, EntityFilters = EntityFilters.Relationships
};
var metadataResponse = service.Execute(metadataRequest) as Microsoft.Xrm.Sdk.Messages.RetrieveEntityResponse;
var relationship = metadataResponse.EntityMetadata.ManyToManyRelationships.FirstOrDefault(m =>
m.SchemaName.Equals(RelationshipName.Get(context), StringComparison.InvariantCultureIgnoreCase) ||
m.IntersectEntityName.Equals(RelationshipName.Get(context), StringComparison.InvariantCultureIgnoreCase));
if (relationship == null)
{
throw new Exception($"Entity '{workflowContext.PrimaryEntityName}' does not have relationship with schema name or relationship entity name '{RelationshipName.Get(context)}'");
}
QueryExpression qe = new QueryExpression(relationship.IntersectEntityName);
qe.Criteria.AddCondition(relationship.Entity1IntersectAttribute, ConditionOperator.Equal, workflowContext.PrimaryEntityId);
qe.ColumnSet = new ColumnSet(relationship.Entity2IntersectAttribute);
var alreadyAssociated = service.RetrieveMultiple(qe).Entities.Select(e => (Guid)e[relationship.Entity2IntersectAttribute]);
var delta = queryResult.RecordIds.Except(alreadyAssociated).Select(id => new EntityReference(relationship.Entity2LogicalName, id)).ToList();
service.Associate(workflowContext.PrimaryEntityName, workflowContext.PrimaryEntityId, new Relationship(relationship.SchemaName), new EntityReferenceCollection(delta));
NumberOfRelationshipChanges.Set(context, delta.Count);
}
protected override void Execute(System.Activities.CodeActivityContext context)
{
var workflowContext = context.GetExtension <IWorkflowContext>();
var service = this.RetrieveOrganizationService(context);
DateTime utcDateTime = this.DateToEvaluate.Get(context);
if (utcDateTime.Kind != DateTimeKind.Utc)
{
utcDateTime = utcDateTime.ToUniversalTime();
}
TimeZoneSummary timeZone = StaticMethods.CalculateTimeZoneToUse(this.TimeZoneOption.Get(context), workflowContext, service);
LocalTimeFromUtcTimeRequest timeZoneChangeRequest = new LocalTimeFromUtcTimeRequest()
{
UtcTime = utcDateTime, TimeZoneCode = timeZone.MicrosoftIndex
};
LocalTimeFromUtcTimeResponse timeZoneResponse = service.Execute(timeZoneChangeRequest) as LocalTimeFromUtcTimeResponse;
DateTime adjustedDateTime = timeZoneResponse.LocalTime;
switch (adjustedDateTime.DayOfWeek)
{
case System.DayOfWeek.Sunday:
this.DayOfWeekPick.Set(context, new OptionSetValue(222540000));
break;
case System.DayOfWeek.Monday:
this.DayOfWeekPick.Set(context, new OptionSetValue(222540001));
break;
case System.DayOfWeek.Tuesday:
this.DayOfWeekPick.Set(context, new OptionSetValue(222540002));
break;
case System.DayOfWeek.Wednesday:
this.DayOfWeekPick.Set(context, new OptionSetValue(222540003));
break;
case System.DayOfWeek.Thursday:
this.DayOfWeekPick.Set(context, new OptionSetValue(222540004));
break;
case System.DayOfWeek.Friday:
this.DayOfWeekPick.Set(context, new OptionSetValue(222540005));
break;
case System.DayOfWeek.Saturday:
this.DayOfWeekPick.Set(context, new OptionSetValue(222540006));
break;
}
this.DayOfWeekName.Set(context, adjustedDateTime.DayOfWeek.ToString());
this.DayOfMonth.Set(context, adjustedDateTime.Day);
this.DayOfYear.Set(context, adjustedDateTime.DayOfYear);
this.HourOfDay023.Set(context, adjustedDateTime.Hour);
this.Minute.Set(context, adjustedDateTime.Minute);
this.MonthOfYearInt.Set(context, adjustedDateTime.Month);
this.MonthOfYearPick.Set(context, new OptionSetValue(222540000 + adjustedDateTime.Month - 1));
this.MonthOfYearName.Set(context, System.Globalization.CultureInfo.CurrentCulture.DateTimeFormat.GetMonthName(adjustedDateTime.Month));
this.Year.Set(context, adjustedDateTime.Year);
}
protected override void Execute(System.Activities.CodeActivityContext context)
{
var workflowContext = context.GetExtension <IWorkflowContext>();
var service = this.RetrieveOrganizationService(context);
QueryResult result = ExecuteQueryForRecords(context);
Entity workflow = service.Retrieve("workflow", this.Workflow.Get(context).Id, new Microsoft.Xrm.Sdk.Query.ColumnSet("primaryentity"));
if (workflow.GetAttributeValue <string>("primaryentity").ToLower() != result.EntityName)
{
throw new ArgumentException($"Workflow entity ({workflow.GetAttributeValue<string>("primaryentity")} does not match query entity ({result.EntityName})");
}
int numberStarted = 0;
foreach (Guid id in result.RecordIds)
{
try
{
ExecuteWorkflowRequest request = new ExecuteWorkflowRequest()
{
EntityId = id, WorkflowId = workflow.Id
};
ExecuteWorkflowResponse response = service.Execute(request) as ExecuteWorkflowResponse;
}
catch (Exception ex)
{
throw new Exception($"Error initiating workflow on record with ID = {id}; {ex.Message}");
}
numberStarted++;
}
this.NumberOfWorkflowsStarted.Set(context, numberStarted);
}
protected override void Execute(System.Activities.CodeActivityContext context)
{
var workflowContext = context.GetExtension <IWorkflowContext>();
var service = this.RetrieveOrganizationService(context);
Entity email = service.Retrieve("email", this.Email.Get(context).Id, new Microsoft.Xrm.Sdk.Query.ColumnSet("statuscode"));
if (email["statuscode"] == null || email.GetAttributeValue <OptionSetValue>("statuscode").Value != 1)
{
throw new ArgumentException("Email must be in Draft status.");
}
SendEmailRequest sendEmailrequest = new SendEmailRequest
{
EmailId = email.Id,
TrackingToken = "",
IssueSend = true
};
try
{
SendEmailResponse sendEmailresponse = (SendEmailResponse)service.Execute(sendEmailrequest);
}
catch (Exception ex)
{
throw new Exception($"Exception on SendEmailResponse - {ex.Message}");
}
}
protected override void Execute(System.Activities.CodeActivityContext context)
{
var workflowContext = context.GetExtension <IWorkflowContext>();
var service = this.RetrieveOrganizationService(context);
QueryResult result = ExecuteQueryForRecords(context);
if (!result.EntityName.Equals("systemuser", StringComparison.InvariantCultureIgnoreCase) &&
!result.EntityName.Equals("team", StringComparison.InvariantCultureIgnoreCase))
{
throw new ArgumentException("Query must return a User or Team record");
}
// Ensure the record has an owner field
RetrieveEntityRequest request = new Microsoft.Xrm.Sdk.Messages.RetrieveEntityRequest()
{
EntityFilters = Microsoft.Xrm.Sdk.Metadata.EntityFilters.Entity,
LogicalName = workflowContext.PrimaryEntityName
};
RetrieveEntityResponse metadataResponse = service.Execute(request) as RetrieveEntityResponse;
if (metadataResponse.EntityMetadata.OwnershipType == null || metadataResponse.EntityMetadata.OwnershipType.Value != OwnershipTypes.UserOwned)
{
throw new ArgumentException("This activity is only available for User owned records");
}
if (!result.RecordIds.Any())
{
return;
}
var workflowRecord = new EntityReference(workflowContext.PrimaryEntityName, workflowContext.PrimaryEntityId);
var assignee = new EntityReference(result.EntityName, result.RecordIds.FirstOrDefault());
AssignRequest assignRequest = new AssignRequest()
{
Assignee = assignee,
Target = workflowRecord
};
try
{
AssignResponse response = service.Execute(assignRequest) as AssignResponse;
if (assignee.LogicalName.Equals("team"))
{
this.NewOwner_Team.Set(context, assignee);
}
else
{
this.NewOwner_User.Set(context, assignee);
}
this.RecordReassigned.Set(context, true);
}
catch (Exception ex)
{
throw new Exception($"There was an error reassigning the record: {ex.Message}");
}
}
protected override void Execute(System.Activities.CodeActivityContext context)
{
var workflowContext = context.GetExtension <IWorkflowContext>();
var service = this.RetrieveOrganizationService(context);
string emailField = "to";
switch (this.EmailRecipientField.Get(context).Value)
{
case 222540001:
emailField = "cc";
break;
case 222540002:
emailField = "bcc";
break;
default:
break;
}
Entity email = service.Retrieve("email", this.Email.Get(context).Id, new Microsoft.Xrm.Sdk.Query.ColumnSet(emailField, "statuscode"));
if (email["statuscode"] == null || email.GetAttributeValue <OptionSetValue>("statuscode").Value != 1)
{
throw new ArgumentException("Email must be in Draft status.");
}
QueryResult result = ExecuteQueryForRecords(context);
int recipientsAdded = result.RecordIds.Count();
if (result.RecordIds.Any())
{
List <Entity> recipients = new List <Entity>();
if (email[emailField] != null && ((Microsoft.Xrm.Sdk.EntityCollection)email[emailField]).Entities != null && ((Microsoft.Xrm.Sdk.EntityCollection)email[emailField]).Entities.Any())
{
recipients.AddRange(((EntityCollection)email[emailField]).Entities.ToList());
}
foreach (Guid id in result.RecordIds)
{
if (!recipients.Any(r => ((EntityReference)(r["partyid"])).Id == id && ((EntityReference)(r["partyid"])).LogicalName == result.EntityName))
{
Entity party = new Entity("activityparty");
party["partyid"] = new EntityReference(result.EntityName, id);
recipients.Add(party);
recipientsAdded++;
}
}
email[emailField] = recipients.ToArray();
}
service.Update(email);
NumberOfRecipientsAdded.Set(context, recipientsAdded);
}
protected override void Execute(System.Activities.CodeActivityContext context)
{
var workflowContext = context.GetExtension <IWorkflowContext>();
var service = this.RetrieveOrganizationService(context);
this.ValidateColorCode(this.Table_BorderColor.Get(context), "Table - Border Color");
this.ValidateColorCode(this.Header_BackgroundColor.Get(context), "Header - Background Color");
this.ValidateColorCode(this.Header_FontColor.Get(context), "Header - Font Color");
this.ValidateColorCode(this.Row_BackgroundColor.Get(context), "Row - Background Color");
this.ValidateColorCode(this.Row_FontColor.Get(context), "Row - Font Color");
this.ValidateColorCode(this.AlternatingRow_BackgroundColor.Get(context), "Alternating Row - Background Color");
this.ValidateColorCode(this.AlternatingRow_FontColor.Get(context), "Alternating Row - Font Color");
DataTable table = this.BuildDataTable(context, workflowContext, service);
this.NumberOfFields.Set(context, table.Rows.Count);
this.BuildResultsAsHtml(table, context, service);
this.BuildResultsAsCsv(table, context);
}
protected override void Execute(System.Activities.CodeActivityContext context)
{
var workflowContext = context.GetExtension <IWorkflowContext>();
var service = this.RetrieveOrganizationService(context);
int day = this.Day.Get(context);
if (day <= 0 || day > 31)
{
throw new ArgumentOutOfRangeException("Day outside of valid range (1 - 31)");
}
int month = this.MonthOfYearInt.Get(context);
if (month < 1 || month > 12)
{
month = this.MonthOfYearPick.Get(context).Value - 222540000 + 1;
}
int year = this.Year.Get(context);
int hour = this.HourOfDay023.Get(context);
int minute = this.Minute.Get(context);
DateTime parsedDate = DateTime.MinValue;
try
{
parsedDate = new DateTime(year, month, day, hour, minute, 0, DateTimeKind.Unspecified);
}
catch (Exception ex)
{
throw new ArgumentException("Error parsing date: " + ex.Message);
}
TimeZoneSummary timeZone = StaticMethods.CalculateTimeZoneToUse(this.TimeZoneOption.Get(context), workflowContext, service);
UtcTimeFromLocalTimeRequest timeZoneChangeRequest = new UtcTimeFromLocalTimeRequest()
{
LocalTime = parsedDate, TimeZoneCode = timeZone.MicrosoftIndex
};
UtcTimeFromLocalTimeResponse timeZoneResponse = service.Execute(timeZoneChangeRequest) as UtcTimeFromLocalTimeResponse;
DateTime adjustedDateTime = timeZoneResponse.UtcTime;
this.ModifiedDate.Set(context, adjustedDateTime);
}
/// <summary>
/// Gets ITracingService extension from CodeActivityContext
/// </summary>
/// <param name="codeActivityContext"></param>
/// <returns></returns>
public static ITracingService GetTracingService(this CodeActivityContext codeActivityContext)
{
return(codeActivityContext.GetExtension <ITracingService>());
}
/// <summary>
/// Gets IOrganizationServiceFactory extension from CodeActivityContext
/// </summary>
/// <param name="codeActivityContext"></param>
/// <returns></returns>
public static IOrganizationServiceFactory GetOrganizationServiceFactory(this CodeActivityContext codeActivityContext)
{
return(codeActivityContext.GetExtension <IOrganizationServiceFactory>());
}
/// <summary>
/// Gets IWorkflowContext extension from CodeActivityContext
/// </summary>
/// <returns></returns>
public static IWorkflowContext GetWorkflowContext(this CodeActivityContext codeActivityContext)
{
return(codeActivityContext.GetExtension <IWorkflowContext>());
}
