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);

            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);
        }
        protected DataTable BuildDataTable(CodeActivityContext context, IWorkflowContext workflowContext, IOrganizationService service)
        {
            TimeZoneSummary timeZone = StaticMethods.CalculateTimeZoneToUse(this.TimeZoneOption.Get(context), workflowContext, service);

            DataTable table = new DataTable()
            {
                TableName = workflowContext.PrimaryEntityName
            };

            table.Columns.AddRange(new DataColumn[] { new DataColumn("Date"), new DataColumn("User"), new DataColumn("Attribute"), new DataColumn("Old Value"), new DataColumn("New Value") });
            DateTime oldestUpdate = DateTime.MinValue;

            if (this.Units != null && this.Number != null && this.Number.Get <int>(context) != 0)
            {
                OptionSetValue value = this.Units.Get <OptionSetValue>(context);
                if (value != null)
                {
                    switch (value.Value)
                    {
                    case 222540000:
                        oldestUpdate = DateTime.Now.AddYears(this.Number.Get <int>(context) * -1);
                        break;

                    case 222540001:
                        oldestUpdate = DateTime.Now.AddMonths(this.Number.Get <int>(context) * -1);
                        break;

                    case 222540002:
                        oldestUpdate = DateTime.Now.AddDays(this.Number.Get <int>(context) * -7);
                        break;

                    case 222540003:
                        oldestUpdate = DateTime.Now.AddDays(this.Number.Get <int>(context) * -1);
                        break;

                    case 222540004:
                        oldestUpdate = DateTime.Now.AddHours(this.Number.Get <int>(context) * -1);
                        break;

                    default:
                        oldestUpdate = DateTime.Now.AddMinutes(this.Number.Get <int>(context) * -1);
                        break;
                    }
                }
            }

            RetrieveRecordChangeHistoryRequest request = new RetrieveRecordChangeHistoryRequest()
            {
                Target     = new EntityReference(workflowContext.PrimaryEntityName, workflowContext.PrimaryEntityId),
                PagingInfo = new PagingInfo()
                {
                    Count = 100, PageNumber = 1
                }
            };
            RetrieveRecordChangeHistoryResponse response = service.Execute(request) as RetrieveRecordChangeHistoryResponse;
            var detailsToInclude = response.AuditDetailCollection.AuditDetails
                                   .Where(ad => ad is AttributeAuditDetail && ad.AuditRecord.Contains("createdon") && ((DateTime)ad.AuditRecord["createdon"]) > oldestUpdate)
                                   .OrderByDescending(ad => ((DateTime)ad.AuditRecord["createdon"]))
                                   .ToList();

            if (detailsToInclude.Any())
            {
                Microsoft.Xrm.Sdk.Messages.RetrieveEntityRequest retrieveEntityRequest = new Microsoft.Xrm.Sdk.Messages.RetrieveEntityRequest()
                {
                    EntityFilters = EntityFilters.Attributes,
                    LogicalName   = workflowContext.PrimaryEntityName
                };
                Microsoft.Xrm.Sdk.Messages.RetrieveEntityResponse retrieveEntityResponse = service.Execute(retrieveEntityRequest) as Microsoft.Xrm.Sdk.Messages.RetrieveEntityResponse;
                EntityMetadata metadata = retrieveEntityResponse.EntityMetadata;

                foreach (var detail in detailsToInclude.Select(d => d as AttributeAuditDetail).Where(d => d.NewValue != null && d.OldValue != null))
                {
                    DateTime dateToModify = (DateTime)detail.AuditRecord["createdon"];
                    if (dateToModify.Kind != DateTimeKind.Utc)
                    {
                        dateToModify = dateToModify.ToUniversalTime();
                    }


                    LocalTimeFromUtcTimeRequest timeZoneChangeRequest = new LocalTimeFromUtcTimeRequest()
                    {
                        UtcTime = dateToModify, TimeZoneCode = timeZone.MicrosoftIndex
                    };
                    LocalTimeFromUtcTimeResponse timeZoneResponse = service.Execute(timeZoneChangeRequest) as LocalTimeFromUtcTimeResponse;
                    DateTime timeZoneSpecificDateTime             = timeZoneResponse.LocalTime;

                    var details = detail.NewValue.Attributes.Keys.Union(detail.OldValue.Attributes.Keys)
                                  .Distinct()
                                  .Select(a =>
                                          new {
                        AttributeName = a,
                        DisplayName   = GetDisplayLabel(metadata, a)
                    })
                                  .OrderBy(a => a.DisplayName);

                    foreach (var item in details)
                    {
                        DataRow newRow = table.NewRow();
                        newRow["User"]      = GetDisplayValue(detail.AuditRecord, "userid");
                        newRow["Date"]      = timeZoneSpecificDateTime.ToString("MM/dd/yyyy h:mm tt");
                        newRow["Attribute"] = item.DisplayName;
                        newRow["Old Value"] = GetDisplayValue(detail.OldValue, item.AttributeName);
                        newRow["New Value"] = GetDisplayValue(detail.NewValue, item.AttributeName);
                        table.Rows.Add(newRow);
                    }
                }
            }
            return(table);
        }
Пример #4
0
        protected override void Execute(CodeActivityContext context)
        {
            var workflowContext = context.GetExtension <IWorkflowContext>();
            var service         = this.RetrieveOrganizationService(context);

            List <OptionSetValue> values = new List <OptionSetValue>()
            {
                this.Part1.Get <OptionSetValue>(context),
                this.Part2.Get <OptionSetValue>(context),
                this.Part3.Get <OptionSetValue>(context),
                this.Part4.Get <OptionSetValue>(context),
                this.Part5.Get <OptionSetValue>(context),
                this.Part6.Get <OptionSetValue>(context),
                this.Part7.Get <OptionSetValue>(context),
                this.Part8.Get <OptionSetValue>(context),
                this.Part9.Get <OptionSetValue>(context),
                this.Part10.Get <OptionSetValue>(context),
                this.Part11.Get <OptionSetValue>(context),
                this.Part12.Get <OptionSetValue>(context),
                this.Part13.Get <OptionSetValue>(context),
                this.Part14.Get <OptionSetValue>(context),
                this.Part15.Get <OptionSetValue>(context),
                this.Part16.Get <OptionSetValue>(context),
                this.Part17.Get <OptionSetValue>(context),
                this.Part18.Get <OptionSetValue>(context),
                this.Part19.Get <OptionSetValue>(context),
                this.Part20.Get <OptionSetValue>(context)
            };

            values.RemoveAll(osv => osv == null || osv.Value == 222540025);

            TimeZoneSummary timeZone     = StaticMethods.CalculateTimeZoneToUse(this.TimeZoneOption.Get(context), workflowContext, service);
            DateTime        dateToModify = this.DateToModify.Get(context);

            if (dateToModify.Kind != DateTimeKind.Utc)
            {
                dateToModify = dateToModify.ToUniversalTime();
            }


            LocalTimeFromUtcTimeRequest timeZoneChangeRequest = new LocalTimeFromUtcTimeRequest()
            {
                UtcTime = dateToModify, TimeZoneCode = timeZone.MicrosoftIndex
            };
            LocalTimeFromUtcTimeResponse timeZoneResponse = service.Execute(timeZoneChangeRequest) as LocalTimeFromUtcTimeResponse;
            DateTime timeZoneSpecificDateTime             = timeZoneResponse.LocalTime;

            StringBuilder sb = new StringBuilder();

            foreach (OptionSetValue osv in values)
            {
                try
                {
                    switch (osv.Value)
                    {
                    case 222540000:
                        sb.Append(timeZoneSpecificDateTime.ToString("%h"));
                        break;

                    case 222540001:
                        sb.Append(timeZoneSpecificDateTime.ToString("hh"));
                        break;

                    case 222540002:
                        sb.Append(timeZoneSpecificDateTime.ToString("%H"));
                        break;

                    case 222540003:
                        sb.Append(timeZoneSpecificDateTime.ToString("HH"));
                        break;

                    case 222540004:
                        sb.Append(timeZoneSpecificDateTime.ToString("%m"));
                        break;

                    case 222540005:
                        sb.Append(timeZoneSpecificDateTime.ToString("mm"));
                        break;

                    case 222540006:
                        sb.Append(timeZoneSpecificDateTime.ToString("%d"));
                        break;

                    case 222540007:
                        sb.Append(timeZoneSpecificDateTime.ToString("dd"));
                        break;

                    case 222540008:
                        sb.Append(timeZoneSpecificDateTime.ToString("ddd"));
                        break;

                    case 222540009:
                        sb.Append(timeZoneSpecificDateTime.ToString("dddd"));
                        break;

                    case 222540010:
                        sb.Append(timeZoneSpecificDateTime.ToString("%M"));
                        break;

                    case 222540011:
                        sb.Append(timeZoneSpecificDateTime.ToString("MM"));
                        break;

                    case 222540012:
                        sb.Append(timeZoneSpecificDateTime.ToString("MMM"));
                        break;

                    case 222540013:
                        sb.Append(timeZoneSpecificDateTime.ToString("MMMM"));
                        break;

                    case 222540014:
                        sb.Append(timeZoneSpecificDateTime.ToString("%y"));
                        break;

                    case 222540015:
                        sb.Append(timeZoneSpecificDateTime.ToString("yy"));
                        break;

                    case 222540016:
                        sb.Append(timeZoneSpecificDateTime.ToString("yyyy"));
                        break;

                    case 222540017:
                        sb.Append(timeZoneSpecificDateTime.ToString("%t"));
                        break;

                    case 222540018:
                        sb.Append(timeZoneSpecificDateTime.ToString("tt"));
                        break;

                    case 222540019:
                        sb.Append(" ");
                        break;

                    case 222540020:
                        sb.Append(",");
                        break;

                    case 222540021:
                        sb.Append(".");
                        break;

                    case 222540022:
                        sb.Append(":");
                        break;

                    case 222540023:
                        sb.Append("/");
                        break;

                    case 222540024:
                        sb.Append(@"\");
                        break;

                    case 222540026:
                        sb.Append("-");
                        break;

                    case 222540027:
                        sb.Append(timeZone.Id);
                        break;

                    case 222540028:
                        sb.Append(timeZone.FullName);
                        break;

                    default:
                        break;
                    }
                }
                catch
                {
                    throw new Exception(osv.Value.ToString());
                }
            }

            FormattedDate.Set(context, sb.ToString());
        }