Esempio n. 1
0
        /// <inheritdoc />
        protected override void Execute(Context context)
        {
            var query  = FetchXml.Get(context);
            var result = context.Service.RetrieveMultiple(query);

            if (result.Entities.Count < 1)
            {
                return;
            }

            decimal resultAsDecimal = 0;

            foreach (var entity in result.Entities)
            {
                foreach (var attribute in entity.Attributes)
                {
                    if (attribute.Value is decimal || attribute.Value is double || attribute.Value is int)
                    {
                        resultAsDecimal += Convert.ToDecimal(attribute.Value);
                    }
                    else if (attribute.Value is Money)
                    {
                        resultAsDecimal += ((Money)attribute.Value).Value;
                    }
                }
            }
            ResultAsDecimal.Set(context, resultAsDecimal);
            ResultAsDouble.Set(context, Convert.ToDouble(resultAsDecimal));
            ResultAsInteger.Set(context, Convert.ToInt32(resultAsDecimal));
            ResultAsMoney.Set(context, new Money(resultAsDecimal));
        }
Esempio n. 2
0
        protected void Execute(Context context, EntityReference ownerRef)
        {
            var fetchXml         = FetchXml.Get(context);
            var entities         = context.Service.RetrieveMultiple(fetchXml).Entities;
            var affectedEntities = 0;

            foreach (var entity in entities)
            {
                try
                {
                    var request = new AssignRequest {
                        Assignee = ownerRef, Target = entity.ToEntityReference()
                    };
                    context.Service.Execute(request);
                    affectedEntities++;
                }
                catch (Exception ex)
                {
                    context.TracingService.Trace(ex);
                }
            }
            if (affectedEntities == 0)
            {
                SetError(context, "В процессе назначения записей произошли ошибки. Ни одна запись не назначена.");
            }
            else if (affectedEntities < entities.Count)
            {
                SetError(context, $"В процессе назначения записей произошли ошибки. Записей назначено: {affectedEntities}, записей не назначено: {entities.Count - affectedEntities}.");
            }
            AffectedEntities.Set(context, affectedEntities);
        }
Esempio n. 3
0
        protected override void Execute(Context context)
        {
            var query = FetchXml.Get(context);

            if (string.IsNullOrWhiteSpace(query))
            {
                return;
            }

            var entities = context.Service.RetrieveMultiple(query).Entities;

            FindedCount.Set(context, entities.Count);

            if (entities.Count == 0)
            {
                DeletedCount.Set(context, 0);
                return;
            }

            var request = new ExecuteMultipleRequest
            {
                Settings = new ExecuteMultipleSettings
                {
                    ContinueOnError = false,
                    ReturnResponses = true
                },
                Requests = new OrganizationRequestCollection()
            };

            request.Requests.AddRange(entities.Select(entity => new DeleteRequest
            {
                Target = entity.ToEntityReference()
            }));

            var responses = (ExecuteMultipleResponse)context.Service.Execute(request);

            if (!responses.IsFaulted)
            {
                DeletedCount.Set(context, entities.Count);
                return;
            }

            var deletedCount = 0;
            var faults       = new List <string>();

            foreach (var response in responses.Responses)
            {
                if (response.Fault == null)
                {
                    deletedCount++;
                }
                else
                {
                    faults.Add(response.Fault.Message);
                }
            }
            DeletedCount.Set(context, deletedCount);
            throw new Exception(string.Join(" ", faults));
        }
Esempio n. 4
0
        /// <inheritdoc />
        protected override void Execute(Context context)
        {
            var query = FetchXml.Get(context);

            if (string.IsNullOrWhiteSpace(query))
            {
                return;
            }

            var result = context.Service.RetrieveMultiple(query);

            ResultAsDecimal.Set(context, result.Entities.Count);
            ResultAsDouble.Set(context, Convert.ToDouble(result.Entities.Count));
            ResultAsInteger.Set(context, Convert.ToInt32(result.Entities.Count));
        }
Esempio n. 5
0
        /// <inheritdoc />
        protected override void Execute(Context context)
        {
            var query = FetchXml.Get(context);

            if (string.IsNullOrWhiteSpace(query))
            {
                return;
            }

            var result = context.Service.RetrieveMultiple(query);

            if (result.Entities.Count < 1)
            {
                return;
            }

            var values = new List <decimal>();

            foreach (var entity in result.Entities)
            {
                foreach (var attribute in entity.Attributes)
                {
                    if (attribute.Value is decimal || attribute.Value is double || attribute.Value is int)
                    {
                        values.Add(Convert.ToDecimal(attribute.Value));
                    }
                    else if (attribute.Value is Money)
                    {
                        values.Add(((Money)attribute.Value).Value);
                    }
                }
            }
            if (values.Count == 0)
            {
                return;
            }

            var sortedValues    = values.OrderBy(number => number);
            var itemIndex       = sortedValues.Count() / 2;
            var resultAsDecimal = sortedValues.Count() % 2 == 0
                ? (sortedValues.ElementAt(itemIndex) + sortedValues.ElementAt(itemIndex - 1)) / 2
                : sortedValues.ElementAt(itemIndex);

            ResultAsDecimal.Set(context, resultAsDecimal);
            ResultAsDouble.Set(context, Convert.ToDouble(resultAsDecimal));
            ResultAsInteger.Set(context, Convert.ToInt32(resultAsDecimal));
            ResultAsMoney.Set(context, new Money(resultAsDecimal));
        }
Esempio n. 6
0
        private void PreviewLive(Entity view)
        {
            if (Live && Parent != null)
            {
                var service = ((IXrmToolBoxPluginControl)Parent).Service;

                if (service != null)
                {
                    new Task(() =>
                    {
                        var query           = FetchXml;
                        var queryAttributes = query.FirstChild.Attributes;

                        XmlAttribute count;

                        // Search for 'count' attribute, if any
                        count = queryAttributes.Cast <XmlAttribute>().Where(x => x.Name == "count").FirstOrDefault();

                        if (count != null)
                        {
                            queryAttributes.Remove(count);
                        }

                        // Adding 'count' attribute to restrict output
                        count       = FetchXml.CreateAttribute("count");
                        count.Value = "50";

                        // Appending new attribute to query
                        queryAttributes.Append(count);

                        var result = service.RetrieveMultiple(new FetchExpression(query.InnerXml));

                        if (result != null)
                        {
                            Invoke(new Action(() =>
                            {
                                Set(result.Entities);
                            }));
                        }
                    }).Start();
                }
            }
        }
Esempio n. 7
0
        /// <inheritdoc />
        protected override void Execute(Context context)
        {
            Json.Set(context, null);

            var query = FetchXml.Get(context);

            var entity = context.SystemService.RetrieveMultiple(query).Entities.FirstOrDefault();

            if (entity == null)
            {
                return;
            }

            Json.Set(context, JsonConvert.SerializeObject(new
            {
                entity.LogicalName,
                entity.Id,
                Attributes      = entity.Attributes.ToDictionary(e => e.Key, e => e.Value),
                FormattedValues = entity.FormattedValues.ToDictionary(e => e.Key, e => e.Value)
            }));
        }
Esempio n. 8
0
        protected override void Execute(CodeActivityContext executionContext)
        {
            #region "Load CRM Service from context"

            Common objCommon = new Common(executionContext);
            objCommon.tracingService.Trace("ConcatenateFromQuery -- Start!");
            #endregion

            #region "Read Parameters"
            var fetchXml = FetchXml.Get(executionContext);
            if (string.IsNullOrEmpty(fetchXml))
            {
                return;
            }
            objCommon.tracingService.Trace($"FetchXML={fetchXml}");

            var attributeFieldName = AttributeName.Get(executionContext);
            objCommon.tracingService.Trace($"AttributeName={attributeFieldName}");

            var separator = Separator.Get(executionContext);
            objCommon.tracingService.Trace($"Separator={separator}");

            var format = FormatString.Get(executionContext);
            objCommon.tracingService.Trace($"FormatString={format}");

            IWorkflowContext context = executionContext.GetExtension <IWorkflowContext>();

            #endregion

            #region "Concatenation Execution"
            string pagingCookie = null;

            bool          hasMoreRecords   = false;
            bool          canPerformPaging = fetchXml.IndexOf("top=", StringComparison.CurrentCultureIgnoreCase) < 0;
            int           pageNumber       = canPerformPaging ? 1 : 0;
            int           fetchCount       = canPerformPaging ? 250 : 0;
            List <string> stringValues     = new List <string>();
            do
            {
                objCommon.tracingService.Trace($"Fetch PageNumber={pageNumber}");

                fetchXml = fetchXml.Replace("{PARENT_GUID}", context.PrimaryEntityId.ToString());

                string xml = CreateXml(fetchXml, pagingCookie, pageNumber, fetchCount);
                RetrieveMultipleRequest fetchRequest1 = new RetrieveMultipleRequest
                {
                    Query = new FetchExpression(xml)
                };
                EntityCollection returnCollection =
                    ((RetrieveMultipleResponse)objCommon.service.Execute(fetchRequest1)).EntityCollection;
                bool attributeNamesSentToTrace = false;
                foreach (var entity in returnCollection.Entities)
                {
                    if (!entity.Attributes.Any())
                    {
                        continue;
                    }

                    if (!attributeNamesSentToTrace)
                    {
                        var attributeNames = entity.Attributes.Select(a => a.Key).Aggregate((x, y) => x + "," + y);
                        objCommon.tracingService.Trace($"List of attributes available: {attributeNames}");
                        attributeNamesSentToTrace = true;
                    }

                    object attribute = null;
                    if (!string.IsNullOrEmpty(attributeFieldName))
                    {
                        if (entity.Attributes.ContainsKey(attributeFieldName))
                        {
                            attribute = entity.Attributes[attributeFieldName];
                        }
                    }
                    else
                    {
                        attribute = entity.Attributes.First().Value;
                    }

                    if (attribute == null)
                    {
                        continue;
                    }

                    if (attribute is AliasedValue)
                    {
                        attribute = ((AliasedValue)attribute).Value;
                    }

                    if (attribute is EntityReference)
                    {
                        attribute = ((EntityReference)attribute).Name;
                    }
                    else if (attribute is Money)
                    {
                        attribute = ((Money)attribute).Value;
                    }
                    else if (attribute is OptionSetValue)
                    {
                        attribute = ((OptionSetValue)attribute).Value;
                        if (entity.FormattedValues.ContainsKey(attributeFieldName))
                        {
                            attribute = entity.FormattedValues[attributeFieldName];
                        }
                    }

                    var attributeValueAsString = string.Format($"{{0:{format}}}", attribute);
                    stringValues.Add(attributeValueAsString);
                }

                if (canPerformPaging && returnCollection.MoreRecords)
                {
                    pageNumber++;
                    pagingCookie   = returnCollection.PagingCookie;
                    hasMoreRecords = returnCollection.MoreRecords;
                }
            } while (hasMoreRecords);

            if (stringValues.Any())
            {
                var concatenatedString = stringValues.Aggregate((x, y) => x + separator + y);
                objCommon.tracingService.Trace($"Concatenated string: {concatenatedString}");
                ConcatenatedString.Set(executionContext, concatenatedString);
            }
            else
            {
                objCommon.tracingService.Trace("No data found to concatenate");
            }

            objCommon.tracingService.Trace("ConcatenateFromQuery -- Done!");

            #endregion
        }
Esempio n. 9
0
        /// <inheritdoc />
        protected override void Execute(Context context)
        {
            var query = FetchXml.Get(context);

            if (string.IsNullOrWhiteSpace(query))
            {
                return;
            }

            var result = context.Service.RetrieveMultiple(query);

            if (result.Entities.Count < 1)
            {
                return;
            }

            var entity = result.Entities.First();

            var regex         = new Regex(@"<attribute name=[""'](?<name>[^\s]+)[""']\s*/>", RegexOptions.IgnoreCase | RegexOptions.Multiline);
            var attributeName = regex.Matches(query).Cast <Match>().Select(match => match.Groups["name"].Value).FirstOrDefault();

            if (attributeName == null)
            {
                ResultAsString.Set(context, entity.Id.ToString());
                return;
            }

            if (entity.Attributes.Keys.All(a => a != attributeName))
            {
                attributeName = entity.Attributes.Keys.FirstOrDefault(a => a.EndsWith($".{attributeName}"));
            }

            if (!entity.Contains(attributeName))
            {
                return;
            }

            var attributeValue = entity.Attributes[attributeName];

            if (attributeValue is AliasedValue)
            {
                attributeValue = ((AliasedValue)attributeValue).Value;
            }

            if (attributeValue is Money)
            {
                attributeValue = ((Money)attributeValue).Value;
            }

            if (attributeValue is EntityReference)
            {
                attributeValue = ((EntityReference)attributeValue).Id;
            }

            ResultAsString.Set(context, attributeValue.ToString());

            if (attributeValue is DateTime)
            {
                ResultAsDateTime.Set(context, (DateTime)attributeValue);
                return;
            }

            if (attributeValue is OptionSetValue)
            {
                attributeValue = ((OptionSetValue)attributeValue).Value;
                // TODO: Получение метки элемента списка и отображение его в качестве текстового значения.
                ResultAsString.Set(context, attributeValue.ToString());
            }

            if (attributeValue is bool || attributeValue is decimal || attributeValue is double || attributeValue is int)
            {
                var decimalValue = Convert.ToDecimal(attributeValue);
                ResultAsBoolean.Set(context, Convert.ToBoolean(attributeValue));
                ResultAsDecimal.Set(context, decimalValue);
                ResultAsDouble.Set(context, Convert.ToDouble(attributeValue));
                ResultAsInteger.Set(context, Convert.ToInt32(attributeValue));
                ResultAsMoney.Set(context, new Money(decimalValue));
            }
        }
Esempio n. 10
0
        /// <summary>
        /// SavedQueryView constructor
        /// </summary>
        /// <param name="serviceContext">OrganizationServiceContext</param>
        /// <param name="savedQuery">savedquery entity</param>
        /// <param name="fetchXmlString">Existing known FetchXML for this view</param>
        /// <param name="layoutXmlString">Existing known LayoutXML for this view</param>
        /// <param name="languageCode">Language code used to retrieve the localized attribute label</param>
        /// <param name="aliasColumnNameStringFormat">A format string used to compose an alias column label. Index 0 is the alias attribute display name, index 1 is the aliased entity's display name. Default is "{0} ({1})".</param>
        public SavedQueryView(OrganizationServiceContext serviceContext, Entity savedQuery, string fetchXmlString, string layoutXmlString, int?languageCode = 0, string aliasColumnNameStringFormat = DefaultAliasColumnNameStringFormat)
        {
            if (serviceContext == null)
            {
                throw new ArgumentNullException("serviceContext");
            }

            if (savedQuery == null)
            {
                throw new ArgumentNullException("savedQuery");
            }

            ServiceContext = serviceContext;
            SavedQuery     = savedQuery;
            LanguageCode   = languageCode ?? 0;
            AliasColumnNameStringFormat = aliasColumnNameStringFormat;

            if (string.IsNullOrEmpty(fetchXmlString))
            {
                fetchXmlString = savedQuery.GetAttributeValue <string>("fetchxml");
            }
            if (!string.IsNullOrEmpty(fetchXmlString))
            {
                FetchXml       = XElement.Parse(fetchXmlString);
                SortExpression = SetSortExpression(FetchXml);

                var entityElement = FetchXml.Element("entity");
                if (entityElement != null)
                {
                    var entityName = entityElement.Attribute("name").Value;
                    EntityLogicalName = entityName;
                }

                var response = (RetrieveEntityResponse)ServiceContext.Execute(new RetrieveEntityRequest
                {
                    LogicalName   = EntityLogicalName,
                    EntityFilters = EntityFilters.Attributes
                });

                if (response == null || response.EntityMetadata == null)
                {
                    ADXTrace.Instance.TraceError(TraceCategory.Application, string.Format("Failed to get EntityMetadata for entity of type '{0}'.", EntityNamePrivacy.GetEntityName(EntityLogicalName)));

                    return;
                }

                EntityMetadata = response.EntityMetadata;

                PrimaryKeyLogicalName = EntityMetadata.PrimaryIdAttribute;
            }

            if (string.IsNullOrEmpty(layoutXmlString))
            {
                layoutXmlString = savedQuery.GetAttributeValue <string>("layoutxml");
            }
            LayoutXml = XElement.Parse(layoutXmlString);

            var rowElement = LayoutXml.Element("row");

            if (rowElement != null)
            {
                var cellNames = rowElement.Elements("cell")
                                .Where(cell => cell.Attribute("ishidden") == null || cell.Attribute("ishidden").Value != "1")
                                .Select(cell => cell.Attribute("name")).Where(name => name != null);
                CellNames = cellNames;
                var disabledSortCellNames = rowElement.Elements("cell")
                                            .Where(cell => cell.Attribute("disableSorting") != null && cell.Attribute("disableSorting").Value == "1")
                                            .Where(cell => cell.Attribute("name") != null)
                                            .Select(cell => cell.Attribute("name").Value);
                DisabledSortCellNames = disabledSortCellNames;
                var cellWidths = rowElement.Elements("cell")
                                 .Where(cell => cell.Attribute("ishidden") == null || cell.Attribute("ishidden").Value != "1")
                                 .Where(cell => cell.Attribute("name") != null)
                                 .ToDictionary(cell => cell.Attribute("name").Value, cell => Convert.ToInt32(cell.Attribute("width").Value));
                CellWidths = cellWidths;
            }

            Name = ServiceContext.RetrieveLocalizedLabel(savedQuery.ToEntityReference(), "name", LanguageCode);
            Id   = savedQuery.GetAttributeValue <Guid>("savedqueryid");
        }
        public override void DoAction(BaseSolution solution)
        {
            ActionStarted();
            DynamicsSolution ds = (DynamicsSolution)solution;

            ds.Service.PublishAll();
            if (!String.IsNullOrEmpty(FetchXml) && !String.IsNullOrEmpty(WorkflowId))
            {
                // get all lines of fetch
                var fetchLines = FetchXml.Split('<');

                //replace first line <fetch.... with <fetch {0}>
                for (int i = 0; i < fetchLines.Length; i++)
                {
                    if (fetchLines[i].Contains("fetch"))
                    {
                        fetchLines[i] = "fetch {0}>";

                        break;
                    }
                }

                FetchXml = String.Join("<", fetchLines);

                bool   moreRecords;
                int    page         = 1;
                string cookie       = string.Empty;
                int    totalRecords = 0;

                int batch = 1000;//int.Parse(ConfigurationManager.AppSettings["batch"]);

                ExecuteMultipleRequest emr = new ExecuteMultipleRequest()
                {
                    Requests = new OrganizationRequestCollection(),
                    Settings = new ExecuteMultipleSettings()
                    {
                        ContinueOnError = false,
                        ReturnResponses = false
                    }
                };

                do
                {
                    var xml     = string.Format(FetchXml, cookie);
                    var results = ds.Service.Service.RetrieveMultiple(new FetchExpression(xml));
                    totalRecords += results.Entities.Count;

                    foreach (var r in results.Entities)
                    {
                        if (emr.Requests.Count == batch)
                        {
                            ds.Service.Service.Execute(emr);

                            emr = new ExecuteMultipleRequest()
                            {
                                Requests = new OrganizationRequestCollection(),
                                Settings = new ExecuteMultipleSettings()
                                {
                                    ContinueOnError = false,
                                    ReturnResponses = false
                                }
                            };
                        }

                        emr.Requests.Add(new ExecuteWorkflowRequest
                        {
                            EntityId   = r.Id,
                            WorkflowId = Guid.Parse(WorkflowId)
                        });
                    }

                    if (emr.Requests.Any())
                    {
                        ds.Service.Service.Execute(emr);
                        emr = new ExecuteMultipleRequest()
                        {
                            Requests = new OrganizationRequestCollection(),
                            Settings = new ExecuteMultipleSettings()
                            {
                                ContinueOnError = false,
                                ReturnResponses = false
                            }
                        };
                    }

                    moreRecords = results.MoreRecords;
                    if (moreRecords)
                    {
                        page++;
                        cookie = string.Format("paging-cookie='{0}' page='{1}'", System.Security.SecurityElement.Escape(results.PagingCookie), page);
                    }
                }while (moreRecords);

                LogInfo($"Processed {totalRecords} records");
            }
            ActionCompleted();
        }
Esempio n. 12
0
        protected override void Execute(CodeActivityContext context)
        {
            ITracingService             trace           = context.GetExtension <ITracingService>();
            IWorkflowContext            workflowContext = context.GetExtension <IWorkflowContext>();
            IOrganizationServiceFactory serviceFactory  = context.GetExtension <IOrganizationServiceFactory>();
            IOrganizationService        service         = serviceFactory.CreateOrganizationService(workflowContext.UserId);

            var fetchXml        = FetchXml.Get <string>(context);
            var returnType      = FetchXml.Get <string>(context);
            var returnAttribute = FetchXml.Get <string>(context);

            if (string.IsNullOrWhiteSpace(fetchXml))
            {
                trace.Trace("fetch xml is null");
                return;
            }
            if (string.IsNullOrWhiteSpace(returnType))
            {
                trace.Trace("return type is null");
                return;
            }
            if (string.IsNullOrWhiteSpace(returnAttribute))
            {
                trace.Trace("return attribute is null.");
                return;
            }
            var query    = new FetchExpression(fetchXml);
            var response = service.RetrieveMultiple(query);

            if (response == null || response.Entities == null || response.Entities.Count == 0)
            {
                trace.Trace("response is null");
                return;
            }

            if (!response.Entities[0].Contains(returnAttribute))
            {
                trace.Trace("response doesnt have the requested attribute.");
                return;
            }

            if (response.Entities[0][returnAttribute] == null)
            {
                trace.Trace("returned object is null");
                return;
            }

            if (returnType.Equals("bool", StringComparison.OrdinalIgnoreCase))
            {
                trace.Trace("setting boolean value.");
                ReturnValueBool.Set(context, (bool)response.Entities[0][returnAttribute]);
            }
            if (returnType.Equals("int", StringComparison.OrdinalIgnoreCase))
            {
                trace.Trace("setting integer value.");
                ReturnValueInt.Set(context, (int)response.Entities[0][returnAttribute]);
            }
            if (returnType.Equals("string", StringComparison.OrdinalIgnoreCase))
            {
                trace.Trace("setting string value.");
                ReturnValueString.Set(context, response.Entities[0][returnAttribute].ToString());
            }
        }