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