/// <summary>
/// Pre-Validation method will default the values of contact preference fields
/// </summary>
private static void PreValidateContactCreate(IPluginExecutionContext context, IOrganizationService service)
{
Entity contactEntity = (Entity)context.InputParameters["Target"];
OptionSetValue doNotAllow = new OptionSetValue(1);
contactEntity.SetAttribute("donotemail", doNotAllow);
contactEntity.SetAttribute("donotpostalmail", doNotAllow);
contactEntity.SetAttribute("donotbulkemail", doNotAllow);
contactEntity.SetAttribute("donotfax", doNotAllow);
// Get a count of child phone call entities associated with this Contact
QueryExpression query = new QueryExpression();
query.EntityName = "phonecall";
query.ColumnSet = new ColumnSet(allColumns: true);
query.Criteria = new FilterExpression();
query.Criteria.AddCondition(new ConditionExpression("regardingobjectid", ConditionOperator.Equal, context.PrimaryEntityId));
RetrieveMultipleRequest request = new RetrieveMultipleRequest();
request.Query = query;
IEnumerable<Entity> results = ((RetrieveMultipleResponse)service.Execute(request)).EntityCollection.Entities;
if (results.Any())
{
// Do not default contact preference for phone if there are already some associated phone calls
// Why? Because! Testing!
contactEntity.SetAttribute("donotphone", doNotAllow);
}
}
public void When_executing_a_query_expression_with_2_filters_combined_with_an_or_filter_right_result_is_returned()
{
var context = new XrmFakedContext();
var contact1 = new Entity("contact") { Id = Guid.NewGuid() }; contact1["fullname"] = "Contact 1"; contact1["firstname"] = "First 1";
var contact2 = new Entity("contact") { Id = Guid.NewGuid() }; contact2["fullname"] = "Contact 2"; contact2["firstname"] = "First 2";
context.Initialize(new List<Entity>() { contact1, contact2 });
var qe = new QueryExpression() { EntityName = "contact" };
qe.ColumnSet = new ColumnSet(true);
var filter1 = new FilterExpression();
filter1.AddCondition(new ConditionExpression("fullname", ConditionOperator.Equal, "Contact 1"));
var filter2 = new FilterExpression();
filter2.AddCondition(new ConditionExpression("fullname", ConditionOperator.Equal, "Contact 2"));
qe.Criteria = new FilterExpression(LogicalOperator.Or);
qe.Criteria.AddFilter(filter1);
qe.Criteria.AddFilter(filter2);
var result = XrmFakedContext.TranslateQueryExpressionToLinq(context, qe).ToList();
Assert.True(result.Count == 2);
}
private static Guid FindPluginAssembly(OrganizationService service, string assemblyName)
{
var query = new QueryExpression
{
EntityName = "pluginassembly",
ColumnSet = null,
Criteria = new FilterExpression()
};
query.Criteria.AddCondition("name", ConditionOperator.Equal, assemblyName);
var request = new RetrieveMultipleRequest
{
Query = query
};
var response = (RetrieveMultipleResponse)service.Execute(request);
if (response.EntityCollection.Entities.Count == 1)
{
var id = response.EntityCollection[0].GetAttributeValue<Guid>("pluginassemblyid");
_logger.Log(LogLevel.Debug, () => string.Format("Found id {0} for assembly", id));
return id;
}
return Guid.Empty;
}
private void AssignAdminRole(IOrganizationService service, Guid id)
{
string adminRoleName = "System Administrator";
try
{
QueryExpression query = new QueryExpression
{
EntityName = "role",
ColumnSet = new ColumnSet("name"),
Criteria = new FilterExpression
{
Conditions =
{
new ConditionExpression
{
AttributeName = "name",
Operator = ConditionOperator.Equal,
Values = {adminRoleName}
}
}
}
};
EntityCollection roles = service.RetrieveMultiple(query);
EntityReferenceCollection entityRefCln = new EntityReferenceCollection();
foreach (Entity entity in roles.Entities)
{
entityRefCln.Add(entity.ToEntityReference());
}
service.Associate("team", id, new Relationship("teamroles_association"), entityRefCln);
}
catch (Exception ex)
{
}
}
/// <summary>
/// This method first connects to the Organization service. Afterwards, it
/// retrieves roles.
/// </summary>
/// <param name="serverConfig">Contains server connection information.</param>
/// <param name="promptforDelete">When True, the user is prompted to delete all
/// created entities.</param>
public void Run(ServerConnection.Configuration serverConfig, bool promptforDelete)
{
try
{
//<snippetRetrieveRolesForOrg1>
// Connect to the Organization service.
// The using statement assures that the service proxy is properly disposed.
using (_serviceProxy = new OrganizationServiceProxy(serverConfig.OrganizationUri, serverConfig.HomeRealmUri,serverConfig.Credentials, serverConfig.DeviceCredentials))
{
QueryExpression query = new QueryExpression
{
EntityName = Role.EntityLogicalName,
ColumnSet = new ColumnSet("name", "roleid")
};
EntityCollection entities = _serviceProxy.RetrieveMultiple(query);
// Write the name and ID of each role to the console.
foreach (Entity item in entities.Entities)
{
Role role = item.ToEntity<Role>();
Console.WriteLine("Name: {0}. Id: {1}", role.Name, role.Id);
}
}
//</snippetRetrieveRolesForOrg1>
}
// Catch any service fault exceptions that Microsoft Dynamics CRM throws.
catch (FaultException<Microsoft.Xrm.Sdk.OrganizationServiceFault>)
{
// You can handle an exception here or pass it back to the calling method.
throw;
}
}
public void FindGuidForObject(IOrganizationService myCRMWebservice)
{
var myQuery = new QueryExpression
{
EntityName = this.sCrmEntityName,
ColumnSet = new ColumnSet(this.sCrmEntityGuidFieldName),
Criteria = new FilterExpression
{
Conditions =
{
new ConditionExpression
{
AttributeName = this.sCrmFilterAttributeName,
Operator = ConditionOperator.Equal,
Values = {this.sCrmFilterAttributeValue}
}
}
}
};
DataCollection<Entity> accountResult = myCRMWebservice.RetrieveMultiple(myQuery).Entities;
if (accountResult.Count > 0)
this.crmGuidId = (Guid)accountResult[0][this.sCrmEntityGuidFieldName];
}
public List<SecureFieldInfo> LoadSecureFields()
{
var query = new QueryExpression("fieldpermission")
{
ColumnSet = new ColumnSet(true)
};
var fields = service.RetrieveMultiple(query).Entities.ToList();
var fieldsInfos = new List<SecureFieldInfo>();
foreach (var field in fields)
{
var fieldInfo =
fieldsInfos.FirstOrDefault(fi => fi.Entity == field.GetAttributeValue<string>("entityname")
&& fi.Attribute ==
field.GetAttributeValue<string>("attributelogicalname"));
if (fieldInfo == null)
{
fieldInfo = new SecureFieldInfo
{
Attribute = field.GetAttributeValue<string>("attributelogicalname"),
Entity = field.GetAttributeValue<string>("entityname"),
};
fieldsInfos.Add(fieldInfo);
}
fieldInfo.Fields.Add(field);
}
return fieldsInfos;
}
private EntityCollection RetrieveSolutions()
{
try
{
QueryExpression qe = new QueryExpression("solution");
qe.Distinct = true;
qe.ColumnSet = new ColumnSet(true);
qe.Criteria = new FilterExpression();
qe.Criteria.AddCondition(new ConditionExpression("ismanaged", ConditionOperator.Equal, false));
qe.Criteria.AddCondition(new ConditionExpression("isvisible", ConditionOperator.Equal, true));
qe.Criteria.AddCondition(new ConditionExpression("uniquename", ConditionOperator.NotEqual, "Default"));
return innerService.RetrieveMultiple(qe);
}
catch (Exception error)
{
if (error.InnerException != null && error.InnerException is FaultException)
{
throw new Exception("Error while retrieving solutions: " + (error.InnerException).Message);
}
else
{
throw new Exception("Error while retrieving solutions: " + error.Message);
}
}
}
private EntityCollection GetYelpAccounts()
{
CrmConnection connection = CrmConnection.Parse(_connection);
using (_orgService = new OrganizationService(connection))
{
var query = new QueryExpression
{
EntityName = "account",
ColumnSet = new ColumnSet("test9_yelpid"),
Criteria = new FilterExpression
{
Conditions =
{
new ConditionExpression
{
AttributeName = "test9_yelpid",
Operator = ConditionOperator.NotNull
}
}
}
};
return _orgService.RetrieveMultiple(query);
}
}
public async Task<bool> IsAuthenticated(PortalUser user)
{
string Url = ConfigurationManager.AppSettings["URL"].ToString();
string CrmConnectionString = string.Format("Url={0}; Username={1}; Password={2}",
Url, user.Username, user.Password);
ClientCredentials credential = new ClientCredentials();
credential.UserName.UserName = user.Username;
credential.UserName.Password = user.Password;
CrmConnection crmConnection = CrmConnection.Parse(CrmConnectionString);
crmConnection.ClientCredentials = credential;
OrganizationService service = new OrganizationService(crmConnection);
QueryExpression qe = new QueryExpression("systemuser");
qe.ColumnSet = new ColumnSet();
qe.ColumnSet.AddColumn("systemuserid");
qe.ColumnSet.AddColumn("fullname");
qe.Criteria = new FilterExpression();
qe.Criteria.AddCondition("domainname", ConditionOperator.Equal, user.Username);
EntityCollection collection = service.RetrieveMultiple(qe);
if (collection.Entities.Count == 0)
{
return false;
}
return true;
}
public List<Entity> GetAllFormsByTypeCode(int objectTypeCode)
{
var qe = new QueryExpression("systemform")
{
ColumnSet = new ColumnSet(new[] { "name", "formxml" }),
Criteria = new FilterExpression
{
Conditions =
{
new ConditionExpression("objecttypecode", ConditionOperator.Equal, objectTypeCode),
new ConditionExpression("type", ConditionOperator.In, new[] {2,7}),
new ConditionExpression("iscustomizable", ConditionOperator.Equal, true),
new ConditionExpression("formactivationstate", ConditionOperator.Equal, 1),
}
}
};
try
{
return Service.RetrieveMultiple(qe).Entities.ToList();
}
catch
{
qe.Criteria.Conditions.RemoveAt(qe.Criteria.Conditions.Count - 1);
return Service.RetrieveMultiple(qe).Entities.ToList();
}
}
public void getSecurityRoleGuidBySecurityRoleName(IOrganizationService securityRoleCrmWebservice)
{
var myQuery = new QueryExpression
{
EntityName = "role",
ColumnSet = new ColumnSet("roleid"),
Criteria = new FilterExpression
{
Conditions =
{
new ConditionExpression
{
AttributeName = "name",
Operator = ConditionOperator.Equal,
Values = {"roleName"}
}
}
}
};
//DataCollection<Entity> securityRoleResult = CrmWebservice.RetrieveMultiple(myQuery).Entities;
DataCollection<Entity> securityRoleResult = securityRoleCrmWebservice.RetrieveMultiple(myQuery).Entities;
if (securityRoleResult.Count > 0)
this.guidSecurityRoleId = (Guid)securityRoleResult[0]["roleid"];
}
public static EntityReference GetCompanyClassificationReferenceByName(this IOrganizationService service, string companyClassification)
{
Guard.ArgumentNotNullOrEmpty(companyClassification, "companyClassification");
if (companyClassification == "Uncategorized")
{
return null;
}
var productTypeNameCondition = ConditionExpressionHelper.CreateEqualsCondition("xv_name", companyClassification);
var filter = new FilterExpression();
filter.Conditions.Add(productTypeNameCondition);
var query = new QueryExpression(xv_firmenklassifizierung.EntityLogicalName);
query.Criteria.AddFilter(filter);
var productTypeEntity = service.RetrieveMultiple(query)
.Entities
.FirstOrDefault();
if (productTypeEntity == null)
{
throw new CrmEntityNotFoundException(string.Format("Company classification '{0}' was not found.", companyClassification));
}
return productTypeEntity.ToEntityReference();
}
public static EntityReference GetCompanyReferenceById(this IOrganizationService service, string companyName)
{
var compayNameCondition = ConditionExpressionHelper.CreateCompanyNameCondition(companyName);
var filter = new FilterExpression();
filter.Conditions.Add(compayNameCondition);
var query = new QueryExpression(Account.EntityLogicalName)
{
ColumnSet = new ColumnSet(true)
};
query.Criteria.AddFilter(filter);
var companies = service.RetrieveMultiple(query)
.Entities.ToList();
if (!companies.Any())
{
throw new CrmEntityNotFoundException(string.Format("Company '{0}' was not found.", companyName));
}
if (companies.Count > 1)
{
throw new CrmAmbiguousMatchException(string.Format("{0} companies found with name '{1}'.", companies.Count, companyName));
}
return companies.Single().ToEntityReference();
}
bool IsDegenerateQuery(QueryExpression query)
{
if (query == null)
return false;
var lastClause = query.Clauses.LastOrDefault();
return !(lastClause is QuerySelectClause || lastClause is QueryGroupClause);
}
public static EntityReference GetAccountReferenceByNameFuzzy(this IOrganizationService service, string companyName)
{
var name = CompanyNameHelper.RemoveCommonCompanySuffixes(companyName);
var nameCondition = ConditionExpressionHelper.CreatePublisherNameBeginsWithCondition(name);
var filter = new FilterExpression();
filter.Conditions.Add(nameCondition);
var query = new QueryExpression(Account.EntityLogicalName);
query.Criteria.AddFilter(filter);
var accounts = service.RetrieveMultiple(query).Entities;
if (accounts.Count() > 1)
{
throw new CrmAmbiguousMatchException(
string.Format("Found multiple fuzzy matches when searching for {0}. Fuzzy match search: {1}", companyName, name));
}
var account = accounts.FirstOrDefault();
if (account == null)
{
throw new CrmEntityNotFoundException("Account not found with name: " + companyName);
}
return new EntityReference(Account.EntityLogicalName, account.Id);
}
/// <summary>
/// Retrieves main forms for the specified entity
/// </summary>
/// <param name="logicalName">Entity logical name</param>
/// <param name="oService">Crm organization service</param>
/// <returns>Document containing all forms definition</returns>
public static IEnumerable<Entity> RetrieveEntityFormList(string logicalName, IOrganizationService oService)
{
var qe = new QueryExpression("systemform")
{
ColumnSet = new ColumnSet(true),
Criteria = new FilterExpression
{
Conditions =
{
new ConditionExpression("objecttypecode", ConditionOperator.Equal, logicalName),
new ConditionExpression("type", ConditionOperator.In, new[] {2,7}),
}
}
};
try
{
return oService.RetrieveMultiple(qe).Entities;
}
catch
{
qe.Criteria.Conditions.RemoveAt(qe.Criteria.Conditions.Count - 1);
return oService.RetrieveMultiple(qe).Entities;
}
}
public void When_ordering_by_money_fields_descending_expected_result_is_returned()
{
List<Entity> contactList = new List<Entity>();
Entity contact1 = new Entity("contact");
contact1.Id = Guid.NewGuid();
contact1.Attributes["firstname"] = "Fred";
contact1.Attributes["lastname"] = "Bloggs";
contact1.Attributes["new_somefield"] = new Money(12345); // (decimal)678910
Entity contact2 = new Entity("contact");
contact2.Id = Guid.NewGuid();
contact2.Attributes["firstname"] = "Jo";
contact2.Attributes["lastname"] = "Bloggs";
contact2.Attributes["new_somefield"] = new Money(678910); // (decimal)678910
contactList.Add(contact2);
contactList.Add(contact1);
var context = new XrmFakedContext();
context.Initialize(contactList);
var service = context.GetFakedOrganizationService();
QueryExpression qry = new QueryExpression("contact");
qry.ColumnSet = new ColumnSet(true);
qry.AddOrder("new_somefield", OrderType.Descending);
var results = service.RetrieveMultiple(qry);
var firstResultValue = results.Entities[0]["new_somefield"] as Money;
Assert.Equal(678910M, firstResultValue.Value);
}
/// <summary>
/// Получаем набор неуправляемых решений для организации
/// </summary>
/// <param name="service">сервис</param>
/// <returns></returns>
public static EntityCollection GetSolutions(IOrganizationService service)
{
var solutions = new EntityCollection();
QueryExpression q = new QueryExpression("solution");
//Берем только неуправляемые решения
q.Criteria.AddCondition(new ConditionExpression("ismanaged", ConditionOperator.Equal, false));
//не берем специальные CRMные солюшены
q.Criteria.AddCondition(new ConditionExpression("friendlyname", ConditionOperator.NotEqual, "Active Solution"));
q.Criteria.AddCondition(new ConditionExpression("friendlyname", ConditionOperator.NotEqual, "Default Solution"));
q.Criteria.AddCondition(new ConditionExpression("friendlyname", ConditionOperator.NotEqual, "Basic Solution"));
q.Orders.Add(new OrderExpression("createdon", OrderType.Descending));
q.ColumnSet = new ColumnSet("friendlyname", "uniquename", "version", "installedon");
q.PageInfo = new PagingInfo()
{
Count = 200,
PageNumber = 1
};
EntityCollection ec;
do
{
ec = service.RetrieveMultiple(q);
solutions.Entities.AddRange(ec.Entities);
q.PageInfo.PageNumber++;
q.PageInfo.PagingCookie = ec.PagingCookie;
} while (ec.MoreRecords);
return solutions;
}
public void Execute(IServiceProvider serviceProvider)
{
System.Diagnostics.Debugger.Launch();
var localContext = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));
var organizationContext = (IOrganizationService)serviceProvider.GetService(typeof(IOrganizationService));
var cases = string.Empty;
var query = new QueryExpression() { EntityName = "oltv_insurance" };
query.ColumnSet = new ColumnSet("oltv_insuranceid", "oltv_name", "oltv_policy");
query.Criteria.AddCondition("ownerid", ConditionOperator.Equal, new EntityReference("user", localContext.UserId));
var insurances = organizationContext.RetrieveMultiple(query);
query = new QueryExpression() { EntityName = "case" };
foreach (var item in insurances.Entities)
{
query.Criteria = new FilterExpression();
query.Criteria.AddCondition("oltv_insurance",
ConditionOperator.Equal,
new EntityReference("oltv_insurance", (Guid) item["oltv_insuranceid"]));
cases = String.Concat(
cases,
organizationContext.RetrieveMultiple(query).TotalRecordCount,
";");
}
localContext.OutputParameters["Insurances"] = insurances;
localContext.OutputParameters["Cases"] = cases;
}
/// <summary>
/// Runs the given query against the OdataLib's uri translator and compares the results against an inmemorycontext
/// </summary>
/// <param name="expression">The query expression to run against the Uri parser</param>
public void Verify(QueryExpression expression)
{
// 1. test : take the expression and construct the OData URI
// /Customers?$top=1
string queryFragment = null;
queryFragment = this.UriQueryVisitor.ComputeUri(expression);
Uri serviceBaseUri = new Uri("http://localhost:9000/");
// http://localhost:9000/Customers?$top=1
Uri queryUri = new Uri(serviceBaseUri, queryFragment);
this.Logger.WriteLine(LogLevel.Info, "Running Uri :{0}", queryUri.OriginalString);
EntityModelSchema schema = Workspace.ConceptualModel;
// Generate an EDM model based on the EntityModelSchema to use in the UriParser
IEdmModel model = this.DataServiceProviderFactory.CreateMetadataProvider(schema);
// Generate an IDSQP based on the EntityModelSchema to use in the Expression Translator
var queryResolver = this.DataServiceProviderFactory.CreateQueryProvider(schema);
// 2. product : take the URI , run it through the parser and get the Linq expression
ODataUriParser parser = new ODataUriParser(model, serviceBaseUri, queryUri);
var query = parser.ParseUri();
var result = query.Path;
// Get the expected Results
QueryValue expectedResults = null;
expectedResults = this.Evaluator.Evaluate(expression);
}
public Boolean generateRiskFactorsForTemplate(EntityReference riskTemplate, Guid fundingCaseRiskAssessmentId)
{
try
{
//
QueryExpression qe = new QueryExpression("gcbase_risktemplateriskfactor");
qe.Criteria.AddCondition("gcbase_risktemplate", ConditionOperator.Equal, riskTemplate.Id);
qe.ColumnSet.AddColumns("gcbase_name", "gcbase_riskfactor", "gcbase_risktemplate");
var riskFactors = _service.RetrieveMultiple(qe).Entities;
foreach (var item in riskFactors)
{
Entity riskFactorValue = new Entity("gcbase_riskfactorvalue");
riskFactorValue["gcbase_name"] = item.GetAttributeValue<EntityReference>("gcbase_riskfactor").Name;
riskFactorValue["gcbase_riskfactor"] = new EntityReference("gcbase_riskfactor", item.GetAttributeValue<EntityReference>("gcbase_riskfactor").Id);
riskFactorValue["gcbase_risktemplateriskfactor"] = new EntityReference("gcbase_risktemplateriskfactor", item.Id);
riskFactorValue["gcbase_fundingcaseriskassessment"] = new EntityReference("gcbase_fundingcaseriskassessment", fundingCaseRiskAssessmentId);
_service.Create(riskFactorValue);
}
return true;
}
catch
{
return false;
}
}
private void LoadCT1()
{
cmbCT1.Items.Clear();
try
{
QueryExpression _query = new QueryExpression("helpdesk_ticketsubjectlevel1");
_query.ColumnSet = new ColumnSet("helpdesk_name", "helpdesk_ticketsubjectlevel1id");
EntityCollection _CT1List = crmService.RetrieveMultiple(_query);
if (_CT1List != null && _CT1List.Entities.Count > 0)
{
for (int i = 0; i < _CT1List.Entities.Count; i++)
{
ListItem _item = new ListItem(_CT1List.Entities[i]["helpdesk_name"].ToString(), _CT1List.Entities[i]["helpdesk_ticketsubjectlevel1id"].ToString());
cmbCT1.Items.Add(_item);
}
}
}
catch (FaultException<OrganizationServiceFault> ex)
{
string strError = ex.Message.Replace("'", "");
string scriptstring = "alert('" + strError + "');";
ScriptManager.RegisterStartupScript(this, this.GetType(), "alertscript", scriptstring, true);
//MessageBox.Show(ex.Message);
}
catch (Exception ex)
{
string strError = ex.Message.Replace("'", "");
string scriptstring = "alert('" + strError + "');";
ScriptManager.RegisterStartupScript(this, this.GetType(), "alertscript", scriptstring, true);
//MessageBox.Show(ex.Message);
}
}
public void When_ordering_by_datetime_fields_expected_result_is_returned()
{
List<Entity> contactList = new List<Entity>();
var now = DateTime.UtcNow;
Entity contact1 = new Entity("contact");
contact1.Id = Guid.NewGuid();
contact1.Attributes["firstname"] = "Fred";
contact1.Attributes["new_orderbyfield"] = now;
Entity contact2 = new Entity("contact");
contact2.Id = Guid.NewGuid();
contact2.Attributes["firstname"] = "Jo";
contact2.Attributes["new_orderbyfield"] = now.AddDays(1);
contactList.Add(contact2);
contactList.Add(contact1);
var context = new XrmFakedContext();
context.Initialize(contactList);
var service = context.GetFakedOrganizationService();
QueryExpression qry = new QueryExpression("contact");
qry.ColumnSet = new ColumnSet(true);
qry.AddOrder("new_orderbyfield", OrderType.Ascending);
var results = service.RetrieveMultiple(qry);
var firstResultValue = (DateTime)results.Entities[0]["new_orderbyfield"];
Assert.Equal(now, firstResultValue);
}
/// <summary>
/// Verifies the query generated by the PHPCodeGenerator
/// </summary>
/// <param name="expression">The expression used to verify the query</param>
public void Verify(QueryExpression expression)
{
ExceptionUtilities.CheckArgumentNotNull(expression, "expression");
ExceptionUtilities.CheckAllRequiredDependencies(this);
if (this.DataServicePhpFileName == null)
{
this.DataServicePhpFileName = this.PhpWorkingDirectory + "\\" + this.Service.ConceptualModel.EntityContainers.First().Name + ".php";
}
if (!File.Exists(this.DataServicePhpFileName))
{
string commandToGenerateConatinerClass = string.Format(CultureInfo.InvariantCulture, "{0}{1} /ups=no", "PHPDataSvcUtil.php /uri=", this.Service.ServiceUri.AbsoluteUri);
this.CodeExecutor.ExecuteCode(commandToGenerateConatinerClass);
}
var fileName = string.Format(CultureInfo.InvariantCulture, "{0}{1}.php", DateTime.Now.Day.ToString(CultureInfo.InvariantCulture), DateTime.Now.TimeOfDay.ToString().Replace(':', '.'));
string phpCode = this.CodeGenerator.GenerateCode(expression);
#if !SILVERLIGHT
File.WriteAllText(string.Format(CultureInfo.InvariantCulture, "{0}\\{1}", this.PhpWorkingDirectory, fileName), phpCode);
#endif
string result = this.CodeExecutor.ExecuteCode(fileName);
if (!result.Equals("Passed"))
{
Logger.WriteLine(LogLevel.Verbose, CultureInfo.InvariantCulture, "Execution of the Php query failed");
throw new DataComparisonException(string.Format(CultureInfo.InvariantCulture, "The Php query failed\n Generated Php Code :\n{0}\n Error : {1}", phpCode, result));
}
}
public static string GetCSharpQueryExpression(QueryExpression QEx)
{
varList.Clear();
var code = new StringBuilder();
var qename = GetVarName("QE" + QEx.EntityName);
code.AppendLine("// Instantiate QueryExpression " + qename);
code.AppendLine("var " + qename + " = new QueryExpression(\"" + QEx.EntityName + "\");");
if (QEx.NoLock)
{
code.AppendLine(qename + ".NoLock = true;");
}
if (QEx.Distinct)
{
code.AppendLine(qename + ".Distinct = true;");
}
if (QEx.TopCount != null)
{
code.AppendLine(qename + ".TopCount = " + QEx.TopCount.ToString() + ";");
}
code.Append(GetColumns(QEx.ColumnSet, qename + ".ColumnSet"));
foreach (var order in QEx.Orders)
{
code.AppendLine(qename + ".AddOrder(\"" + order.AttributeName + "\", OrderType." + order.OrderType.ToString() + ");");
}
code.Append(GetFilter(QEx.Criteria, qename + ".Criteria"));
foreach (var link in QEx.LinkEntities)
{
code.Append(GetLinkEntity(link, qename));
}
return code.ToString();
}
/// <summary>
/// This method first connects to the Organization service. Afterwards,
/// it creates a system user account with a given active directory account.
/// Note: Creating a user is only supported in an on-premises/active directory environment.
/// </summary>
/// <param name="serverConfig">Contains server connection information.</param>
/// <param name="promptforDelete">When True, the user will be prompted to delete all
/// created entities.</param>
public void Run(ServerConnection.Configuration serverConfig, bool promptforDelete)
{
try
{
//<snippetCreateAUser1>
// Connect to the Organization service.
// The using statement assures that the service proxy is properly disposed.
using (_serviceProxy = new OrganizationServiceProxy(serverConfig.OrganizationUri, serverConfig.HomeRealmUri,
serverConfig.Credentials, serverConfig.DeviceCredentials))
{
_serviceProxy.EnableProxyTypes();
CreateRequiredRecords();
// Retrieve the default business unit needed to create the user.
QueryExpression businessUnitQuery = new QueryExpression
{
EntityName = BusinessUnit.EntityLogicalName,
ColumnSet = new ColumnSet("businessunitid"),
Criteria =
{
Conditions =
{
new ConditionExpression("parentbusinessunitid",
ConditionOperator.Null)
}
}
};
BusinessUnit defaultBusinessUnit = _serviceProxy.RetrieveMultiple(
businessUnitQuery).Entities[0].ToEntity<BusinessUnit>();
//Create a new system user.
SystemUser user = new SystemUser
{
DomainName = _domain + _userName,
FirstName = _firstName,
LastName = _lastName,
BusinessUnitId = new EntityReference
{
LogicalName = BusinessUnit.EntityLogicalName,
Name = BusinessUnit.EntityLogicalName,
Id = defaultBusinessUnit.Id
}
};
Guid userId = _serviceProxy.Create(user);
Console.WriteLine("Created a system user {0} for '{1}, {2}'", userId, _lastName, _firstName);
}
//</snippetCreateAUser1>
}
// Catch any service fault exceptions that Microsoft Dynamics CRM throws.
catch (FaultException<Microsoft.Xrm.Sdk.OrganizationServiceFault>)
{
// You can handle an exception here or pass it back to the calling method.
throw;
}
}
private void InitData(Order order)
{
if (this.orderEntity.OrderStatus == EntityAdapter.EditStatus.New)
{
string typeName = orderEntity.OrderTypeName;
this.orderEntity = new OrderEntity(orderEntity.OrderType);
this.orderEntity.OrderTypeName = typeName;
EmplyeerData itemOwner = DataCore.CurrentUser.CurrentPostInfo.Copy();
this.orderEntity.ReferencedData.Dictionary = order.ReferenceDataInfoList.Dictionary;
this.orderEntity.ReferencedData["Entity.OWNERID"] = itemOwner;
this.orderEntity.ReferencedData["Entity.OWNERDEPARTMENTID"] = itemOwner.DepartMent;
this.orderEntity.ReferencedData["Entity.OWNERCOMPANYID"] = itemOwner.Company;
this.orderEntity.SetValue("Entity.CREATEUSERID", DataCore.CurrentUser.UserID);
this.orderEntity.SetValue("Entity.UPDATEUSERID", DataCore.CurrentUser.UserID);
this.orderEntity.SetValue("Entity.CREATEDATE", DateTime.Now);
this.orderEntity.SetValue("Entity.CREATEDEPARTMENTID", DataCore.CurrentUser.CurrentPostInfo.DepartMent.Value);
this.orderEntity.SetValue("Entity.CREATECOMPANYID", DataCore.CurrentUser.CurrentPostInfo.Company.Value);
this.orderEntity.SetValue("Entity.CREATEDEPARTMENTNAME", DataCore.CurrentUser.CurrentPostInfo.DepartMent.Text);
this.orderEntity.SetValue("Entity.CREATECOMPANYNAME", DataCore.CurrentUser.CurrentPostInfo.Company.Text);
//暂时
this.orderEntity.SetValue("Entity.OWNERPOSTID", DataCore.CurrentUser.CurrentPostInfo.Post.Value);
this.orderEntity.SetValue("Entity.CREATEPOSTID", DataCore.CurrentUser.CurrentPostInfo.Post.Value);
this.orderEntity.SetValue("Entity.CREATEPOSTNAME", DataCore.CurrentUser.CurrentPostInfo.Post.Text);
this.orderEntity.SetValue("Entity.OWNERPOSTNAME", DataCore.CurrentUser.CurrentPostInfo.Post.Text);
}
else if (this.orderEntity.OrderStatus == EntityAdapter.EditStatus.Edit)
{
QueryExpression q = new QueryExpression();
q.PropertyName = orderEntity.Entity.EntityKey.EntityContainerName;
q.PropertyValue = orderEntity.OrderID;
q.Operation = QueryExpression.Operations.Equal;
//orderEntity.Entity.EntityKey.EntityContainerName
this.orderEntity = OrderSource.GetOrder(q)[0];
ObjectList<ReferencedDataInfo> list = order.ReferenceDataInfoList;
for (int i = 0; i < order.ReferenceDataInfoList.Count; i++)
{
object key = this.orderEntity.GetValue(list[i].PropertyName);
ITextValueItem item = null;
if (key != null)
{
item = DataCore.FindRefData(list[i].ReferencedType, key.ToString());
}
orderEntity.ReferencedData.Add(list[i].PropertyName, item);
}
}
}
public static CrmQuery Select( ColumnSet in_columns ) {
#endif
QueryExpression query = new QueryExpression();
query.ColumnSet = in_columns;
CrmQuery dsl = new CrmQuery();
dsl.m_query = query;
return dsl;
}
public FilterSpec(QueryExpression queryExpression , FilterSpec parentFilter = null)
: this(parentFilter)
{
if (queryExpression == null)
return;
Expressions.Add(queryExpression);
}
/// <summary>
/// Create, Retrieve, Update and Delete an e-mail attachment.
/// <param name="serverConfig">Contains server connection information.</param>
/// <param name="promptforDelete">When True, the user will be prompted to delete all
/// created entities.</param>
/// </summary>
public void Run(ServerConnection.Configuration serverConfig, bool promptForDelete)
{
try
{
// Connect to the Organization service.
// The using statement assures that the service proxy will be properly disposed.
using (_serviceProxy = new OrganizationServiceProxy(serverConfig.OrganizationUri, serverConfig.HomeRealmUri, serverConfig.Credentials, serverConfig.DeviceCredentials))
{
// This statement is required to enable early-bound type support.
_serviceProxy.EnableProxyTypes();
CreateRequiredRecords();
//<snippetCRUDEmailAttachments1>
// Create three e-mail attachments
for (int i = 0; i < 3; i++)
{
ActivityMimeAttachment _sampleAttachment = new ActivityMimeAttachment
{
ObjectId = new EntityReference(Email.EntityLogicalName, _emailId),
ObjectTypeCode = Email.EntityLogicalName,
Subject = String.Format("Sample Attachment {0}", i),
Body = System.Convert.ToBase64String(
new ASCIIEncoding().GetBytes("Example Attachment")),
FileName = String.Format("ExampleAttachment{0}.txt", i)
};
_emailAttachmentId[i] = _serviceProxy.Create(_sampleAttachment);
}
Console.WriteLine("Created three e-mail attachments for the e-mail activity.");
// Retrieve an attachment including its id, subject, filename and body.
ActivityMimeAttachment _singleAttachment =
(ActivityMimeAttachment)_serviceProxy.Retrieve(
ActivityMimeAttachment.EntityLogicalName,
_emailAttachmentId[0],
new ColumnSet("activitymimeattachmentid",
"subject",
"filename",
"body"));
Console.WriteLine("Retrieved an email attachment, {0}.", _singleAttachment.FileName);
// Update attachment
_singleAttachment.FileName = "ExampleAttachmentUpdated.txt";
_serviceProxy.Update(_singleAttachment);
Console.WriteLine("Updated the retrieved e-mail attachment to {0}.", _singleAttachment.FileName);
// Retrieve all attachments associated with the email activity.
QueryExpression _attachmentQuery = new QueryExpression
{
EntityName = ActivityMimeAttachment.EntityLogicalName,
ColumnSet = new ColumnSet("activitymimeattachmentid"),
Criteria = new FilterExpression
{
Conditions =
{
new ConditionExpression
{
AttributeName = "objectid",
Operator = ConditionOperator.Equal,
Values = { _emailId }
},
new ConditionExpression
{
AttributeName = "objecttypecode",
Operator = ConditionOperator.Equal,
Values = { Email.EntityLogicalName }
}
}
}
};
EntityCollection results = _serviceProxy.RetrieveMultiple(
_attachmentQuery);
Console.WriteLine("Retrieved all the e-mail attachments.");
//</snippetCRUDEmailAttachments1>
DeleteRequiredRecords(promptForDelete);
}
}
// Catch any service fault exceptions that Microsoft Dynamics CRM throws.
catch (FaultException <Microsoft.Xrm.Sdk.OrganizationServiceFault> )
{
// You can handle an exception here or pass it back to the calling method.
throw;
}
}
public static LinkEntity AddLink <TFrom, TTo>(this QueryExpression query,
Expression <Func <TFrom, object> > fromAttribute,
Expression <Func <TTo, object> > toAttribute)
where TFrom : Entity
where TTo : Entity =>
query.AddLink(Name <TTo>(), Name(fromAttribute), Name(toAttribute));
protected override void Execute(CodeActivityContext context)
{
try
{
// Get the context service.
IWorkflowContext Icontext = context.GetExtension <IWorkflowContext>();
IOrganizationServiceFactory serviceFactory = context.GetExtension <IOrganizationServiceFactory>();
// Use the context service to create an instance of IOrganizationService.
IOrganizationService service = serviceFactory.CreateOrganizationService(Icontext.InitiatingUserId);
//get input fields
var birthDate = Birthdate.Get(context) == new DateTime(0001, 01, 01) ? new DateTime(1753, 01, 01) : Birthdate.Get(context);
var firstName = Firstname.Get(context);
var lastName = Lastname.Get(context);
var userName = Username.Get(context) == null ? "" : Username.Get(context);
// made in fetchXML builder
// Instantiate QueryExpression QEcontact
var QEcontact = new QueryExpression("contact");
// Add columns to QEcontact.ColumnSet
QEcontact.ColumnSet.AddColumns("fullname", "firstname", "lastname", "birthdate", "sdu_brugernavn", "sdu_domne", "emailaddress1", "address1_city", "jobtitle", "sdu_crmomkostningssted", "sdu_brugernavn", "address1_line1");
// Define filter QEcontact.Criteria // all must match birthdate + sdu_crmudlb + opdateret fra fim
var QEcontact_Criteria = new FilterExpression();
QEcontact.Criteria.AddFilter(QEcontact_Criteria);
// Define filter QEcontact_Criteria // either match on username, or firstname + lastname
QEcontact_Criteria.FilterOperator = LogicalOperator.Or;
QEcontact_Criteria.AddCondition("sdu_brugernavn", ConditionOperator.Equal, userName);
var QEcontact_Criteria_name = new FilterExpression();
QEcontact_Criteria.AddFilter(QEcontact_Criteria_name);
// Define filter QEcontact_Criteria_name_birthdate
QEcontact_Criteria_name.AddCondition("firstname", ConditionOperator.Like, "%" + firstName + "%");
QEcontact_Criteria_name.AddCondition("lastname", ConditionOperator.Like, "%" + lastName + "%");
QEcontact_Criteria_name.AddCondition("birthdate", ConditionOperator.On, birthDate);
var QEcontact_Criteria_state = new FilterExpression();
QEcontact.Criteria.AddFilter(QEcontact_Criteria_state);
// define filter QEcontact_Criteria_dates
QEcontact_Criteria_state.AddCondition("statecode", ConditionOperator.Equal, RecordStatus.Get(context) == false ? 1 : 0); // kontoen er inaktiv
QEcontact_Criteria_state.AddCondition("sdu_crmudlb", ConditionOperator.OnOrAfter, DateTime.Today.AddMonths(ExpirationDateLimit.Get(context) * -1)); // CRM udløb er maksimalt 13 måneder gammelt
QEcontact_Criteria_state.AddCondition("sdu_crmudlb", ConditionOperator.OnOrBefore, DateTime.Today.AddDays(-1)); // CRM er igår eller før
QEcontact_Criteria_state.AddCondition("jobtitle", ConditionOperator.NotLike, "%Studentermedhjælp%");
//find records
var queryResult = service.RetrieveMultiple(QEcontact);
if (queryResult.Entities.Count == 1)
{
foreach (var record in queryResult.Entities)
{
// fullname
FullnameOutput.Set(context, record.GetAttributeValue <string>("fullname"));
// contactid
ContactID.Set(context, record.GetAttributeValue <Guid>("contactid").ToString());
// omkostningssted
var omkStedIdLocal = SearchForRecord(service, "sdu_brugeradmomksted",
new KeyValuePair <string, string>("sdu_omksted", record.GetAttributeValue <EntityReference>("sdu_crmomkostningssted").Id.ToString()),
new KeyValuePair <string, string>("", ""),
"sdu_brugeradmomkstedid");
OmkStedId.Set(context, omkStedIdLocal);
// domæne
String[] seperator_domaene = { "_" };
if (omkStedIdLocal != "")
{
Domaene.Set(context, SearchForRecord(service,
"sdu_domner",
new KeyValuePair <string, string>("sdu_brugeradmomksted", omkStedIdLocal.Split(seperator_domaene, StringSplitOptions.RemoveEmptyEntries).GetValue(0).ToString()),
new KeyValuePair <string, string>("sdu_name", record.GetAttributeValue <string>("sdu_domne")),
"sdu_domnerid"));
// email domæne
String[] seperator_emailDomaene = { "@" };
var emailDomainFromContact = "@" + record.GetAttributeValue <string>("emailaddress1").Split(seperator_emailDomaene, StringSplitOptions.RemoveEmptyEntries).GetValue(1).ToString();
EmailDomaene.Set(context, SearchForRecord(service,
"sdu_emaildomne",
new KeyValuePair <string, string>("sdu_brugeradmomksted", omkStedIdLocal.Split(seperator_domaene, StringSplitOptions.RemoveEmptyEntries).GetValue(0).ToString()),
new KeyValuePair <string, string>("sdu_name", emailDomainFromContact.Replace(" ", "")), // remove whitespaces
"sdu_emaildomneid"));
}
else
{
// set output parameters to empty strings, if no omk sted
Domaene.Set(context, "");
EmailDomaene.Set(context, "");
}
// lokation + arbejdsadresse
var LokationOptionSetValue = "";
switch (record.GetAttributeValue <string>("address1_city"))
{
case "Odense":
LokationOptionSetValue = "100000000";
break;
case "Odense M":
LokationOptionSetValue = "100000000";
break;
case "Odense C":
LokationOptionSetValue = "100000000";
break;
case "Sønderborg":
LokationOptionSetValue = "100000001";
break;
case "Esbjerg":
LokationOptionSetValue = "100000002";
break;
case "Slagelse":
LokationOptionSetValue = "100000003";
break;
case "Kolding":
LokationOptionSetValue = "100000004";
break;
default:
break;
}
var workAddress = record.GetAttributeValue <string>("address1_line1") == null ? "" : record.GetAttributeValue <string>("address1_line1");
if (workAddress.Contains("Campusvej"))
{
LokationOptionSetValue = LokationOptionSetValue + "_" + "100000000";
}
else if (workAddress.Contains("J.B. Winsløws Vej"))
{
LokationOptionSetValue = LokationOptionSetValue + "_" + "100000001";
}
Lokation.Set(context, LokationOptionSetValue);
// stillingsbetegnelse
StillingsBetegnelse.Set(context, SearchForRecord(service,
"sdu_stikogruppe",
new KeyValuePair <string, string>("sdu_name", record.GetAttributeValue <string>("jobtitle") == null ? "" : record.GetAttributeValue <string>("jobtitle")),
new KeyValuePair <string, string>("", ""),
"sdu_stikogruppeid"));
// fødselsdato
BirthDateOutput.Set(context, record.GetAttributeValue <DateTime>("birthdate") < new DateTime(1900, 01, 01) ? DateTime.Now : record.GetAttributeValue <DateTime>("birthdate"));
// brugernavn
UsernameOutput.Set(context, record.GetAttributeValue <string>("sdu_brugernavn"));
}
}
else
{
FullnameOutput.Set(context, "");
ContactID.Set(context, "");
OmkStedId.Set(context, "");
Domaene.Set(context, "");
EmailDomaene.Set(context, "");
Lokation.Set(context, "");
StillingsBetegnelse.Set(context, "");
BirthDateOutput.Set(context, DateTime.Now);
UsernameOutput.Set(context, "");
}
}
catch (Exception ex)
{
throw (ex);
}
}
public RedILNode VisitQueryExpression(QueryExpression queryExpression, State data)
{
throw new System.NotImplementedException();
}
/* public async Task<List<DiagnosticCode>> getDiagnosticCodes(string diagnosticCodeId, string diagnosticCodeName, string practiceId)
* {
* List<DiagnosticCode> DCode = new List<DiagnosticCode>();
* QueryExpression query = new QueryExpression(xrm.mzk_concept.EntityLogicalName);
* FilterExpression filter = query.Criteria.AddFilter(LogicalOperator.And);
* if (!string.IsNullOrEmpty(diagnosticCodeId))
* {
* filter.AddCondition("mzk_conceptid", ConditionOperator.Equal, diagnosticCodeId);
* }
* if (!string.IsNullOrEmpty(diagnosticCodeName))
* {
* filter.AddCondition("mzk_conceptname", ConditionOperator.Equal, diagnosticCodeName);
* }
* query.ColumnSet = new Microsoft.Xrm.Sdk.Query.ColumnSet("mzk_conceptid", "mzk_conceptname");
* SoapEntityRepository entityRepository = SoapEntityRepository.GetService();
* EntityCollection entitycollection = entityRepository.GetEntityCollection(query);
*
* foreach (Entity entity in entitycollection.Entities)
* {
* DiagnosticCode code = new DiagnosticCode();
* if (entity.Attributes.Contains("mzk_conceptid"))
* {
* code.codeId = entity["mzk_conceptid"].ToString();
* }
* if (entity.Attributes.Contains("mzk_conceptname"))
* {
* code.codeName = entity["mzk_conceptname"].ToString();
* }
* DCode.Add(code);
* }
*
* return DCode;
*
* }*/
public async Task <List <Physician> > getPhysicians(string practiceId)
{
List <Physician> Physicians = new List <Physician>();
//Physician model = new Physician();
//Physician model = new Physician();
QueryExpression query = new QueryExpression(xrm.mzk_clinicphysician.EntityLogicalName);
query.Criteria.AddCondition("mzk_clinic", ConditionOperator.Equal, new Guid(practiceId));
//query.ColumnSet = new Microsoft.Xrm.Sdk.Query.ColumnSet(false);
LinkEntity link1 = new LinkEntity(xrm.mzk_clinicphysician.EntityLogicalName, xrm.BookableResource.EntityLogicalName, "mzk_physician", "bookableresourceid", JoinOperator.Inner)
{
Columns = new Microsoft.Xrm.Sdk.Query.ColumnSet("bookableresourceid", "name", "mzk_npinumber", "msdyn_primaryemail", "mzk_phone"),
EntityAlias = "ContactBook",
};
query.LinkEntities.Add(link1);
/* LinkEntity Link1 = new LinkEntity(xrm.Account.EntityLogicalName, xrm.mzk_clinicphysician.EntityLogicalName, "territoryid", "mzk_clinicphysicianid", JoinOperator.Inner)
* {
*
* };*/
//query.ColumnSet = new Microsoft.Xrm.Sdk.Query.ColumnSet("bookableresourceid", "name", "mzk_npinumber", "msdyn_primaryemail", "mzk_phone");
SoapEntityRepository entityRepository = SoapEntityRepository.GetService();
EntityCollection entitycollection = entityRepository.GetEntityCollection(query);
foreach (Entity entity in entitycollection.Entities)
{
Physician model = new Physician();
if (entity.Attributes.Contains("ContactBook.bookableresourceid"))
{
model.physicianId = ((AliasedValue)entity["ContactBook.bookableresourceid"]).Value.ToString();
}
if (entity.Attributes.Contains("ContactBook.name"))
{
string[] splitname = (((AliasedValue)entity["ContactBook.name"]).Value.ToString()).Split(new char[0]);
if (splitname.Length >= 3)
{
for (int i = 3; i < splitname.Length; i++)
{
splitname[2] += " " + splitname[i];
}
char[] middleinitial = splitname[1].ToCharArray();
model.firstName = splitname[0]; //((AliasedValue)entity["ContactBook.name"]).Value.ToString(); //
model.middleInitial = middleinitial[0].ToString(); //entity["name"].ToString();
model.lastName = splitname[2];
}
else if (splitname.Length == 2)
{
model.firstName = splitname[0];
model.lastName = splitname[1];
}
else
{
model.firstName = ((AliasedValue)entity["ContactBook.name"]).Value.ToString();
}
}
if (entity.Attributes.Contains("ContactBook.mzk_npinumber"))
{
model.NPI = ((AliasedValue)entity["ContactBook.mzk_npinumber"]).Value.ToString();
}
if (entity.Attributes.Contains("ContactBook.msdyn_primaryemail"))
{
model.email = ((AliasedValue)entity["ContactBook.msdyn_primaryemail"]).Value.ToString();
}
if (entity.Attributes.Contains("ContactBook.mzk_phone"))
{
model.phone = ((AliasedValue)entity["ContactBook.mzk_phone"]).Value.ToString();
}
Physicians.Add(model);
}
return(Physicians);
/*List<Physician> Physicians = new List<Physician>();
* Physician physician = new Physician();
* List<PhysicianType> pTypes = new List<PhysicianType>();
* PhysicianType pType = new PhysicianType();
* pTypes.Add(pType);
* physician.physicianTypes = pTypes;
* Physicians.Add(physician);
* return Physicians;*/
}
/// <summary>
/// This method creates any entity records that this sample requires.
/// Creates the dashboard.
/// </summary>
public void CreateRequiredRecords()
{
//Grab the default public view for opportunities.
QueryExpression mySavedQuery = new QueryExpression
{
ColumnSet = new ColumnSet("savedqueryid"),
EntityName = SavedQuery.EntityLogicalName,
Criteria = new FilterExpression
{
Conditions =
{
new ConditionExpression
{
AttributeName = "isdefault",
Operator = ConditionOperator.Equal,
Values = { true }
},
new ConditionExpression
{
AttributeName = "querytype",
Operator = ConditionOperator.Equal,
Values = { 0 }
},
new ConditionExpression
{
AttributeName = "returnedtypecode",
Operator = ConditionOperator.Equal,
Values = { Opportunity.EntityTypeCode }
}
}
}
};
//This query should return one and only one result.
SavedQuery defaultOpportunityQuery = _serviceProxy.RetrieveMultiple(mySavedQuery)
.Entities.Select(x => (SavedQuery)x).FirstOrDefault();
// Retrieve visualizations out of the system.
// This sample assumes that you have the "Top Opportunities"
// visualization that is installed with Microsoft Dynamics CRM.
QueryByAttribute visualizationQuery = new QueryByAttribute
{
EntityName = SavedQueryVisualization.EntityLogicalName,
ColumnSet = new ColumnSet("savedqueryvisualizationid"),
Attributes = { "name" },
//If you do not have this visualization, you will need to change
//this line.
Values = { "Top Opportunities" }
};
SavedQueryVisualization visualization = _serviceProxy.RetrieveMultiple(visualizationQuery).
Entities.Select(x => (SavedQueryVisualization)x).FirstOrDefault();
//This is the language code for U.S. English. If you are running this code
//in a different locale, you will need to modify this value.
int languageCode = 1033;
//We set up our dashboard and specify the FormXml. Refer to the
//FormXml schema in the Microsoft Dynamics CRM SDK for more information.
UserForm dashboard = new UserForm
{
Name = "Sample User Dashboard",
Description = "Sample user-owned dashboard.",
FormXml = String.Format(@"<form>
<tabs>
<tab name='Test Dashboard' verticallayout='true'>
<labels>
<label description='Sample User Dashboard' languagecode='{0}' />
</labels>
<columns>
<column width='100%'>
<sections>
<section name='Information Section'
showlabel='false' showbar='false'
columns='111'>
<labels>
<label description='Information Section'
languagecode='{0}' />
</labels>
<rows>
<row>
<cell colspan='1' rowspan='10'
showlabel='false'>
<labels>
<label description='Top Opportunities - 1'
languagecode='{0}' />
</labels>
<control id='Top10Opportunities'
classid='{{E7A81278-8635-4d9e-8D4D-59480B391C5B}}'>
<parameters>
<ViewId>{1}</ViewId>
<IsUserView>false</IsUserView>
<RelationshipName />
<TargetEntityType>opportunity</TargetEntityType>
<AutoExpand>Fixed</AutoExpand>
<EnableQuickFind>false</EnableQuickFind>
<EnableViewPicker>false</EnableViewPicker>
<EnableJumpBar>false</EnableJumpBar>
<ChartGridMode>Chart</ChartGridMode>
<VisualizationId>{2}</VisualizationId>
<EnableChartPicker>false</EnableChartPicker>
<RecordsPerPage>10</RecordsPerPage>
</parameters>
</control>
</cell>
<cell colspan='1' rowspan='10'
showlabel='false'>
<labels>
<label description='Top Opportunities - 2'
languagecode='{0}' />
</labels>
<control id='Top10Opportunities2'
classid='{{E7A81278-8635-4d9e-8D4D-59480B391C5B}}'>
<parameters>
<ViewId>{1}</ViewId>
<IsUserView>false</IsUserView>
<RelationshipName />
<TargetEntityType>opportunity</TargetEntityType>
<AutoExpand>Fixed</AutoExpand>
<EnableQuickFind>false</EnableQuickFind>
<EnableViewPicker>false</EnableViewPicker>
<EnableJumpBar>false</EnableJumpBar>
<ChartGridMode>Grid</ChartGridMode>
<VisualizationId>{2}</VisualizationId>
<EnableChartPicker>false</EnableChartPicker>
<RecordsPerPage>10</RecordsPerPage>
</parameters>
</control>
</cell>
</row>
<row />
<row />
<row />
<row />
<row />
<row />
<row />
<row />
<row />
</rows>
</section>
</sections>
</column>
</columns>
</tab>
</tabs>
</form>",
languageCode,
defaultOpportunityQuery.SavedQueryId.Value.ToString("B"),
visualization.SavedQueryVisualizationId.Value.ToString("B"))
};
_userDashboardId = _serviceProxy.Create(dashboard);
Console.WriteLine("Created {0}.", dashboard.Name);
// Create another user to whom the dashboard will be assigned.
_otherUserId = SystemUserProvider.RetrieveSalesManager(_serviceProxy);
}
/// <summary>
/// Executa uma query
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public EntityCollection RetrieveMultiple(QueryExpression query)
{
return(Repositorio.RepositorioEntity.Instancia.RetrieveMultiple(query));
}
public static IQueryState VisitQueryExpression(QueryExpression queryExpression)
{
return(queryExpression.Accept(_reducer));
}
[STAThread] // Added to support UX
static void Main(string[] args)
{
CrmServiceClient service = null;
try
{
service = SampleHelpers.Connect("Connect");
if (service.IsReady)
{
#region Sample Code
//////////////////////////////////////////////
#region Set up
SetUpSample(service);
#endregion Set up
#region Demonstrate
// Create three e-mail attachments
for (int i = 0; i < 3; i++)
{
ActivityMimeAttachment _sampleAttachment = new ActivityMimeAttachment
{
ObjectId = new EntityReference(Email.EntityLogicalName, emailId),
ObjectTypeCode = Email.EntityLogicalName,
Subject = String.Format("Sample Attachment {0}", i),
Body = System.Convert.ToBase64String(
new ASCIIEncoding().GetBytes("Example Attachment")),
FileName = String.Format("ExampleAttachment{0}.txt", i)
};
emailAttachmentId[i] = service.Create(_sampleAttachment);
}
Console.WriteLine("Created three e-mail attachments for the e-mail activity.");
// Retrieve an attachment including its id, subject, filename and body.
ActivityMimeAttachment _singleAttachment =
(ActivityMimeAttachment)service.Retrieve(
ActivityMimeAttachment.EntityLogicalName,
emailAttachmentId[0],
new ColumnSet("activitymimeattachmentid",
"subject",
"filename",
"body"));
Console.WriteLine("Retrieved an email attachment, {0}.", _singleAttachment.FileName);
// Update attachment
_singleAttachment.FileName = "ExampleAttachmentUpdated.txt";
service.Update(_singleAttachment);
Console.WriteLine("Updated the retrieved e-mail attachment to {0}.", _singleAttachment.FileName);
// Retrieve all attachments associated with the email activity.
QueryExpression _attachmentQuery = new QueryExpression
{
EntityName = ActivityMimeAttachment.EntityLogicalName,
ColumnSet = new ColumnSet("activitymimeattachmentid"),
Criteria = new FilterExpression
{
Conditions =
{
new ConditionExpression
{
AttributeName = "objectid",
Operator = ConditionOperator.Equal,
Values = { emailId }
},
new ConditionExpression
{
AttributeName = "objecttypecode",
Operator = ConditionOperator.Equal,
Values = { Email.EntityLogicalName }
}
}
}
};
EntityCollection results = service.RetrieveMultiple(
_attachmentQuery);
Console.WriteLine("Retrieved all the e-mail attachments.");
#region Clean up
CleanUpSample(service);
#endregion Clean up
}
#endregion Demonstrate
#endregion Sample Code
else
{
const string UNABLE_TO_LOGIN_ERROR = "Unable to Login to Common Data Service";
if (service.LastCrmError.Equals(UNABLE_TO_LOGIN_ERROR))
{
Console.WriteLine("Check the connection string values in cds/App.config.");
throw new Exception(service.LastCrmError);
}
else
{
throw service.LastCrmException;
}
}
}
catch (Exception ex)
{
SampleHelpers.HandleException(ex);
}
finally
{
if (service != null)
{
service.Dispose();
}
Console.WriteLine("Press <Enter> to exit.");
Console.ReadLine();
}
}
public async Task <bool> postPhysicianToPractice(string practiceId, string Choice, Physician physician, string userCreatedBy, string userModifiedBy)
{
SoapEntityRepository entityRepository = SoapEntityRepository.GetService();
if (Choice.Equals("add"))
{
//WarnType warning = new WarnType();
//warning = await verifyNPI(physician.NPI);
//bool result = await verifyNPI(physician.NPI);
Entity contact = new Entity("contact");
contact["mzk_usercreatedby"] = userCreatedBy;
contact["mzk_usermodifiedby"] = userCreatedBy;
if (!string.IsNullOrEmpty(physician.firstName))
{
contact["firstname"] = physician.firstName;
}
if (!string.IsNullOrEmpty(physician.lastName))
{
contact["lastname"] = physician.lastName;
}
if ((!string.IsNullOrEmpty(physician.firstName)) && (!string.IsNullOrEmpty(physician.lastName)))
{
contact["fullname"] = physician.firstName + " " + physician.lastName;
}
Guid contactguid = new Guid();
contactguid = entityRepository.CreateEntity(contact);
//EntityReference link = new EntityReference();
//link.Id = contactguid;
Entity physician_new = new Entity("bookableresource");
// physician_new.FormattedValues["resourcetype"] = "Contact";
physician_new["mzk_usercreatedby"] = userCreatedBy;
physician_new["mzk_usermodifiedby"] = userCreatedBy;
physician_new["resourcetype"] = new OptionSetValue(2);
physician_new["contactid"] = new EntityReference("contact", contactguid);
//if(!.string.IsNullOrEmpty(physician.))
if (!string.IsNullOrEmpty(physician.firstName))
{
physician_new["name"] = physician.firstName;
if (!string.IsNullOrEmpty(physician.middleInitial))
{
physician_new["name"] += physician.middleInitial;
if (!string.IsNullOrEmpty(physician.lastName))
{
physician_new["name"] += physician.lastName;
}
}
}
else if (!string.IsNullOrEmpty(physician.middleInitial))
{
physician_new["name"] = physician.middleInitial;
if (!string.IsNullOrEmpty(physician.lastName))
{
physician_new["name"] += physician.lastName;
}
}
else if (!string.IsNullOrEmpty(physician.lastName))
{
physician_new["name"] = physician.lastName;
}
//physician_new["name"] = physician.firstName + " " + physician.middleInitial + " " + physician.lastName;
if (!string.IsNullOrEmpty(physician.NPI))
{
WarnType warning = new WarnType();
warning = await verifyNPI(physician.NPI);
if (warning.verified.Equals(false))
{
HttpContext.Current.Items["warningmessage"] = warning.message;
}
else
{
// HttpContext.Current.Items["warningmessage"] = warning.message;
}
physician_new["mzk_npinumber"] = physician.NPI;
}
if (!string.IsNullOrEmpty(physician.email))
{
physician_new["msdyn_primaryemail"] = physician.email;
}
if (!string.IsNullOrEmpty(physician.phone))
{
physician_new["mzk_phone"] = physician.phone;
}
physician_new["timezone"] = 25;
Guid id_phy = new Guid();
id_phy = entityRepository.CreateEntity(physician_new);
// EntityReference lookup = new EntityReference();
// entityRepository.CreateEntity(physician_new); //= new EntityReference("bookableresourceid", id_phy);
//id_phy = (EntityReference)entityRepository.CreateEntity(physician_new);
/* QueryExpression query = new QueryExpression("account");
* query.Criteria.AddCondition("accountid", ConditionOperator.Equal, new Guid(practiceId));
* //LinkEntity link1 = new LinkEntity("")*/
Entity relation = new Entity(mzk_clinicphysician.EntityLogicalName);
relation["mzk_usercreatedby"] = userCreatedBy;
relation["mzk_usermodifiedby"] = userModifiedBy;
relation["mzk_physician"] = new EntityReference("bookableresource", id_phy);
relation["mzk_clinic"] = new EntityReference("account", new Guid(practiceId));
entityRepository.CreateEntity(relation);
//Create Association
return(true);
}
else if (Choice.Equals("delete"))
{
QueryExpression query = new QueryExpression(mzk_clinicphysician.EntityLogicalName);
FilterExpression childFilter = query.Criteria.AddFilter(LogicalOperator.And);
childFilter.AddCondition("mzk_clinic", ConditionOperator.Equal, new Guid(practiceId));
childFilter.AddCondition("mzk_physician", ConditionOperator.Equal, new Guid(physician.physicianId));
EntityCollection entity = entityRepository.GetEntityCollection(query);
Guid guid = entity.Entities[0].Id;
entityRepository.DeleteEntity(mzk_clinicphysician.EntityLogicalName, guid);
return(true);
}
else if (Choice.Equals("modify"))
{
QueryExpression queryb = new QueryExpression(BookableResource.EntityLogicalName);
FilterExpression childFilter = queryb.Criteria.AddFilter(LogicalOperator.And);
childFilter.AddCondition("bookableresourceid", ConditionOperator.Equal, new Guid(physician.physicianId));
queryb.ColumnSet = new Microsoft.Xrm.Sdk.Query.ColumnSet("bookableresourceid", "contactid", "name", "mzk_npinumber", "msdyn_primaryemail", "mzk_phone");
EntityCollection entitycollection = entityRepository.GetEntityCollection(queryb);
foreach (Entity entity in entitycollection.Entities)
{
if (!string.IsNullOrEmpty(physician.firstName))
{
entity["name"] = physician.firstName;
}
if (!string.IsNullOrEmpty(physician.middleInitial))
{
entity["name"] += " " + physician.middleInitial;
}
if (!string.IsNullOrEmpty(physician.lastName))
{
entity["name"] += " " + physician.lastName;
}
if (!string.IsNullOrEmpty(physician.NPI))
{
entity["mzk_npinumber"] = physician.NPI;
}
if (!string.IsNullOrEmpty(physician.email))
{
entity["msdyn_primaryemail"] = physician.email;
}
if (!string.IsNullOrEmpty(physician.phone))
{
entity["mzk_phone"] = physician.phone;
}
if (entity.Attributes.Contains("contactid"))
{
EntityReference refer = (EntityReference)entity["contactid"];
QueryExpression queryc = new QueryExpression(xrm.Contact.EntityLogicalName);
FilterExpression childfilter = queryc.Criteria.AddFilter(LogicalOperator.And);
childfilter.AddCondition("contactid", ConditionOperator.Equal, refer.Id);
queryc.ColumnSet = new Microsoft.Xrm.Sdk.Query.ColumnSet("fullname", "address1_composite", "emailaddress1", "telephone2");
EntityCollection ecollection = entityRepository.GetEntityCollection(queryc);
foreach (Entity c_entity in ecollection.Entities)
{
if (!string.IsNullOrEmpty(physician.firstName))
{
c_entity.Attributes["fullname"] = physician.firstName;
}
if (!string.IsNullOrEmpty(physician.middleInitial))
{
c_entity.Attributes["fullname"] += " " + physician.middleInitial;
}
if (!string.IsNullOrEmpty(physician.lastName))
{
c_entity.Attributes["fullname"] += " " + physician.lastName;
}
if (!string.IsNullOrEmpty(physician.location))
{
c_entity.Attributes["address1_composite"] = physician.location;
}
if (!string.IsNullOrEmpty(physician.email))
{
c_entity.Attributes["emailaddress1"] = physician.email;
}
if (!string.IsNullOrEmpty(physician.phone))
{
c_entity.Attributes["telephone2"] = physician.phone;
}
try
{
entityRepository.UpdateEntity(c_entity);
}
catch (Exception ex)
{
throw ex;
}
}
}
try
{
entityRepository.UpdateEntity(entity);
}
catch (Exception ex)
{
throw ex;
}
}
return(true);
}
else
{
return(false);
}
}
public CRMLargeQuery(IOrganizationService incomingService, QueryExpression incomingQuery)
{
service = incomingService;
query = incomingQuery;
}
[STAThread] // Added to support UX
static void Main(string[] args)
{
CrmServiceClient service = null;
try
{
service = SampleHelpers.Connect("Connect");
if (service.IsReady)
{
#region Sample Code
#region Set up
SetUpSample(service);
#endregion Set up
#region Demonstrate
// Enable auditing on the organization and for user access by editing the
// organization's settings.
// First, get the organization's ID from the system user record.
var whoAmIReq = new WhoAmIRequest();
var whoAmIRes = (WhoAmIResponse)service.Execute(whoAmIReq);
Guid orgId = whoAmIRes.OrganizationId;
_systemUserId = whoAmIRes.UserId;
// Next, retrieve the organization's record.
var org = (Organization)service.Retrieve(
Organization.EntityLogicalName, orgId,
new ColumnSet("organizationid", "isauditenabled", "isuseraccessauditenabled", "useraccessauditinginterval"));
// Finally, enable auditing on the organization, including auditing for
// user access.
bool organizationAuditingFlag = org.IsAuditEnabled.Value;
bool userAccessAuditingFlag = org.IsUserAccessAuditEnabled.Value;
if (!organizationAuditingFlag || !userAccessAuditingFlag)
{
org.IsAuditEnabled = true;
org.IsUserAccessAuditEnabled = true;
service.Update(org);
Console.WriteLine("Enabled auditing for the organization and for user access.");
Console.WriteLine("Auditing interval is set to {0} hours.", org.UserAccessAuditingInterval);
}
else
{
Console.WriteLine("Auditing was enabled before the sample began, so no auditing settings were changed.");
}
// Enable auditing on the account entity, since no audits will be created
// when we create/update an account entity, otherwise.
var oldAccountAuditing = EnableEntityAuditing(service, Account.EntityLogicalName, true);
// Make an update request to the Account entity to be tracked by auditing.
var newAccount = new Account();
newAccount.AccountId = _newAccountId;
newAccount.AccountNumber = "1-A";
newAccount.AccountCategoryCode = new OptionSetValue(
(int)AccountAccountCategoryCode.PreferredCustomer);
newAccount.Telephone1 = "555-555-5555";
service.Update(newAccount);
Console.WriteLine("Created an account and made updates which should be captured by auditing.");
// Set the organization and account auditing flags back to the old values
if (!organizationAuditingFlag || !userAccessAuditingFlag)
{
// Only revert them if they were actually changed to begin with.
org.IsAuditEnabled = organizationAuditingFlag;
org.IsUserAccessAuditEnabled = userAccessAuditingFlag;
service.Update(org);
Console.WriteLine("Reverted organization and user access auditing to their previous values.");
}
else
{
Console.WriteLine("Auditing was enabled before the sample began, so no auditing settings were reverted.");
}
// Revert the account entity auditing.
EnableEntityAuditing(service, Account.EntityLogicalName, oldAccountAuditing);
#endregion Revert auditing
#region Show Audited Records
// Select all columns for convenience.
var query = new QueryExpression(Audit.EntityLogicalName)
{
ColumnSet = new ColumnSet(true),
Criteria = new FilterExpression(LogicalOperator.And)
};
// Only retrieve audit records that track user access.
query.Criteria.AddCondition("action", ConditionOperator.In,
(int)AuditAction.UserAccessAuditStarted,
(int)AuditAction.UserAccessAuditStopped,
(int)AuditAction.UserAccessviaWebServices,
(int)AuditAction.UserAccessviaWeb);
// Change this to false in order to retrieve audit records for all users
// when running the sample.
var filterAuditsRetrievedByUser = true;
if (filterAuditsRetrievedByUser)
{
// Only retrieve audit records for the current user or the "SYSTEM"
// user.
var userFilter = new FilterExpression(LogicalOperator.Or);
userFilter.AddCondition(
"userid", ConditionOperator.Equal, _systemUserId);
userFilter.AddCondition(
"useridname", ConditionOperator.Equal, "SYSTEM");
}
// Only retrieve records for this sample run, so that we don't get too
// many results if auditing was enabled previously.
query.Criteria.AddCondition(
"createdon", ConditionOperator.GreaterEqual, DateTime.UtcNow);
var results = service.RetrieveMultiple(query);
Console.WriteLine("Retrieved audit records:");
foreach (Audit audit in results.Entities)
{
Console.Write("\r\n Action: {0}, User: {1},"
+ "\r\n Created On: {2}, Operation: {3}",
(AuditAction)audit.Action.Value,
audit.UserId.Name,
audit.CreatedOn.Value.ToLocalTime(),
(AuditOperation)audit.Operation.Value);
// Display the name of the related object (which will be the user
// for audit records with Action UserAccessviaWebServices.
if (!String.IsNullOrEmpty(audit.ObjectId.Name))
{
Console.WriteLine(
",\r\n Related Record: {0}", audit.ObjectId.Name);
}
else
{
Console.WriteLine();
}
}
#endregion Show Audited Records
#region Clean up
CleanUpSample(service);
#endregion Clean up
}
#endregion Demonstrate
else
{
const string UNABLE_TO_LOGIN_ERROR = "Unable to Login to Common Data Service";
if (service.LastCrmError.Equals(UNABLE_TO_LOGIN_ERROR))
{
Console.WriteLine("Check the connection string values in cds/App.config.");
throw new Exception(service.LastCrmError);
}
else
{
throw service.LastCrmException;
}
}
}
catch (Exception ex)
{
SampleHelpers.HandleException(ex);
}
finally
{
if (service != null)
{
service.Dispose();
}
Console.WriteLine("Press <Enter> to exit.");
Console.ReadLine();
}
}
public static void AddOrder <T>(this QueryExpression query, Expression <Func <T, object> > attribute,
OrderType orderType)
where T : Entity => query.AddOrder(Name(attribute), orderType);
internal QueryCastExpression(QueryExpression source, QueryType typeToCastTo)
: base(source, typeToCastTo, typeToCastTo)
{
}
public void TestRetrieveRelatedEntities()
{
using (var context = new Xrm(orgAdminUIService))
{
var accountName = "Litware, Inc.";
var _accountId = orgAdminUIService.Create(
new Account
{
Name = accountName,
Address1_StateOrProvince = "Colorado"
});
// Create the two contacts.
orgAdminUIService.Create(
new Contact()
{
FirstName = "Ben",
LastName = "Andrews",
EMailAddress1 = "*****@*****.**",
Address1_City = "Redmond",
Address1_StateOrProvince = "WA",
Address1_Telephone1 = "(206)555-5555",
ParentCustomerId = new EntityReference
{
Id = _accountId,
LogicalName = Account.EntityLogicalName
}
});
orgAdminUIService.Create(
new Contact()
{
FirstName = "Alan",
LastName = "Wilcox",
EMailAddress1 = "*****@*****.**",
Address1_City = "Bellevue",
Address1_StateOrProvince = "WA",
Address1_Telephone1 = "(425)555-5555",
ParentCustomerId = new EntityReference
{
Id = _accountId,
LogicalName = Account.EntityLogicalName
}
});
//create the query expression object
QueryExpression query = new QueryExpression
{
EntityName = "contact",
ColumnSet = new ColumnSet(true)
};
//create the relationship object
Relationship relationship = new Relationship();
//add the condition where you can retrieve only the account related active contacts
query.Criteria = new FilterExpression();
query.Criteria.AddCondition(new ConditionExpression("address1_city", ConditionOperator.Equal, "Bellevue"));
// name of relationship between account & contact
relationship.SchemaName = "contact_customer_accounts";
//create relationshipQueryCollection Object
RelationshipQueryCollection relatedEntity = new RelationshipQueryCollection
{
{ relationship, query }
};
//create the retrieve request object
RetrieveRequest request = new RetrieveRequest
{
RelatedEntitiesQuery = relatedEntity,
ColumnSet = new ColumnSet("accountid"),
Target = new EntityReference {
Id = _accountId, LogicalName = "account"
}
};
//execute the request
RetrieveResponse response = (RetrieveResponse)orgAdminUIService.Execute(request);
Assert.AreEqual(1, response.Entity.RelatedEntities.Count);
var collection = response.Entity.RelatedEntities.Values.First();
Assert.AreEqual(1, collection.Entities.Count);
var entity = collection.Entities.First();
Assert.IsTrue(entity.Attributes.ContainsKey("firstname"));
Assert.AreEqual("Alan", entity.Attributes["firstname"]);
}
}
public ScopeExpression(QueryExpression expression)
: base(expression)
{
}
public void GetEntityRecord(IOrganizationService service)
{
ConditionExpression condition1 = new ConditionExpression();
condition1.AttributeName = "lastname";
condition1.Operator = ConditionOperator.Equal;
condition1.Values.Add("Fry");
ConditionExpression condition2 = new ConditionExpression();
condition2.AttributeName = "firstname";
condition2.Operator = ConditionOperator.Equal;
condition2.Values.Add("Alexis");
FilterExpression filter1 = new FilterExpression();
filter1.Conditions.Add(condition1);
filter1.Conditions.Add(condition2);
QueryExpression query = new QueryExpression("contact");
query.ColumnSet.AddColumns("firstname", "lastname");
query.Criteria.AddFilter(filter1);
EntityCollection result1 = service.RetrieveMultiple(query);
if (result1.Entities.Count > 0) //Check for EntityCollection count
{
string output = string.Empty;
foreach (var item in result1.Entities)
{
//String
if (item.Attributes.Contains("fullname")) //Check for fullname value exists or not in Entity Collection
{
output += "Full Name : " + item.Attributes["fullname"] + "\n";
}
//Lookup
if (item.Attributes.Contains("parentcustomerid")) //Check for parentcustomerid exists or not in Entity Collection
{
output += "Company : " + ((EntityReference)item.Attributes["parentcustomerid"]).Name + "\n";
}
//OptionSet
if (item.Attributes.Contains("gendercode")) //Check for gendercode exists or not in Entity Collection
{
output += "Gender : Name - " + item.FormattedValues["gendercode"] + ", Value - " + ((OptionSetValue)item.Attributes["gendercode"]).Value + "\n";
}
//Date
if (item.Attributes.Contains("birthdate")) //Check for birthdate exists or not in Entity Collection
{
output += "Birthday : " + ((DateTime)item.Attributes["birthdate"]).ToLocalTime().ToShortDateString().ToString() + "\n";
}
//Currency
if (item.Attributes.Contains("creditlimit")) //Check for creditlimit exists or not in Entity Collection
{
output += "Credit Limit : " + ((Money)item.Attributes["creditlimit"]).Value + "\n";
}
//Two Options
if (item.Attributes.Contains("donotsendmm")) //Check for donotsendmm exists or not in Entity Collection
{
output += "Send Marketing Materials : Name - " + item.FormattedValues["donotsendmm"] + ", Value - " + ((Boolean)item.Attributes["donotsendmm"]).ToString();
}
}
Console.WriteLine(output);
Console.ReadKey();
}
}
public void QueryExpressionpaginatequery(IOrganizationService service, string accountid)
{
// Query using the paging cookie.
// Define the paging attributes.
// The number of records per page to retrieve.
int queryCount = 3;
// Initialize the page number.
int pageNumber = 1;
// Initialize the number of records.
int recordCount = 0;
// Define the condition expression for retrieving records.
ConditionExpression pagecondition = new ConditionExpression();
pagecondition.AttributeName = "parentaccountid";
pagecondition.Operator = ConditionOperator.Equal;
pagecondition.Values.Add(accountid);
// Define the order expression to retrieve the records.
OrderExpression order = new OrderExpression();
order.AttributeName = "name";
order.OrderType = OrderType.Ascending;
// Create the query expression and add condition.
QueryExpression pagequery = new QueryExpression();
pagequery.EntityName = "account";
pagequery.Criteria.AddCondition(pagecondition);
pagequery.Orders.Add(order);
pagequery.ColumnSet.AddColumns("name", "emailaddress1");
// Assign the pageinfo properties to the query expression.
pagequery.PageInfo = new PagingInfo();
pagequery.PageInfo.Count = queryCount;
pagequery.PageInfo.PageNumber = pageNumber;
// The current paging cookie. When retrieving the first page,
// pagingCookie should be null.
pagequery.PageInfo.PagingCookie = null;
Console.WriteLine("Retrieving sample account records in pages...\n");
Console.WriteLine("#\tAccount Name\t\tEmail Address");
while (true)
{
// Retrieve the page.
EntityCollection results = service.RetrieveMultiple(pagequery);
if (results.Entities != null)
{
// Retrieve all records from the result set.
foreach (var acct in results.Entities)
{
Console.WriteLine("{0}.\t{1}\t{2}", ++recordCount, acct["Name"],
acct["EMailAddress1"]);
}
}
// Check for more records, if it returns true.
if (results.MoreRecords)
{
Console.WriteLine("\n****************\nPage number {0}\n****************", pagequery.PageInfo.PageNumber);
Console.WriteLine("#\tAccount Name\t\tEmail Address");
// Increment the page number to retrieve the next page.
pagequery.PageInfo.PageNumber++;
// Set the paging cookie to the paging cookie returned from current results.
pagequery.PageInfo.PagingCookie = results.PagingCookie;
}
else
{
// If no more records are in the result nodes, exit the loop.
break;
}
}
}
private EntityCollection RetrieveMultipleInternal(QueryExpression qe)
{
return((EntityCollection)InvokeStaticGenericMethod(qe.EntityName, "ReadEntities", this, qe));
}
internal Dictionary <Guid, SecurityRole> GetSecurityRoles(Guid rootBUId)
{
// Queries
var privQuery = new QueryExpression(PRIVILEGE)
{
ColumnSet = new ColumnSet("privilegeid", "accessright", "canbeglobal", "canbedeep", "canbelocal", "canbebasic")
};
var privileges = QueryPaging(privQuery);
var privOTCQuery = new QueryExpression(PRIVILEGE_OTC)
{
ColumnSet = new ColumnSet("privilegeid", "objecttypecode")
};
var privilegeOTCs = QueryPaging(privOTCQuery);
var rolePrivQuery = new QueryExpression(ROLEPRIVILEGES)
{
ColumnSet = new ColumnSet("privilegeid", "roleid", "privilegedepthmask")
};
var rolePrivileges = QueryPaging(rolePrivQuery);
var roleQuery = new QueryExpression(ROLE)
{
ColumnSet = new ColumnSet("parentrootroleid", "name", "roleid", "roletemplateid", "businessunitid")
};
var rolelist = QueryPaging(roleQuery);
// Joins
// rpr <- roleprivileges left outer join roles
var roleprivilegeLOJrole =
from roleprivilege in rolePrivileges
join role in rolelist on((Guid)roleprivilege["roleid"]) equals((EntityReference)role["parentrootroleid"]).Id into res
from role in res.DefaultIfEmpty()
where ((EntityReference)role["businessunitid"]).Id.Equals(rootBUId) &&
(int)roleprivilege["privilegedepthmask"] != 0
select new { roleprivilege, role };
// pp <- privileges left outer join privilegeOTCs
var privilegesLOJprivilegeOTCs =
from privilege in privileges
join privilegeOTC in privilegeOTCs on((Guid)privilege["privilegeid"]) equals((EntityReference)privilegeOTC["privilegeid"]).Id into res
from privilegeOTC in res.DefaultIfEmpty()
select new { privilege, privilegeOTC };
// entities <- pp left outer join rpr
var entities =
from pp in privilegesLOJprivilegeOTCs
join rpr in roleprivilegeLOJrole on((Guid)pp.privilege["privilegeid"]) equals((Guid)rpr.roleprivilege["privilegeid"]) into res
from rpr in res.DefaultIfEmpty()
select new { pp, rpr };
// Role generation
var roles = new Dictionary <Guid, SecurityRole>();
var validSecurityRoles = entities.Where(e =>
e.pp?.privilege != null &&
(e.pp?.privilegeOTC?.Contains("objecttypecode")).GetValueOrDefault() &&
(e.rpr?.roleprivilege?.Contains("roleid")).GetValueOrDefault() &&
(e.rpr?.role?.Contains("name")).GetValueOrDefault());
foreach (var e in validSecurityRoles)
{
var entityName = (string)e.pp.privilegeOTC["objecttypecode"];
if (entityName == "none")
{
continue;
}
var rp = ToRolePrivilege(e.pp.privilege, e.rpr.roleprivilege);
if (rp.AccessRight == AccessRights.None)
{
continue;
}
var roleId = (Guid)e.rpr.roleprivilege["roleid"];
if (!roles.ContainsKey(roleId))
{
roles[roleId] = new SecurityRole()
{
Name = (string)e.rpr.role["name"],
RoleId = roleId
};
if (e.rpr.role.Attributes.ContainsKey("roletemplateid"))
{
roles[roleId].RoleTemplateId = ((EntityReference)e.rpr.role["roletemplateid"]).Id;
}
roles[roleId].Privileges = new Dictionary <string, Dictionary <AccessRights, RolePrivilege> >();
}
if (!roles[roleId].Privileges.ContainsKey(entityName))
{
roles[roleId].Privileges.Add(entityName, new Dictionary <AccessRights, RolePrivilege>());
}
roles[roleId].Privileges[entityName].Add(rp.AccessRight, rp);
}
return(roles);
}
/// <summary>
/// подсчёт оплаченной суммы в объекте договор при обовлении и создании счета со статусом оплачено
/// </summary>
/// <param name="image"></param>
public void CalcSum(Entity image)
{
Entity order = image;
// guid текущего счета
Guid orderId = order.Id;
_TracingService.Trace("PostOrderCreate: Get order object values");
// var orderValues = _service.Retrieve(order.LogicalName, orderId, new ColumnSet(new string[] { "al_fact", "al_summa", "al_dogovorid" }));
_TracingService.Trace("PostOrderCreate: Check if order is paid");
var isPaid = order.GetAttributeValue <bool>("al_facted");
// проверка статуса оплачено на объекте счет
if (isPaid)
{
var contractId = order.GetAttributeValue <EntityReference>("al_dogovorid").Id;
_TracingService.Trace("PostOrderCreateUpdate: Get paid orders by contract and sums");
// поиск всех оплаченных счетов для данного договора
QueryExpression queryExpression = new QueryExpression();
queryExpression.EntityName = "al_order";
queryExpression.ColumnSet = new ColumnSet(new string[] { "al_summa" });
queryExpression.Criteria = new FilterExpression
{
Conditions =
{
new ConditionExpression
{
AttributeName = "al_dogovorid",
Operator = ConditionOperator.Equal,
Values = { contractId }
},
new ConditionExpression
{
AttributeName = "al_facted",
Operator = ConditionOperator.Equal,
Values = { true }
}
}
};
var entityCollection = _Service.RetrieveMultiple(queryExpression);
// общая сумма счетов
var commonSum = 0;
// подсчёт общей суммы счетов
foreach (var ent in entityCollection.Entities)
{
commonSum = commonSum + (int)ent.Attributes["al_summa"];
}
_TracingService.Trace("PostOrderCreateUpdate: Set fact summa in contract object.");
// объект договор связанный со счетами
var contractValues = _Service.Retrieve("al_dogovor", contractId, new ColumnSet(new string[] { "al_summa" }));
Entity contractToUpdate = new Entity("al_dogovor", contractId);
// общая сумма в договоре
var contractSum = contractValues.GetAttributeValue <Money>("al_summa");
// проверка не превышает ли общая сумма счетов общей суммы в договоре
if ((decimal)commonSum > contractSum.Value)
{
throw new InvalidPluginExecutionException("Common sum of bills greater than contract sum");
}
// обновление общей суммы в объекте договор
contractToUpdate["al_factsumma"] = new Money((decimal)commonSum);
_Service.Update(contractToUpdate);
}
}
public static EntityCollection RetrieveMultipleAll(this IOrganizationService service, QueryExpression query)
{
var entitiesList = new List <Entity>();
query.PageInfo.PageNumber = 1;
while (true)
{
var collRecords = service.RetrieveMultiple(query);
entitiesList.AddRange(collRecords.Entities);
if (!collRecords.MoreRecords)
{
break;
}
query.PageInfo.PageNumber++;
query.PageInfo.PagingCookie = collRecords.PagingCookie;
}
return(new EntityCollection(entitiesList));
}
public void Execute(IServiceProvider serviceProvider)
{
ITracingService tracingService =
(ITracingService)serviceProvider.GetService(typeof(ITracingService));
IPluginExecutionContext context = (IPluginExecutionContext)
serviceProvider.GetService(typeof(IPluginExecutionContext));
if (!context.InputParameters.Contains("Target") ||
!(context.InputParameters["Target"] is Entity))
{
throw new InvalidPluginExecutionException("Target is not Entity");
}
if (!context.PostEntityImages.Contains("image") || !(context.PostEntityImages["image"] is Entity))
{
throw new InvalidPluginExecutionException("Context has no post images");
}
Entity targetEntity = (Entity)context.InputParameters["Target"];
if (targetEntity.LogicalName != "al_order" && context.MessageName != "Update")
{
throw new InvalidPluginExecutionException("Target's logical name is not order or action is not update");
}
try
{
IOrganizationServiceFactory serviceFactory = (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory));
IOrganizationService service = serviceFactory.CreateOrganizationService(context.UserId);
Entity currentOrder = (Entity)context.InputParameters["Target"];
var isPaidOrder = currentOrder.GetAttributeValue <bool>("al_facted");
if (isPaidOrder)
{
var contractId = currentOrder.GetAttributeValue <EntityReference>("al_dogovorid").Id;
tracingService.Trace("PostOrderDelete: Get paid orders by contract and sums");
QueryExpression queryExpression = new QueryExpression();
queryExpression.EntityName = "al_order";
queryExpression.ColumnSet = new ColumnSet(new string[] { "al_summa" });
queryExpression.Criteria = new FilterExpression
{
Conditions =
{
new ConditionExpression
{
AttributeName = "al_dogovorid",
Operator = ConditionOperator.Equal,
Values = { contractId }
},
new ConditionExpression
{
AttributeName = "al_facted",
Operator = ConditionOperator.Equal,
Values = { true }
}
}
};
var entityCollection = service.RetrieveMultiple(queryExpression);
var commonSum = 0;
foreach (var ent in entityCollection.Entities)
{
commonSum = commonSum + (int)ent.Attributes["al_summa"];
}
tracingService.Trace("PostOrderDelete: Set fact summa in contract object.");
var res = service.Retrieve("al_dogovor", contractId, new ColumnSet(new string[] { "al_summa" }));
Entity contractToUpdate = new Entity("al_dogovor", contractId);
var contractSum = res.GetAttributeValue <Money>("al_summa");
if (contractSum.Value < (decimal)commonSum)
{
throw new InvalidPluginExecutionException("Common sum of bills greater than contract sum");
}
contractToUpdate["al_factsumma"] = new Money((decimal)commonSum);
service.Update(contractToUpdate);
}
}
catch (Exception ex)
{
tracingService.Trace("PostOrderUpdate: {0}", ex.ToString());
throw;
}
}
public static TBuilder Limit <TBuilder>(this TBuilder builder, QueryExpression queryExpression)
where TBuilder : IRangeQueryBuilder
{
builder.Range.Limit(queryExpression);
return(builder);
}
private static void ThrowUnsupportedRangeExpression(FacetQuery query, QueryExpression expression)
{
throw new InvalidQueryException($"Unsupported range expression of a facet query: {expression.GetType().Name}. Text: {expression.GetText()}.", query.Query.Metadata.QueryText, query.Query.QueryParameters);
}
public void Execute(IServiceProvider serviceProvider)
{
IPluginExecutionContext context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));
IOrganizationServiceFactory factory = (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory));
IOrganizationService service = factory.CreateOrganizationService(context.UserId);
try
{
string credentials = null;
try
{
QueryExpression query = new QueryExpression();
query.EntityName = "syt_twittercredential";
query.ColumnSet = new ColumnSet()
{
AllColumns = true
};
EntityCollection entities = service.RetrieveMultiple(query);
Entity entity = entities[0];
credentials = entity.Attributes["syt_twitterauth"].ToString();
}
catch (Exception ex)
{
throw new InvalidPluginExecutionException(ex.Message);
}
string access_token = "";
var post = WebRequest.Create("https://api.twitter.com/oauth2/token") as HttpWebRequest;
post.Method = "POST";
post.ContentType = "application/x-www-form-urlencoded";
post.Headers[HttpRequestHeader.Authorization] = "Basic " + credentials;
var reqbody = Encoding.UTF8.GetBytes("grant_type=client_credentials");
post.ContentLength = reqbody.Length;
using (var req = post.GetRequestStream())
{
req.Write(reqbody, 0, reqbody.Length);
}
try
{
string respbody = null;
using (var resp = post.GetResponse().GetResponseStream())//there request sends
{
var respR = new StreamReader(resp);
respbody = respR.ReadToEnd();
}
access_token = respbody.Substring(respbody.IndexOf("access_token\":\"") + "access_token\":\"".Length, respbody.IndexOf("\"}") - (respbody.IndexOf("access_token\":\"") + "access_token\":\"".Length));
}
catch //if credentials are not valid
{
//TODO
}
var crm = WebRequest.Create("https://api.twitter.com/1.1/search/tweets.json?q=%23crm-filter:retweets&-filter:replies&result_type=recent&count=30") as HttpWebRequest;
crm.Method = "GET";
crm.Headers[HttpRequestHeader.Authorization] = "Bearer " + access_token;
var cms = WebRequest.Create("https://api.twitter.com/1.1/search/tweets.json?q=%23cms-filter:retweets&-filter:replies&result_type=recent&count=30") as HttpWebRequest;
cms.Method = "GET";
cms.Headers[HttpRequestHeader.Authorization] = "Bearer " + access_token;
var suyati = WebRequest.Create("https://api.twitter.com/1.1/search/tweets.json?q=%23suyati-filter:retweets&-filter:replies&result_type=recent&count=30") as HttpWebRequest;
suyati.Method = "GET";
suyati.Headers[HttpRequestHeader.Authorization] = "Bearer " + access_token;
var salesforce = WebRequest.Create("https://api.twitter.com/1.1/search/tweets.json?q=%23salesforce-filter:retweets&-filter:replies&result_type=recent&count=30") as HttpWebRequest;
salesforce.Method = "GET";
salesforce.Headers[HttpRequestHeader.Authorization] = "Bearer " + access_token;
var dynamics = WebRequest.Create("https://api.twitter.com/1.1/search/tweets.json?q=%23msdynamics-filter:retweets&-filter:replies&result_type=recent&count=30") as HttpWebRequest;
dynamics.Method = "GET";
dynamics.Headers[HttpRequestHeader.Authorization] = "Bearer " + access_token;
try
{
string crmtweet = null;
using (var resp = crm.GetResponse().GetResponseStream())//get tweets with #crm
{
var respR = new StreamReader(resp);
crmtweet = respR.ReadToEnd();
}
string cmstweet = null;
using (var resp = cms.GetResponse().GetResponseStream())//get tweets with #cms
{
var respR = new StreamReader(resp);
cmstweet = respR.ReadToEnd();
}
string suyatitweet = null;
using (var resp = suyati.GetResponse().GetResponseStream())//get tweets with #suyati
{
var respR = new StreamReader(resp);
suyatitweet = respR.ReadToEnd();
}
string salesforcetweet = null;
using (var resp = salesforce.GetResponse().GetResponseStream())//get tweets with #salesforce
{
var respR = new StreamReader(resp);
salesforcetweet = respR.ReadToEnd();
}
string dynamicstweet = null;
using (var resp = dynamics.GetResponse().GetResponseStream())//get tweets with #dynamics
{
var respR = new StreamReader(resp);
dynamicstweet = respR.ReadToEnd();
}
//Passing it to Action
context.OutputParameters["crmtweets"] = crmtweet.ToString();
context.OutputParameters["cmstweets"] = cmstweet.ToString();
context.OutputParameters["suyatitweets"] = suyatitweet.ToString();
context.OutputParameters["salesforcetweets"] = salesforcetweet.ToString();
context.OutputParameters["dynamicstweets"] = dynamicstweet.ToString();
}
catch //401 (access token invalid or expired)
{
//TODO
}
}
catch (Exception ex)
{
throw new InvalidPluginExecutionException(ex.Message);
}
}
public static JoinQueryResult VisitQueryExpression(QueryExpression queryExpression, ResultElement resultElement, DbJoinType joinType, LambdaExpression conditionExpression, List <IMappingObjectExpression> moeList)
{
JoinQueryExpressionVisitor visitor = new JoinQueryExpressionVisitor(resultElement, joinType, conditionExpression, moeList);
return(queryExpression.Accept(visitor));
}
private static ParsedRange ParseRange(QueryExpression expression, FacetQuery query, out RangeType type)
{
if (expression is BetweenExpression bee)
{
var hValue = ConvertFieldValue(bee.Max.Token, bee.Max.Value);
var lValue = ConvertFieldValue(bee.Min.Token, bee.Min.Value);
var fieldName = ((FieldExpression)bee.Source).FieldValue;
if (hValue.Type != lValue.Type)
{
ThrowDifferentTypesOfRangeValues(query, hValue.Type, lValue.Type, fieldName);
}
type = hValue.Type;
return(new ParsedRange
{
Field = fieldName,
HighInclusive = true,
HighValue = hValue.Value,
LowInclusive = true,
LowValue = lValue.Value,
RangeText = expression.GetText()
});
}
if (expression is BinaryExpression be)
{
switch (be.Operator)
{
case OperatorType.LessThan:
case OperatorType.GreaterThan:
case OperatorType.LessThanEqual:
case OperatorType.GreaterThanEqual:
var fieldName = ExtractFieldName(be, query);
var r = (ValueExpression)be.Right;
var fieldValue = ConvertFieldValue(r.Token, r.Value);
type = fieldValue.Type;
var range = new ParsedRange
{
Field = fieldName,
RangeText = expression.GetText()
};
if (be.Operator == OperatorType.LessThan || be.Operator == OperatorType.LessThanEqual)
{
range.HighValue = fieldValue.Value;
range.HighInclusive = be.Operator == OperatorType.LessThanEqual;
return(range);
}
if (be.Operator == OperatorType.GreaterThan || be.Operator == OperatorType.GreaterThanEqual)
{
range.LowValue = fieldValue.Value;
range.LowInclusive = be.Operator == OperatorType.GreaterThanEqual;
return(range);
}
return(range);
case OperatorType.And:
var left = ParseRange(be.Left, query, out var lType);
var right = ParseRange(be.Right, query, out var rType);
if (lType != rType)
{
ThrowDifferentTypesOfRangeValues(query, lType, rType, left.Field);
}
type = lType;
if (left.HighValue == null)
{
left.HighValue = right.HighValue;
left.HighInclusive = right.HighInclusive;
}
if (left.LowValue == null)
{
left.LowValue = right.LowValue;
left.LowInclusive = right.LowInclusive;
}
left.RangeText = expression.GetText();
return(left);
default:
ThrowUnsupportedRangeOperator(query, be.Operator);
break;
}
}
ThrowUnsupportedRangeExpression(query, expression);
type = RangeType.None;
return(null);
}
public async Task <List <FrequentlyAskedQuestions> > getContractSpecificFAQS(string patientId, SoapEntityRepository entityRepository)
{
try
{
if (!string.IsNullOrEmpty(patientId))
{
List <FrequentlyAskedQuestions> FAQS = new List <FrequentlyAskedQuestions>();
QueryExpression query = new QueryExpression("mzk_faqconfiguration");
query.Criteria.AddCondition("mzk_servicespecific", ConditionOperator.Equal, true);
query.ColumnSet = new ColumnSet("mzk_faqconfigurationid", "mzk_name", "entityimage");
LinkEntity FAQContract = new LinkEntity("mzk_faqconfiguration", "mzk_faqconfigurationcontract", "mzk_faqconfigurationid", "mzk_faqconfiguration", JoinOperator.LeftOuter)
{
};
LinkEntity FAQContractManagement = new LinkEntity("mzk_faqconfigurationcontract", "mzk_contractmanagement", "mzk_contract", "mzk_contractmanagementid", JoinOperator.LeftOuter)
{
};
LinkEntity ContractReferral = new LinkEntity("mzk_contractmanagement", "opportunity", "mzk_contractmanagementid", "mzk_contract", JoinOperator.Inner)
{
LinkCriteria =
{
Conditions =
{
new ConditionExpression("mzk_status", ConditionOperator.Equal, 275380001), //Active
new ConditionExpression("mzk_status", ConditionOperator.Equal, 275380004) //Reviewed
},
FilterOperator = LogicalOperator.Or
},
};
LinkEntity ReferralPatient = new LinkEntity("opportunity", "contact", "parentcontactid", "contactid", JoinOperator.Inner)
{
LinkCriteria =
{
Conditions =
{
new ConditionExpression("contactid", ConditionOperator.Equal, new Guid(patientId)),
}
},
};
FAQContract.LinkEntities.Add(FAQContractManagement);
FAQContractManagement.LinkEntities.Add(ContractReferral);
ContractReferral.LinkEntities.Add(ReferralPatient);
query.LinkEntities.Add(FAQContract);
EntityCollection entitycollection = entityRepository.GetEntityCollection(query);
var groupedFAQS = entitycollection.Entities.GroupBy(item => (item.GetAttributeValue <Guid>("mzk_faqconfigurationid")));
foreach (var faqs in groupedFAQS)
{
foreach (Entity entity in faqs)
{
FrequentlyAskedQuestions FAQ = new FrequentlyAskedQuestions();
if (entity.Attributes.Contains("mzk_faqconfigurationid"))
{
FAQ.FAQId = entity["mzk_faqconfigurationid"].ToString();
}
if (entity.Attributes.Contains("mzk_name"))
{
FAQ.name = entity["mzk_name"].ToString();
}
if (entity.Attributes.Contains("entityimage"))
{
byte[] imageInBytes = (entity.Attributes["entityimage"]) as byte[];
FAQ.image = Convert.ToBase64String(imageInBytes);
}
FAQS.Add(FAQ);
break;
}
}
return(FAQS);
}
else
{
throw new ValidationException("Patient Id missing");
}
}
catch (Exception ex)
{
throw ex;
}
}
public void Run(ServerConnection.Configuration serverConfig,
bool promptforDelete)
{
using (_serviceProxy = new OrganizationServiceProxy(serverConfig.OrganizationUri, serverConfig.HomeRealmUri, serverConfig.Credentials, serverConfig.DeviceCredentials))
{
// This statement is required to enable early bound type support.
_serviceProxy.EnableProxyTypes();
CreateRequiredRecords();
Console.WriteLine("=== Creating and Qualifying Leads ===");
// Create two leads.
var lead1 = new Lead
{
CompanyName = "A. Datum Corporation",
FirstName = "Henriette",
LastName = "Andersen",
Subject = "Sample Lead 1"
};
_lead1Id = _serviceProxy.Create(lead1);
NotifyEntityCreated(Lead.EntityLogicalName, _lead1Id);
var lead2 = new Lead
{
CompanyName = "Adventure Works",
FirstName = "Michael",
LastName = "Sullivan",
Subject = "Sample Lead 2"
};
_lead2Id = _serviceProxy.Create(lead2);
NotifyEntityCreated(Lead.EntityLogicalName, _lead2Id);
// Qualify the first lead, creating an account and a contact from it, but
// not creating an opportunity.
var qualifyIntoAccountContactReq = new QualifyLeadRequest
{
CreateAccount = true,
CreateContact = true,
LeadId = new EntityReference(Lead.EntityLogicalName, _lead1Id),
Status = new OptionSetValue((int)lead_statuscode.Qualified)
};
var qualifyIntoAccountContactRes =
(QualifyLeadResponse)_serviceProxy.Execute(qualifyIntoAccountContactReq);
Console.WriteLine(" The first lead was qualified.");
foreach (var entity in qualifyIntoAccountContactRes.CreatedEntities)
{
NotifyEntityCreated(entity.LogicalName, entity.Id);
if (entity.LogicalName == Account.EntityLogicalName)
{
_leadAccountId = entity.Id;
}
else if (entity.LogicalName == Contact.EntityLogicalName)
{
_contactId = entity.Id;
}
}
// Retrieve the organization's base currency ID for setting the
// transaction currency of the opportunity.
var query = new QueryExpression("organization");
query.ColumnSet = new ColumnSet("basecurrencyid");
var result = _serviceProxy.RetrieveMultiple(query);
var currencyId = (EntityReference)result.Entities[0]["basecurrencyid"];
// Qualify the second lead, creating an opportunity from it, and not
// creating an account or a contact. We use an existing account for the
// opportunity customer instead.
var qualifyIntoOpportunityReq = new QualifyLeadRequest
{
CreateOpportunity = true,
OpportunityCurrencyId = currencyId,
OpportunityCustomerId = new EntityReference(
Account.EntityLogicalName,
_accountId),
Status = new OptionSetValue((int)lead_statuscode.Qualified),
LeadId = new EntityReference(Lead.EntityLogicalName, _lead2Id)
};
var qualifyIntoOpportunityRes =
(QualifyLeadResponse)_serviceProxy.Execute(qualifyIntoOpportunityReq);
Console.WriteLine(" The second lead was qualified.");
foreach (var entity in qualifyIntoOpportunityRes.CreatedEntities)
{
NotifyEntityCreated(entity.LogicalName, entity.Id);
if (entity.LogicalName == Opportunity.EntityLogicalName)
{
_opportunityId = entity.Id;
}
}
DeleteRecords(promptforDelete);
}
}
