public void GetByEmailTest() { Contact actual; string email = "*****@*****.**"; var entity1 = new CrmEntities.Contact(); entity1.Id = Guid.NewGuid(); entity1.FirstName = "Kate"; entity1.LastName = "O'conor"; entity1.EMailAddress1 = "*****@*****.**"; var entity2 = new CrmEntities.Contact(); entity2.Id = Guid.NewGuid(); entity2.FirstName = "John"; entity2.LastName = "Smith"; entity2.EMailAddress1 = "*****@*****.**"; var organisationService = new Microsoft.Xrm.Sdk.Fakes.StubIOrganizationService(); organisationService.ExecuteOrganizationRequest = r => { List<Entity> entities = new List<Entity> { entity2 }; var response = new RetrieveMultipleResponse { Results = new ParameterCollection { { "EntityCollection", new EntityCollection(entities) } } }; return response; }; var crmUnitOfWork = new Xrm.Infrastructure.DataAccess.Crm.Fakes.StubCrmUnitOfWork(organisationService, 10); var target = new ContactRepository(organisationService, crmUnitOfWork); // // Act // actual = target.GetByEmail(email); // // Assert // Assert.IsNotNull(actual); Assert.AreEqual(entity2.EMailAddress1, actual.EmailAddress1); }
/// <summary> /// Method to Get a Record and return /// it in the form of a Dynamic Entity Object /// to the calling function /// </summary> /// <param name="poGuid"></param> /// <param name="psEntityName"></param> /// <param name="psAttributeName"></param> /// <param name="poService"></param> /// <param name="paColumnSet"></param> /// <returns></returns> public static DynamicEntity GetDynamicEntityBasedOnGuid(Guid poGuid, string psEntityName, string psAttributeName, CrmService poService, ArrayList paColumnSet) { CrmService loService = poService; QueryExpression loQuery = new QueryExpression(); DynamicEntity loDynamicEntity = null; ColumnSet loColSet = new ColumnSet(); foreach (string lsColumnItem in paColumnSet) { loColSet.AddColumn(lsColumnItem); } try { ConditionExpression loCondition = new ConditionExpression(psAttributeName, ConditionOperator.Equal, poGuid); FilterExpression loFilter = new FilterExpression(); loQuery.EntityName = psEntityName; loQuery.ColumnSet = loColSet; loFilter.Conditions.Add(loCondition); loQuery.Criteria = loFilter; RetrieveMultipleRequest loRetrieve = new RetrieveMultipleRequest(); loRetrieve.Query = loQuery; loRetrieve.ReturnDynamicEntities = true; RetrieveMultipleResponse loResponse = (RetrieveMultipleResponse)loService.Execute(loRetrieve); if (loResponse.BusinessEntityCollection.BusinessEntities.Count > 0) { loDynamicEntity = (DynamicEntity)loResponse.BusinessEntityCollection.BusinessEntities[0]; } } catch (System.Web.Services.Protocols.SoapException ex) { MessageBox.Show("Error: " + ex.Detail.InnerXml.ToString()); } catch (Exception ex) { MessageBox.Show("Error: " + ex.Message.ToString()); } return(loDynamicEntity); }
/// <summary> /// /// </summary> /// <param name="connection"></param> /// <param name="entityLogicalName"></param> /// <returns></returns> public static List <Dynamics365Workflow> GetWorkflows(Dynamics365Connection connection, string entityLogicalName) { ConnectionCache cache = new ConnectionCache(connection); string cacheKey = string.Format("GetOnDemandWorkflows:{0}", entityLogicalName); List <Dynamics365Workflow> workflows = (List <Dynamics365Workflow>)cache[cacheKey]; if (workflows == default(List <Dynamics365Workflow>)) { workflows = new List <Dynamics365Workflow>(); QueryExpression workflowQuery = new QueryExpression("workflow") { ColumnSet = new ColumnSet(true) }; using (OrganizationServiceProxy proxy = connection.OrganizationServiceProxy) { workflowQuery.Criteria.AddCondition(new ConditionExpression("category", ConditionOperator.Equal, 0)); // workflow workflowQuery.Criteria.AddCondition(new ConditionExpression("primaryentity", ConditionOperator.Equal, entityLogicalName)); workflowQuery.Criteria.AddCondition(new ConditionExpression("statecode", ConditionOperator.Equal, 1)); // activated workflowQuery.Criteria.AddCondition(new ConditionExpression("type", ConditionOperator.Equal, 1)); // definition workflowQuery.Criteria.AddCondition(new ConditionExpression("ondemand", ConditionOperator.Equal, true)); RetrieveMultipleRequest workflowRequest = new RetrieveMultipleRequest() { Query = workflowQuery }; RetrieveMultipleResponse workflowResponse = (RetrieveMultipleResponse)proxy.Execute(workflowRequest); foreach (Microsoft.Xrm.Sdk.Entity workflowMetadata in workflowResponse.EntityCollection.Entities) { workflows.Add(new Dynamics365Workflow() { ID = workflowMetadata.Id, Name = workflowMetadata.Attributes["name"].ToString() }); } } workflows.Sort((workflow1, workflow2) => workflow1.Name.CompareTo(workflow2.Name)); cache[cacheKey] = workflows; } return(workflows); }
private BulkResponse ReadExecuteMultipleResponse(ExecuteMultipleResponse executeMultipleResponse, List <string> recordIds) { List <BulkResponseItem> responses = new List <BulkResponseItem>(); if (executeMultipleResponse != null && executeMultipleResponse.Responses != null && executeMultipleResponse.Responses.Count > 0) { ExecuteMultipleResponseItemCollection responseItems = executeMultipleResponse.Responses; foreach (ExecuteMultipleResponseItem responseItem in responseItems) { string recordKey = recordIds[responseItem.RequestIndex]; BulkResponseItem bulkResponseItem = new BulkResponseItem(); bulkResponseItem.BulkRequestId = recordKey; if (responseItem.Fault != null) { string message = GetFaultedMessage(responseItem); bulkResponseItem.Error = message; } else { OrganizationResponse response = responseItem.Response; Guid recordId = Guid.Empty; if (response is CreateResponse) { bulkResponseItem.CreatedRecordId = ((CreateResponse)response).id; } else if (response is RetrieveMultipleResponse) { RetrieveMultipleResponse retrieveMultipleResponse = (RetrieveMultipleResponse)response; bulkResponseItem.Results = (retrieveMultipleResponse != null) ? retrieveMultipleResponse.EntityCollection : null; } bulkResponseItem.Success = true; } responses.Add(bulkResponseItem); } } return(new BulkResponse { Responses = responses }); }
public static void Items_Are_Readonly() { // Arrange var items = new List <int>(new[] { 1, 2, 3 }); // Act var res = new RetrieveMultipleResponse <int>(items, true); // Assert Assert.NotSame(items, res); Assert.Equal(3, EnumerableHelper.Count(res.Items)); Assert.True(res.HasMore); Assert.Throws <NotSupportedException>(() => { var list = res.Items as IList <int>; list.RemoveAt(0); }); }
public void RetrieveAccountsByIdTest() { // // Arrange // Guid id = Guid.NewGuid(); Microsoft.Xrm.Sdk.Entity expected = new Microsoft.Xrm.Sdk.Entity { Id = id }; var service = new Microsoft.Xrm.Sdk.Fakes.StubIOrganizationService(); service.ExecuteOrganizationRequest = r => { List <Entity> entities = new List <Entity> { expected }; var response = new RetrieveMultipleResponse { Results = new ParameterCollection { { "EntityCollection", new EntityCollection(entities) } } }; return(response); }; Microsoft.Xrm.Sdk.Entity actual; LINQToCRM2 target = new LINQToCRM2(service); // // Act // actual = target.RetrieveAccountsById(id); // // Assert // Assert.AreEqual(expected, actual); }
public static List <Dynamics365Team> GetTeams(Dynamics365Connection connection) { ConnectionCache cache = new ConnectionCache(connection); string cacheKey = "GetTeams:{0}"; List <Dynamics365Team> teams = (List <Dynamics365Team>)cache[cacheKey]; if (teams == default(List <Dynamics365Team>)) { teams = new List <Dynamics365Team>(); QueryExpression teamQuery = new QueryExpression("team") { ColumnSet = new ColumnSet(true) }; using (OrganizationServiceProxy proxy = connection.OrganizationServiceProxy) { if (connection.IsVersionOrAbove(CrmVersion.Crm2013)) { teamQuery.Criteria.AddCondition(new ConditionExpression("teamtype", ConditionOperator.Equal, 0)); } RetrieveMultipleRequest teamRequest = new RetrieveMultipleRequest() { Query = teamQuery }; RetrieveMultipleResponse teamResponse = (RetrieveMultipleResponse)proxy.Execute(teamRequest); foreach (Microsoft.Xrm.Sdk.Entity teamMetadata in teamResponse.EntityCollection.Entities) { teams.Add(new Dynamics365Team() { ID = teamMetadata.Id, Name = teamMetadata.Attributes["name"].ToString() }); } teams.Sort((team1, team2) => team1.Name.CompareTo(team2.Name)); } cache[cacheKey] = teams; } return(teams); }
/// <summary> /// Retrieve all entity records using up to three fields and values /// </summary> /// <param name="service"></param> /// <param name="entityName">Name of the entity (Constants.ENTITYNAME.This)</param> /// <param name="entitySearchField1">Name of the 1st entity field to filter by (Constants.ENTITYNAME.FIELD)</param> /// <param name="entitySearchFieldValue1">Value for the 1st entity field to filter by</param> /// <param name="entitySearchField2">Name of the 2nd entity field to filter by (Constants.ENTITYNAME.FIELD)</param> /// <param name="entitySearchFieldValue2">Value for the 2nd entity field to filter by</param> /// <param name="entitySearchField3">Name of the 3rd entity field to filter by (Constants.ENTITYNAME.FIELD)</param> /// <param name="entitySearchFieldValue3">Value for the 3rd entity field to filter by</param> /// <param name="columnSet"></param> /// <param name="activeRecordsOnly">Optional - Selects only records with statecode of 0, which is usually active, or open records</param> /// <returns></returns> static public List <Entity> EntitiesList(IOrganizationService service, string entityName, string entitySearchField1, object entitySearchFieldValue1, string entitySearchField2, object entitySearchFieldValue2, string entitySearchField3, object entitySearchFieldValue3, ColumnSet columnSet, bool activeRecordsOnly = false) { RetrieveMultipleRequest getRequest = new RetrieveMultipleRequest(); QueryExpression qex = new QueryExpression(entityName); if (columnSet == null) { qex.ColumnSet = new ColumnSet(true); // They get all } else { qex.ColumnSet = columnSet; // Give them just what they asked for } qex.Criteria = new FilterExpression(); qex.Criteria.FilterOperator = LogicalOperator.And; if (entitySearchFieldValue1 != null) { qex.Criteria.AddCondition(new ConditionExpression(entitySearchField1, ConditionOperator.Equal, entitySearchFieldValue1)); } if (entitySearchFieldValue2 != null) { qex.Criteria.AddCondition(new ConditionExpression(entitySearchField2, ConditionOperator.Equal, entitySearchFieldValue2)); } if (entitySearchFieldValue3 != null) { qex.Criteria.AddCondition(new ConditionExpression(entitySearchField3, ConditionOperator.Equal, entitySearchFieldValue3)); } if (activeRecordsOnly) { qex.Criteria.AddCondition(new ConditionExpression("statecode", ConditionOperator.Equal, 0)); } getRequest.Query = qex; RetrieveMultipleResponse returnValues = (RetrieveMultipleResponse)service.Execute(getRequest); if (returnValues.EntityCollection.Entities != null) { return(returnValues.EntityCollection.Entities.ToList()); } return(null); }
/// <summary> /// /// </summary> /// <param name="entity"></param> /// <param name="connection"></param> /// <returns></returns> private static List <Dynamics365View> GetPersonalViews(Dynamics365Entity entity, IConnection connection) { ConnectionCache cache = new ConnectionCache(connection); string cacheKey = string.Format("GetPersonalViews:{0}:{1}", typeof(Dynamics365View).Name, entity.LogicalName); List <Dynamics365View> views = (List <Dynamics365View>)cache[cacheKey]; if (views == null) { views = new List <Dynamics365View>(); QueryExpression query = new QueryExpression("userquery"); query.Criteria.AddCondition("returnedtypecode", ConditionOperator.Equal, entity.ObjectTypeCode); query.Criteria.AddCondition("fetchxml", ConditionOperator.NotNull); query.Criteria.AddCondition("statecode", ConditionOperator.Equal, 0); query.ColumnSet = new ColumnSet(new string[] { "name", "fetchxml" }); // todo - not working? RetrieveMultipleRequest request = new RetrieveMultipleRequest() { Query = query }; using (OrganizationServiceProxy proxy = ((Dynamics365Connection)connection).OrganizationServiceProxy) { RetrieveMultipleResponse response = (RetrieveMultipleResponse)proxy.Execute(request); foreach (Entity viewEntity in response.EntityCollection.Entities) { Dynamics365View view = new Dynamics365View() { ID = viewEntity.Id, DisplayName = (string)viewEntity.Attributes["name"], FetchXml = (string)viewEntity.Attributes["fetchxml"] }; views.Add(view); } views.Sort((view1, view2) => view1.DisplayName.CompareTo(view2.DisplayName)); } cache[cacheKey] = views; } return(views); }
public void Should_Be_Able_To_Fill_DataTable() { // Arrange using (var sandbox = ConnectionTestsSandbox.Create()) { var dbConnection = sandbox.Container.Resolve <CrmDbConnection>(); var selectCommand = new CrmDbCommand(dbConnection); selectCommand.CommandText = "SELECT * FROM contact"; int resultCount = 100; var entityDataGenerator = new EntityDataGenerator(); IList <Entity> fakeContactsData = entityDataGenerator.GenerateFakeEntities("contact", resultCount); // This is the fake reponse that the org service will return when its requested to get the data. var response = new RetrieveMultipleResponse { Results = new ParameterCollection { { "EntityCollection", new EntityCollection(fakeContactsData) { EntityName = "contact" } } } }; // Setup fake org service to return fake response. sandbox.FakeOrgService.Stub(f => f.Execute(Arg <OrganizationRequest> .Matches(new OrganizationRequestMessageConstraint <RetrieveMultipleRequest>()))) .WhenCalled(x => { var request = ((RetrieveMultipleRequest)x.Arguments[0]); }).Return(response); // Act var dt = new DataTable(); var subject = ResolveTestSubjectInstance(); subject.SelectCommand = selectCommand; var result = subject.Fill(dt); // Assert Assert.That(dt.Rows.Count, NUnit.Framework.Is.EqualTo(resultCount)); } }
public void IsMemberInTeamTest() { // // Arrange // Guid userId = Guid.NewGuid(); Guid teamId = Guid.NewGuid(); bool expected = true; AddMemberTeamActivity target = new AddMemberTeamActivity(); // IOrganizationService var service = new Microsoft.Xrm.Sdk.Fakes.StubIOrganizationService(); service.ExecuteOrganizationRequest = r => { List <Entity> entities = new List <Entity> { new Entity() }; var response = new RetrieveMultipleResponse { Results = new ParameterCollection { { "EntityCollection", new EntityCollection(entities) } } }; return(response); }; // // Act // var actual = target.IsMemberInTeam(service, teamId, userId); // // Assert // Assert.AreEqual(expected, actual); }
private ResultSet GetResultSet(RetrieveMultipleResponse retrieveMultipleResponse) { IList <IDictionary <string, object> > recordsCollection = new List <IDictionary <string, object> >(); // const string moneyType = "Money"; bool hasMoreRecords = retrieveMultipleResponse.EntityCollection.MoreRecords; foreach (var entity in retrieveMultipleResponse.EntityCollection.Entities) { IDictionary <string, object> attributesCollection = new Dictionary <string, object>(); foreach (var attribute in entity.Attributes) { var columnMetaData = new ColumnMetaData(); if (attribute.Value != null) { columnMetaData.__metadata = new MetaData(); if (attribute.Value is EntityReference) { columnMetaData.__metadata.type = typeof(EntityReference).ToString(); } else if (attribute.Value is Money) { columnMetaData.__metadata.type = typeof(Money).ToString(); } string attributeKey = attribute.Key; object attributeValue = attribute.Value; attributesCollection.Add(attributeKey, attributeValue); } } attributesCollection.Add("isOpen", false); recordsCollection.Add(attributesCollection); } var resultSet = new ResultSet { HasMoreRecords = hasMoreRecords, recordsCollection = recordsCollection }; return(resultSet); }
public static RetrieveMultipleResponse RetrieveEntities(OrganizationServiceProxy serviceProxy, ODataQuery odataQueryObject) { log.Info("Entered RetrieveEntities"); QueryExpression queryExpression = GetQueryExpression(odataQueryObject); var multipleRequest = new RetrieveMultipleRequest { Query = queryExpression }; try { RetrieveMultipleResponse result = (RetrieveMultipleResponse)serviceProxy.Execute(multipleRequest); log.Info("Exiting RetrieveEntities"); return(result); } catch (FaultException <OrganizationServiceFault> fault) { log.Error("RetrieveEntities : An Exception Occured ==" + fault.Message); throw new Exception("==An Exception Occured ==" + fault.Message); } }
private bool CheckValidUserCount(int licenseUser, IOrganizationService _crmService, IPluginExecutionContext executionContext) { QueryExpression qe = new QueryExpression(); qe.EntityName = "systemuser"; qe.ColumnSet = new ColumnSet("firstname"); ConditionExpression ce = new ConditionExpression(); ce.AttributeName = "isdisabled"; ce.Operator = ConditionOperator.Equal; ce.Values.Add("0"); ConditionExpression ce2 = new ConditionExpression(); ce2.AttributeName = "accessmode"; ce2.Operator = ConditionOperator.NotEqual; ce2.Values.Add("3"); FilterExpression fe = new FilterExpression(); fe.Conditions.Add(ce); fe.Conditions.Add(ce2); qe.Criteria = fe; RetrieveMultipleRequest retrieveMultipleRequest = new RetrieveMultipleRequest(); RetrieveMultipleResponse retrieveMultipleResponse = new RetrieveMultipleResponse(); retrieveMultipleRequest.Query = qe; retrieveMultipleResponse = (RetrieveMultipleResponse)_crmService.Execute(retrieveMultipleRequest); EntityCollection entityCollection = retrieveMultipleResponse.EntityCollection; if (entityCollection.Entities.Count <= licenseUser)//License found { return(true); } else { return(false); } }
public static List <Dynamics365User> GetUsers(Dynamics365Connection connection) { ConnectionCache cache = new ConnectionCache(connection); string cacheKey = "GetUsers"; List <Dynamics365User> users = (List <Dynamics365User>)cache[cacheKey]; if (users == null) { users = new List <Dynamics365User>(); QueryExpression userQuery = new QueryExpression("systemuser") { ColumnSet = new ColumnSet(true) }; RetrieveMultipleRequest userRequest = new RetrieveMultipleRequest() { Query = userQuery }; using (OrganizationServiceProxy proxy = (connection).OrganizationServiceProxy) { RetrieveMultipleResponse formResponse = (RetrieveMultipleResponse)proxy.Execute(userRequest); foreach (Entity userMetadata in formResponse.EntityCollection.Entities) { Dynamics365User user = new Dynamics365User() { ID = userMetadata.Id, Name = userMetadata.Attributes["fullname"].ToString() }; users.Add(user); } users.Sort((user1, user2) => user1.Name.CompareTo(user2.Name)); } cache[cacheKey] = users; } return(users); }
public override ICrmEntity GetEntity(string logicalName, string fieldName, string value, bool onlyActive, string[] columns) { FilterExpression expression = new FilterExpression { FilterOperator = LogicalOperator.And }; expression.AddCondition(new ConditionExpression(fieldName, ConditionOperator.Equal, new object[] { value })); if (onlyActive) { expression.AddCondition(new ConditionExpression("statecode", ConditionOperator.Equal, new object[] { "Active" })); } RetrieveMultipleRequest request2 = new RetrieveMultipleRequest(); QueryExpression expression3 = new QueryExpression { ColumnSet = (columns == null) ? new ColumnSet(true) : new ColumnSet(columns), EntityName = logicalName }; PagingInfo info = new PagingInfo { Count = 1, PageNumber = 1 }; expression3.PageInfo = info; expression3.Criteria = expression; request2.Query = expression3; RetrieveMultipleRequest request = request2; RetrieveMultipleResponse response = (RetrieveMultipleResponse)this._organizationService.Execute(request); var entity = response.EntityCollection.Entities.FirstOrDefault(); if (entity == null) { return(null); } return(new CrmEntityAdapter(this, entity)); }
public BusinessEntityCollection searchContact(string new_config_allid) { try { CrmConnection crmc = new CrmConnection("Crm"); CrmService crmService = crmc.CreateCrmService(); QueryExpression qe = new QueryExpression("new_config_all") { ColumnSet = new ColumnSet(new String[] { "new_config_allid", "new_name", "new_count", "new_current_amount", "new_period", "new_period" }), Criteria = new FilterExpression() { FilterOperator = LogicalOperator.And, Conditions = { new ConditionExpression("new_config_allid", ConditionOperator.Equal, new_config_allid), } } }; RetrieveMultipleResponse retrived = new RetrieveMultipleResponse(); RetrieveMultipleRequest retrive = new RetrieveMultipleRequest(); retrive.Query = qe; retrive.ReturnDynamicEntities = true; BusinessEntityCollection results = ((RetrieveMultipleResponse)crmService.Execute(retrive)).BusinessEntityCollection; return(results); } catch (SoapException ex) { logger.Error($"Не удалось осуществить поиск конфига с id {new_config_allid}. Ошибка: {ex.Message}"); throw new System.ArgumentException($"Не удалось осуществить поиск конфига с id {new_config_allid}. Ошибка: {ex.Message}", "original"); } }
/// <summary> /// Get duplicate criterias /// </summary> /// <returns>EntityCollection</returns> private EntityCollection GetDuplicateCriterias() { RetrieveMultipleRequest rmRequest = null; RetrieveMultipleResponse rmResponse = null; rmRequest = new RetrieveMultipleRequest() { Query = new QueryExpression("duplicaterulecondition") { ColumnSet = new ColumnSet(true), //ColumnSet = new ColumnSet(true), Distinct = true, LinkEntities = { new LinkEntity("duplicaterulecondition", "duplicaterule", "regardingobjectid", "duplicateruleid", JoinOperator.Inner) { LinkCriteria = { Conditions = { new ConditionExpression("baseentityname", ConditionOperator.Equal, ApplicationSetting.SelectedEntity.LogicalName), new ConditionExpression("statuscode", ConditionOperator.Equal, 2) } } } } } }; rmResponse = (RetrieveMultipleResponse)Service.Execute(rmRequest); if (rmResponse.EntityCollection != null && rmResponse.EntityCollection.Entities.Count > 0) { return(rmResponse.EntityCollection); } return(null); }
/// <summary> /// /// </summary> /// <remarks>Must set the Organization Service before calling this function</remarks> /// <param name="key"></param> /// <returns></returns> public static string RetrieveApplicationSettingValue(string key, bool encrypted = false) { string rc = ""; QueryByAttribute query = new QueryByAttribute(); query.ColumnSet = new ColumnSet("xrm_key", "xrm_value", "xrm_securevalue"); query.EntityName = "xrm_applicationsetting"; query.Attributes.Add("xrm_key"); query.Values.Add(key); RetrieveMultipleRequest request = new RetrieveMultipleRequest(); request.Query = query; try { RetrieveMultipleResponse response = (RetrieveMultipleResponse)OrganizationService.Execute(request); EntityCollection results = response.EntityCollection; if (results.Entities.Count > 0) { if (encrypted) { rc = results.Entities[0].Attributes["xrm_securevalue"].ToString(); } else { rc = results.Entities[0].Attributes["xrm_value"].ToString(); } } return(rc); } catch (FaultException <OrganizationServiceFault> ex) { throw new InvalidPluginExecutionException( String.Format("An error occurred in the {0} function of the {1} plug-in.", "RetrieveApplicationSettingValue", "CRMHelper"), ex); } }
public BusinessEntityCollection searchContact(string contactid) { try { CrmConnection crmc = new CrmConnection("Crm"); CrmService crmService = crmc.CreateCrmService(); QueryExpression qe = new QueryExpression("contact") { ColumnSet = new ColumnSet(new String[] { "contactid", "salutation", "lastname", "firstname", "middlename", "mobilephone", "emailaddress1", "address1_name", "address1_line1", "address1_city", "address1_stateorprovince", "address1_country", "new_seria", "new_nomer", "new_giveoutby", "gendercode", "new_nationality", "new_type", "familystatuscode", "birthdate", "new_openles", "new_dategiveout", "ownerid" //" address1_postalcode" // }), Criteria = new FilterExpression() { FilterOperator = LogicalOperator.And, Conditions = { new ConditionExpression("contactid", ConditionOperator.Equal, contactid), } } }; RetrieveMultipleResponse retrived = new RetrieveMultipleResponse(); RetrieveMultipleRequest retrive = new RetrieveMultipleRequest(); retrive.Query = qe; retrive.ReturnDynamicEntities = true; BusinessEntityCollection results = ((RetrieveMultipleResponse)crmService.Execute(retrive)).BusinessEntityCollection; return(results); } catch (SoapException ex) { logger.Error($"Не удалось осуществить поиск контакта с id {contactid}. Ошибка: {ex.Message}"); throw new System.ArgumentException($"Не удалось осуществить поиск контакта с id {contactid}. Ошибка: {ex.Message}", "original"); } }
/// <summary> /// Helper method to retrieve Entity instances. /// </summary> /// <param name="queryExpr">An instance of QueryExpression</param> /// <returns>An instance of EntityCollection if callback not provided.</returns> public List <Entity> RetrieveMultiple(QueryExpression queryExpr) { // Define the paging attributes. Initialize the page number. Assign the PageInfo properties to the QueryExpression. queryExpr.PageInfo = new PagingInfo(); queryExpr.PageInfo.Count = SettingCtxt.RecordPerPage; queryExpr.PageInfo.PageNumber = 1; queryExpr.PageInfo.PagingCookie = null; // The current paging cookie. PagingCookie should be null for first page. // Create instance of RetrieveMultipleRequest message. RetrieveMultipleRequest retMultiReq = new RetrieveMultipleRequest(); // Set Query Criteria for the retrieval in RetrieveMultipleRequest message. retMultiReq.Query = queryExpr; List <Entity> entitySet = new List <Entity>(); // Prevents AgrumentNullException. RetrieveMultipleResponse retMultiResp = null; do { // Request OrganizationService to Execute the RetrieveMultipleRequest message. retMultiResp = Execute <RetrieveMultipleResponse>(retMultiReq); if (retMultiResp.EntityCollection.Entities != null) { entitySet.AddRange(retMultiResp.EntityCollection.Entities); } // Check for more records, if it returns true. if (retMultiResp.EntityCollection.MoreRecords) { queryExpr.PageInfo.PageNumber += 1; // Increment the page number to retrieve the next page. queryExpr.PageInfo.PagingCookie = retMultiResp.EntityCollection.PagingCookie; // Set the paging cookie to the paging cookie returned from current results. } } while (retMultiResp.EntityCollection.MoreRecords); // Exit the loop, if no more record(s) are available in result nodes. return(entitySet); }
public void RetriveRecord() { RetrieveMultipleRequest rmr = new RetrieveMultipleRequest(); RetrieveMultipleResponse resp = new RetrieveMultipleResponse(); SiteMap wb = new SiteMap(); QueryExpression query = new QueryExpression() { EntityName = "sitemap", ColumnSet = new ColumnSet(true), }; rmr.Query = query; resp = (RetrieveMultipleResponse)_serviceProxy.Execute(rmr); wb = (SiteMap)resp.EntityCollection.Entities[0]; _sitemapId = wb.SiteMapId.Value; // byte[] b = Convert.FromBase64String(wb.Content); //************************************** //The string below will contain your HTML //************************************** //string strHTML = System.Text.Encoding.UTF8.GetString(b); }
public void RetriveRecordByCondition() { RetrieveMultipleRequest rmr = new RetrieveMultipleRequest(); RetrieveMultipleResponse resp = new RetrieveMultipleResponse(); WebResource wb = new WebResource(); QueryExpression query = new QueryExpression() { EntityName = "webresource", ColumnSet = new ColumnSet("content"), Criteria = new FilterExpression { FilterOperator = LogicalOperator.And, Conditions = { new ConditionExpression { AttributeName = "webresourceid", Operator = ConditionOperator.Equal, Values = { "572b5e08-289d-e411-80d5-000001010103" } } } } }; rmr.Query = query; resp = (RetrieveMultipleResponse)_serviceProxy.Execute(rmr); wb = (WebResource)resp.EntityCollection.Entities[0]; var s = wb.SolutionId; byte[] b = Convert.FromBase64String(wb.Content); //************************************** //The string below will contain your HTML //************************************** string strHTML = System.Text.Encoding.UTF8.GetString(b); }
private static DataCollection <Entity> RetrieveCRMRecords(CrmDbContext context, string primaryEntityAttribute, EntityReference reference, EntityDefinition ed, List <Guid> guids) { var fetch = ed.CreateFetch(); //Make Retrive Multiple Query object[] guidArray = guids.Cast <object>().ToArray(); var condition = new Condition(primaryEntityAttribute, ConditionOperator.In, guidArray); if (fetch.Entity.Filters == null || !fetch.Entity.Filters.Any()) { fetch.AddFilter(new Filter { Conditions = new List <Condition> { condition } }); } else { var firstFilter = fetch.Entity.Filters.FirstOrDefault(); if (firstFilter.Conditions == null) { firstFilter.Conditions = new List <Condition>(); } firstFilter.Conditions.Add(condition); } // retrieve a fresh entity which also acts as a backend validation ADXTrace.Instance.TraceInfo(TraceCategory.Application, string.Format("Calling Retrieve Multiple Request for Entity {0} ", EntityNamePrivacy.GetEntityName(reference.LogicalName))); RetrieveMultipleResponse responses = (RetrieveMultipleResponse)context.Service.Execute(fetch.ToRetrieveMultipleRequest()); var entities = responses.EntityCollection.Entities; ADXTrace.Instance.TraceInfo(TraceCategory.Application, string.Format("Retrieve Multiple Response for Entity {0} has Record Count {1} ", EntityNamePrivacy.GetEntityName(reference.LogicalName), responses.EntityCollection.Entities.Count)); return(entities); }
public virtual IEnumerable <T> FetchAll(string fetchXml) { RetrieveMultipleResponse allRecords = null; var conversionRequest = new FetchXmlToQueryExpressionRequest { FetchXml = fetchXml }; var conversionResponse = (FetchXmlToQueryExpressionResponse)service.Execute(conversionRequest); var retrieveRequest = new RetrieveMultipleRequest { Query = conversionResponse.Query }; // add paging to request: int i = 1; ((Microsoft.Xrm.Sdk.Query.QueryExpression)(retrieveRequest.Query)).PageInfo.Count = 5000; ((Microsoft.Xrm.Sdk.Query.QueryExpression)(retrieveRequest.Query)).PageInfo.PageNumber = i; bool moreRecords = true; do { var retrieveResponse = (RetrieveMultipleResponse)service.Execute(retrieveRequest); if (i == 1) { allRecords = retrieveResponse; } else { allRecords.EntityCollection.Entities.AddRange(retrieveResponse.EntityCollection.Entities.Select(x => (T)x)); } moreRecords = retrieveResponse.EntityCollection.MoreRecords; i++; ((Microsoft.Xrm.Sdk.Query.QueryExpression)(retrieveRequest.Query)).PageInfo.PageNumber = i; } while (moreRecords); return(allRecords.EntityCollection.Entities.Select(x => (T)x)); }
public BusinessEntityCollection searchnew_reestr(string txn_id) { CrmConnection crmc = new CrmConnection("Crm"); CrmService crmService = crmc.CreateCrmService(); QueryExpression qe = new QueryExpression("new_reestr") { ColumnSet = new ColumnSet(new String[] { "new_txn_id", "new_reestrid", "new_name" }), Criteria = new FilterExpression() { FilterOperator = LogicalOperator.And, Conditions = { new ConditionExpression("new_txn_id", ConditionOperator.Equal, txn_id), new ConditionExpression("statecode", ConditionOperator.Equal, 0), } } }; try { RetrieveMultipleResponse retrived = new RetrieveMultipleResponse(); RetrieveMultipleRequest retrive = new RetrieveMultipleRequest(); retrive.Query = qe; retrive.ReturnDynamicEntities = true; BusinessEntityCollection results = ((RetrieveMultipleResponse)crmService.Execute(retrive)).BusinessEntityCollection; return(results); } catch (SoapException ex) { logger.Error($"Не удалось осуществить поиск Реестра оплат txn_id = {txn_id}. Ошибка: {ex.Message}"); throw; } }
public static string RetrieveWebResourceByName(string name) { string rc = ""; QueryByAttribute query = new QueryByAttribute(); query.ColumnSet = new ColumnSet("content"); query.EntityName = "webresource"; query.Attributes.Add("name"); query.Values.Add(name); RetrieveMultipleRequest request = new RetrieveMultipleRequest(); request.Query = query; try { RetrieveMultipleResponse response = (RetrieveMultipleResponse)OrganizationService.Execute(request); EntityCollection results = response.EntityCollection; Entity firstResult = results.Entities[0]; if (firstResult.Contains("content")) { byte[] encodedContent = Convert.FromBase64String(firstResult.Attributes["content"].ToString()); rc = UnicodeEncoding.UTF8.GetString(encodedContent); } TracingService.Trace("Content: {0}", rc); return(rc); } catch (FaultException <OrganizationServiceFault> ex) { throw new InvalidPluginExecutionException( String.Format("An error occurred in the {0} function of the {1} plug-in.", "RetrieveWebResourceByName", "CRMHelper"), ex); } }
public static EntityCollection GetAllData(this IOrganizationService service, QueryExpression queryExp, int recCount, bool isSetNoLock = true) { var entityCol = new EntityCollection(); try { int pageNumber = 1; RetrieveMultipleRequest multiRequest; var multiResponse = new RetrieveMultipleResponse(); do { queryExp.NoLock = isSetNoLock; queryExp.PageInfo.Count = recCount; queryExp.PageInfo.PagingCookie = (pageNumber == 1) ? null : multiResponse.EntityCollection.PagingCookie; queryExp.PageInfo.PageNumber = pageNumber++; multiRequest = new RetrieveMultipleRequest(); multiRequest.Query = queryExp; multiResponse = (RetrieveMultipleResponse)service.Execute(multiRequest); entityCol.Entities.AddRange(multiResponse.EntityCollection.Entities); // if the record count is less than 5k no need to check for morerecords, just terminate if (recCount < 5000) { break; } }while (multiResponse.EntityCollection.MoreRecords); } catch { throw; } return(entityCol); }
private Entity GetContactDetail(Guid id, string[] columns) { ConditionExpression conditionExpression = new ConditionExpression(); conditionExpression.AttributeName = "contactid"; conditionExpression.Operator = ConditionOperator.Equal; conditionExpression.Values.Add((object)id); FilterExpression filterExpression = new FilterExpression(); filterExpression.Conditions.Add(conditionExpression); filterExpression.FilterOperator = LogicalOperator.And; ColumnSet columnSet = new ColumnSet(); foreach (string column in columns) { columnSet.AddColumn(column); } RetrieveMultipleResponse multipleResponse = (RetrieveMultipleResponse)this.service.Execute((OrganizationRequest) new RetrieveMultipleRequest() { Query = (QueryBase) new QueryExpression() { ColumnSet = columnSet, Criteria = filterExpression, EntityName = "contact" } }); if (multipleResponse.EntityCollection.Entities != null && multipleResponse.EntityCollection.Entities.Count > 0) { return(Enumerable.First <Entity>((IEnumerable <Entity>)multipleResponse.EntityCollection.Entities)); } else { return((Entity)null); } }
public static IEnumerable <DynamicEntity> GetByIdOrPrimaryAttribute(CrmService _crmService, MetadataService metadataService, string entityName, Guid id, string primaryAttributeValue, params string[] fields) { List <DynamicEntity> resultList = new List <DynamicEntity>(); DynamicEntity ret = GetById(_crmService, entityName, id); if (ret == null) { string primaryAttribute = MetadataUtility.RetrievePrimaryAttribute(metadataService, entityName); QueryExpression query = new QueryExpression(entityName) { ColumnSet = new ColumnSet(fields) }; ConditionExpression primaryAttributeExpression = new ConditionExpression(primaryAttribute.ToLower(), ConditionOperator.Equal, primaryAttributeValue); query.Criteria.Conditions.Add(primaryAttributeExpression); RetrieveMultipleRequest request = new RetrieveMultipleRequest() { Query = query, ReturnDynamicEntities = true }; RetrieveMultipleResponse response = (RetrieveMultipleResponse)_crmService.Execute(request); if (response.BusinessEntityCollection.BusinessEntities.Count > 0) { resultList.AddRange(response.BusinessEntityCollection.BusinessEntities.ConvertAll <DynamicEntity>(x => (DynamicEntity)x)); } } else { resultList.Add(ret); } return(resultList); }
private static Entity GetCurrencyDetail(Guid id, string[] Columns) { ConditionExpression conditionExpression = new ConditionExpression(); conditionExpression.AttributeName = "transactioncurrencyid"; conditionExpression.Operator = ConditionOperator.Equal; conditionExpression.Values.Add((object)id); FilterExpression filterExpression = new FilterExpression(); filterExpression.Conditions.Add(conditionExpression); filterExpression.FilterOperator = LogicalOperator.And; ColumnSet columnSet = new ColumnSet(); columnSet.AddColumns(Columns); RetrieveMultipleResponse multipleResponse = (RetrieveMultipleResponse)MSCRM.AdminOrgService.Execute((OrganizationRequest) new RetrieveMultipleRequest() { Query = new QueryExpression() { ColumnSet = columnSet, Criteria = filterExpression, EntityName = "transactioncurrency" } }); if (multipleResponse.EntityCollection.Entities != null && multipleResponse.EntityCollection.Entities.Count > 0) { return(Enumerable.First <Entity>((IEnumerable <Entity>)multipleResponse.EntityCollection.Entities)); } else { return((Entity)null); } }
private RetrieveMultipleResponse ExecuteInternal(RetrieveMultipleRequest request) { var response = new RetrieveMultipleResponse(); response.Results["EntityCollection"] = RetrieveMultiple(request.Query); return response; }
private OrganizationResponse CallOrganizationServiceRequestForExecuteRequest(OrganizationRequest request) { OrganizationResponse response = null; var associate = request as AssociateRequest; if (associate != null) { response = new AssociateResponse(); Associate(associate.Target.LogicalName, associate.Target.Id, associate.Relationship, associate.RelatedEntities); } var create = request as CreateRequest; if (create != null) { response = new CreateResponse(); response["id"] = Create(create.Target); } var delete = request as DeleteRequest; if (delete != null) { response = new DeleteResponse(); Delete(delete.Target.LogicalName, delete.Target.Id); } var disassociate = request as DisassociateRequest; if (disassociate != null) { response = new AssociateResponse(); Disassociate(disassociate.Target.LogicalName, disassociate.Target.Id, disassociate.Relationship, disassociate.RelatedEntities); } var retrieve = request as RetrieveRequest; if (retrieve != null) { response = new RetrieveResponse(); response["Entity"] = Retrieve(retrieve.Target.LogicalName, retrieve.Target.Id, retrieve.ColumnSet); } var retrieveMultiple = request as RetrieveMultipleRequest; if (retrieveMultiple != null) { response = new RetrieveMultipleResponse(); response["EntityCollection"] = RetrieveMultiple(retrieveMultiple.Query); } var update = request as UpdateRequest; if (update != null) { response = new UpdateResponse(); Update(update.Target); } return response; }
private void GetDataSet() { if (OnPageComplete != null) OnPageComplete(this); if (query is QueryExpression) { RetrieveMultipleRequest req = new RetrieveMultipleRequest(); ((QueryExpression)query).PageInfo = new PagingInfo(); ((QueryExpression)query).PageInfo.PageNumber = page++; ((QueryExpression)query).PageInfo.Count = rowsPerPage; req.Query = query; response = (RetrieveMultipleResponse)proxy.Execute(req); } if (query is FetchExpression) { string strXml = CreateXml(((FetchExpression)query).Query, null, page++, rowsPerPage); ((FetchExpression)query).Query = strXml; RetrieveMultipleRequest req = new RetrieveMultipleRequest(); req.Query = query; response = (RetrieveMultipleResponse)proxy.Execute(req); } }
public OrganizationResponse Execute(OrganizationRequest req, XrmFakedContext ctx) { var request = req as RetrieveMultipleRequest; if (request.Query is QueryExpression) { var linqQuery = XrmFakedContext.TranslateQueryExpressionToLinq(ctx, request.Query as QueryExpression); var list = linqQuery.ToList(); list.ForEach(e => PopulateFormattedValues(e)); var response = new RetrieveMultipleResponse { Results = new ParameterCollection { { "EntityCollection", new EntityCollection(list) } } }; return response; } else if (request.Query is FetchExpression) { var fetchXml = (request.Query as FetchExpression).Query; var queryExpression = XrmFakedContext.TranslateFetchXmlToQueryExpression(ctx, fetchXml); var linqQuery = XrmFakedContext.TranslateQueryExpressionToLinq(ctx, queryExpression); var list = linqQuery.ToList(); list.ForEach(e => PopulateFormattedValues(e)); var response = new RetrieveMultipleResponse { Results = new ParameterCollection { { "EntityCollection", new EntityCollection(list) } } }; return response; } else if (request.Query is QueryByAttribute) { //We instantiate a QueryExpression to be executed as we have the implementation done already var query = request.Query as QueryByAttribute; var qe = new QueryExpression(query.EntityName); qe.ColumnSet = query.ColumnSet; qe.Criteria = new FilterExpression(); for (var i = 0; i < query.Attributes.Count; i++) { qe.Criteria.AddCondition(new ConditionExpression(query.Attributes[i], ConditionOperator.Equal, query.Values[i])); } //QueryExpression now done... execute it! var linqQuery = XrmFakedContext.TranslateQueryExpressionToLinq(ctx, qe as QueryExpression); var list = linqQuery.ToList(); list.ForEach(e => PopulateFormattedValues(e)); var response = new RetrieveMultipleResponse { Results = new ParameterCollection { { "EntityCollection", new EntityCollection(list) } } }; return response; } else throw PullRequestException.NotImplementedOrganizationRequest(request.Query.GetType()); }
public OrganizationResponse Execute( OrganizationRequest request ) { if( request.GetType().Name == "RetrieveMultipleRequest" ) { RetrieveMultipleResponse response = new RetrieveMultipleResponse(); EntityCollection result = RetrieveMultiple( ( ( RetrieveMultipleRequest )request ).Query ); response.Results[ "EntityCollection" ] = result; return response; } else if(request.GetType().Name == "RetrieveRequest" ) { RetrieveResponse response = new RetrieveResponse(); RetrieveRequest retrieveRequest = ( RetrieveRequest )request; EntityReference target = retrieveRequest.Target; if( target.GetType().Name == "TargetRetrieveDynamic" ) { /* TargetRetrieveDynamic trd = ( TargetRetrieveDynamic )target; response.Entity = Retrieve( trd.EntityName, trd.EntityId, retrieveRequest.ColumnSet ); */ } // TODO: entity is readonly .. will have to set this with reflection // response.Entity = Retrieve( target.LogicalName, target.Id, retrieveRequest.ColumnSet ); else { // request sent using a specific strongly-typed business entity // rather than a DynamicEntity throw new NotImplementedException(); } return response; } else if( request.GetType().Name == "CreateRequest" ) { CreateResponse response = new CreateResponse(); Guid result = Create( ( ( CreateRequest )request ).Target ); response.Results[ "id" ] = result; return response; } else if( request.GetType().Name == "UpdateRequest" ) { UpdateResponse response = new UpdateResponse(); Update( ( ( UpdateRequest )request).Target ); return response; } else { throw new NotImplementedException(); } }
public object Execute( object request ) { if( request.GetType().Name == "RetrieveMultipleRequest" ) { RetrieveMultipleResponse response = new RetrieveMultipleResponse(); response.BusinessEntityCollection = RetrieveMultiple( ( ( RetrieveMultipleRequest )request ).Query ); return response; } else if(request.GetType().Name == "RetrieveRequest" ) { RetrieveResponse response = new RetrieveResponse(); RetrieveRequest retrieveRequest = ( RetrieveRequest )request; TargetRetrieve target = retrieveRequest.Target; if( target.GetType().Name == "TargetRetrieveDynamic" ) { TargetRetrieveDynamic trd = ( TargetRetrieveDynamic )target; response.BusinessEntity = Retrieve( trd.EntityName, trd.EntityId, retrieveRequest.ColumnSet ); } else { // request sent using a specific strongly-typed business entity // rather than a DynamicEntity throw new NotImplementedException(); } return response; } else { throw new NotImplementedException(); } }