Summary

Class:FakeXrmEasy.FakeMessageExecutors.RetrieveMultipleRequestExecutor
Assembly:FakeXrmEasy
File(s):F:\Git\fake-xrm-easy\FakeXrmEasy.Shared\FakeMessageExecutors\RetrieveMultipleRequestExecutor.cs
Covered lines:145
Uncovered lines:2
Coverable lines:147
Total lines:215
Line coverage:98.6%
Branch coverage:92.8%

Metrics

MethodCyclomatic ComplexitySequence CoverageBranch Coverage
CanExecute(...)1100100
Execute(...)2498.0293.55
PopulateFormattedValues(...)6100100
GetFormattedValueForValue(...)510085.71
GetResponsibleRequestType()1100100
GetDistinctEntities(...)4100100

File(s)

F:\Git\fake-xrm-easy\FakeXrmEasy.Shared\FakeMessageExecutors\RetrieveMultipleRequestExecutor.cs

#LineLine coverage
 1using FakeXrmEasy.Extensions;
 2using FakeXrmEasy.Extensions.FetchXml;
 3using Microsoft.Xrm.Sdk;
 4using Microsoft.Xrm.Sdk.Messages;
 5using Microsoft.Xrm.Sdk.Query;
 6using System;
 7using System.Collections.Generic;
 8using System.Linq;
 9
 10namespace FakeXrmEasy.FakeMessageExecutors
 11{
 12    public class RetrieveMultipleRequestExecutor : IFakeMessageExecutor
 13    {
 14        public bool CanExecute(OrganizationRequest request)
 72915        {
 72916            return request is RetrieveMultipleRequest;
 72917        }
 18
 19        public OrganizationResponse Execute(OrganizationRequest req, XrmFakedContext ctx)
 236720        {
 236721            var request = req as RetrieveMultipleRequest;
 236722            List<Entity> list = null;
 236723            PagingInfo pageInfo = null;
 24            QueryExpression qe;
 25
 236726            string entityName = null;
 27
 236728             if (request.Query is QueryExpression)
 158129            {
 158130                qe = (request.Query as QueryExpression).Clone();
 158131                entityName = qe.EntityName;
 32
 158133                var linqQuery = XrmFakedContext.TranslateQueryExpressionToLinq(ctx, qe);
 156634                list = linqQuery.ToList();
 156635            }
 78636             else if (request.Query is FetchExpression)
 66737            {
 66738                var fetchXml = (request.Query as FetchExpression).Query;
 66739                var xmlDoc = XrmFakedContext.ParseFetchXml(fetchXml);
 66740                qe = XrmFakedContext.TranslateFetchXmlDocumentToQueryExpression(ctx, xmlDoc);
 64941                entityName = qe.EntityName;
 42
 64943                var linqQuery = XrmFakedContext.TranslateQueryExpressionToLinq(ctx, qe);
 63744                list = linqQuery.ToList();
 45
 63746                 if (xmlDoc.IsAggregateFetchXml())
 14447                {
 14448                    list = XrmFakedContext.ProcessAggregateFetchXml(ctx, xmlDoc, list);
 14449                }
 63750            }
 11951             else if (request.Query is QueryByAttribute)
 11952            {
 53                // We instantiate a QueryExpression to be executed as we have the implementation done already
 11954                var query = request.Query as QueryByAttribute;
 11955                qe = new QueryExpression(query.EntityName);
 11956                entityName = qe.EntityName;
 57
 11958                qe.ColumnSet = query.ColumnSet;
 11959                qe.Criteria = new FilterExpression();
 58460                 for (var i = 0; i < query.Attributes.Count; i++)
 17361                {
 17362                    qe.Criteria.AddCondition(new ConditionExpression(query.Attributes[i], ConditionOperator.Equal, query
 17363                }
 64
 36965                foreach (var order in query.Orders)
 666                {
 667                    qe.AddOrder(order.AttributeName, order.OrderType);
 668                }
 69
 11970                qe.PageInfo = query.PageInfo;
 71
 72                // QueryExpression now done... execute it!
 11973                var linqQuery = XrmFakedContext.TranslateQueryExpressionToLinq(ctx, qe);
 11974                list = linqQuery.ToList();
 11975            }
 76            else
 077            {
 078                throw PullRequestException.NotImplementedOrganizationRequest(request.Query.GetType());
 79            }
 80
 232281             if (qe.Distinct)
 4282            {
 4283                list = GetDistinctEntities(list);
 4284            }
 85
 86            // Handle the top count before taking paging into account
 232287             if (qe.TopCount != null && qe.TopCount.Value < list.Count)
 688            {
 689                list = list.Take(qe.TopCount.Value).ToList();
 690            }
 91
 92            // Handle TotalRecordCount here?
 232293            int totalRecordCount = -1;
 232294             if (qe?.PageInfo?.ReturnTotalRecordCount == true)
 3095            {
 3096                totalRecordCount = list.Count;
 3097            }
 98
 99            // Handle paging
 2322100            var pageSize = ctx.MaxRetrieveCount;
 2322101            pageInfo = qe.PageInfo;
 2322102            int pageNumber = 1;
 2322103             if (pageInfo != null && pageInfo.PageNumber > 0)
 1299104            {
 1299105                pageNumber = pageInfo.PageNumber;
 1299106                 pageSize = pageInfo.Count == 0 ? ctx.MaxRetrieveCount : pageInfo.Count;
 1299107            }
 108
 109            // Figure out where in the list we need to start and how many items we need to grab
 2322110            int numberToGet = pageSize;
 2322111            int startPosition = 0;
 112
 2322113             if (pageNumber != 1)
 36114            {
 36115                startPosition = (pageNumber - 1) * pageSize;
 36116            }
 117
 2322118             if (list.Count < pageSize)
 2118119            {
 2118120                numberToGet = list.Count;
 2118121            }
 204122             else if (list.Count - pageSize * (pageNumber - 1) < pageSize)
 18123            {
 18124                numberToGet = list.Count - (pageSize * (pageNumber - 1));
 18125            }
 126
 2322127            var recordsToReturn = startPosition + numberToGet > list.Count ? new List<Entity>() : list.GetRange(startPos
 128
 18071129            recordsToReturn.ForEach(e => e.ApplyDateBehaviour(ctx));
 18071130            recordsToReturn.ForEach(e => PopulateFormattedValues(e));
 131
 2322132            var response = new RetrieveMultipleResponse
 2322133            {
 2322134                Results = new ParameterCollection
 2322135                                 {
 2322136                                    { "EntityCollection", new EntityCollection(recordsToReturn) }
 2322137                                 }
 2322138            };
 2322139            response.EntityCollection.EntityName = entityName;
 2322140            response.EntityCollection.MoreRecords = (list.Count - pageSize * pageNumber) > 0;
 2322141            response.EntityCollection.TotalRecordCount = totalRecordCount;
 142
 2322143             if (response.EntityCollection.MoreRecords)
 66144            {
 66145                var first = response.EntityCollection.Entities.First();
 66146                var last = response.EntityCollection.Entities.Last();
 66147                response.EntityCollection.PagingCookie = $"<cookie page=\"{pageNumber}\"><{first.LogicalName}id last=\"{
 66148            }
 149
 2322150            return response;
 2322151        }
 152
 153        /// <summary>
 154        /// Populates the formmated values property of this entity record based on the proxy types
 155        /// </summary>
 156        /// <param name="e"></param>
 157        protected void PopulateFormattedValues(Entity e)
 15749158        {
 159            // Iterate through attributes and retrieve formatted values based on type
 80637160            foreach (var attKey in e.Attributes.Keys)
 16695161            {
 16695162                var value = e[attKey];
 16695163                string formattedValue = "";
 16695164                 if (!e.FormattedValues.ContainsKey(attKey) && (value != null))
 16677165                {
 166                    bool bShouldAdd;
 16677167                    formattedValue = this.GetFormattedValueForValue(value, out bShouldAdd);
 16677168                     if (bShouldAdd)
 6169                    {
 6170                        e.FormattedValues.Add(attKey, formattedValue);
 6171                    }
 16677172                }
 16695173            }
 15749174        }
 175
 176        protected string GetFormattedValueForValue(object value, out bool bShouldAddFormattedValue)
 20773177        {
 20773178            bShouldAddFormattedValue = false;
 20773179            var sFormattedValue = string.Empty;
 180
 20773181             if (value is Enum)
 6182            {
 183                // Retrieve the enum type
 6184                sFormattedValue = Enum.GetName(value.GetType(), value);
 6185                bShouldAddFormattedValue = true;
 6186            }
 20767187             else if (value is AliasedValue)
 4096188            {
 4096189                 return this.GetFormattedValueForValue((value as AliasedValue)?.Value, out bShouldAddFormattedValue);
 190            }
 191
 16677192            return sFormattedValue;
 20773193        }
 194
 195        public Type GetResponsibleRequestType()
 4264196        {
 4264197            return typeof(RetrieveMultipleRequest);
 4264198        }
 199
 200        private static List<Entity> GetDistinctEntities(IEnumerable<Entity> input)
 42201        {
 42202            var output = new List<Entity>();
 203
 258204            foreach (var entity in input)
 66205            {
 90206                 if (!output.Any(i => i.LogicalName == entity.LogicalName && i.Attributes.SequenceEqual(entity.Attributes
 48207                {
 48208                    output.Add(entity);
 48209                }
 66210            }
 211
 42212            return output;
 42213        }
 214    }
 215}