/// <summary>
/// Adds the type T as a child linked entity, additionally ensuring it is active.
/// </summary>
/// <typeparam name="T">The type of Entity</typeparam>
/// <param name="link">The link.</param>
/// <param name="linkFromAttributeName">Name of the link from attribute.</param>
/// <param name="linkToAttributeName">Name of the link to attribute.</param>
/// <param name="joinType">Type of the join.</param>
/// <param name="anonymousTypeInitializer">An Anonymous Type Initializer where the properties of the anonymous
/// type are the column names to add</param>
/// <returns></returns>
public static LinkEntity AddLink <T>(this LinkEntity link, string linkFromAttributeName, string linkToAttributeName, JoinOperator joinType, Expression <Func <T, object> > anonymousTypeInitializer) where T : Entity
{
var childLink = link.AddLink(linkFromAttributeName, linkToAttributeName, joinType);
childLink.Columns.AddColumns(anonymousTypeInitializer);
return(childLink);
}
public static LinkEntity AddLink <TFrom, TTo>(this LinkEntity linkEntity,
Expression <Func <TFrom, object> > fromAttribute,
Expression <Func <TTo, object> > toAttribute,
JoinOperator joinOperator)
where TFrom : Entity
where TTo : Entity =>
linkEntity.AddLink(Name <TTo>(), Name(fromAttribute), Name(toAttribute), joinOperator);
/// <summary>
/// Gets the latest active membership of a member.
/// </summary>
public Guid GetLatestActiveMembershipId(string membershipNumber, bool ignoreLifeTimeMemberships = false)
{
QueryExpression query = new QueryExpression {
EntityName = "mag_membership"
};
query.Criteria.AddCondition("mag_idnumber", ConditionOperator.Equal, membershipNumber);
//query.Criteria.AddCondition("statuscode", ConditionOperator.Equal, 809730001); // active
query.Criteria.AddCondition("statuscode", ConditionOperator.In, new object[] { 809730001, 809730005 }); // active OR service end - PN - 27/11/13
query.AddOrder("mag_startdate", OrderType.Descending);
// this is used by the renewal process, lifetime memberships dont need to be renewd
if (ignoreLifeTimeMemberships)
{
LinkEntity le = query.AddLink("product", "mag_membershiptypeid", "productid", JoinOperator.Inner);
//le.LinkCriteria.AddCondition("name", ConditionOperator.NotEqual, "Lifetime Membership");
LinkEntity unit = le.AddLink("uom", "defaultuomid", "uomid", JoinOperator.Inner); // Needs to look at the Unit name, as many products can be lifetime memberships - PN - 27/11/13
unit.LinkCriteria.AddCondition("name", ConditionOperator.NotEqual, "Lifetime");
}
EntityCollection results = this._sdk.RetrieveMultiple(query);
if (results != null && results.Entities != null && results.Entities.Count > 0)
{
return(results[0].Get <Guid>("mag_membershipid"));
}
return(Guid.Empty);
}
public void AddLink2Test()
{
// Setup
string expectedFromEntityName = EntityFrom.EnityLogicalName;
string expectedToEntityName = EntityTo.EnityLogicalName;
string expectedFromAttributName = nameof(EntityFrom.FromId).ToLower();
string expectedToAttributName = nameof(EntityTo.ToId).ToLower();
LinkEntity linkEntity = new LinkEntity()
{
LinkFromEntityName = expectedFromEntityName
};
// Act
LinkEntity newLink = linkEntity.AddLink <EntityFrom, EntityTo>(
EntityTo.EnityLogicalName,
f => f.FromId,
t => t.ToId);
// Assert
Assert.AreEqual(expectedFromEntityName, newLink.LinkFromEntityName);
Assert.AreEqual(expectedToEntityName, newLink.LinkToEntityName);
Assert.AreEqual(expectedToAttributName, newLink.LinkToAttributeName);
Assert.AreEqual(expectedFromAttributName, newLink.LinkFromAttributeName);
}
/// <summary>
/// Returns a list of application questions that are applicable to an application
/// based on the application lines and items linked to the application
/// </summary>
/// <param name="applicationId">Guid for the application to check</param>
/// <returns>A simplified array of application questions and application line ids that are applicable</returns>
public List <ApplicationQuestionsAndLines> GetApplicableApplicationQuestions(Guid applicationId)
{
// 1. Prepare query, start with application line
QueryExpression query = new QueryExpression(defra_applicationline.EntityLogicalName);
query.ColumnSet.AddColumns(defra_applicationline.Fields.defra_applicationlineId);
query.Criteria.AddCondition(defra_applicationline.Fields.StateCode, ConditionOperator.Equal,
(int)defra_applicationlineState.Active);
query.Criteria.AddCondition(defra_applicationline.Fields.defra_applicationId, ConditionOperator.Equal,
applicationId);
// 2. Link to Item
LinkEntity linkItem = query.AddLink(defra_item.EntityLogicalName, defra_item.Fields.defra_itemId,
defra_item.Fields.defra_itemId);
linkItem.LinkCriteria.AddCondition(defra_item.Fields.StateCode, ConditionOperator.Equal,
(int)defra_itemState.Active);
// 3. Link to Item Application Question linker table
LinkEntity linkItemApplicationQuestion = linkItem.AddLink(defra_item_application_question.EntityLogicalName,
defra_item.Fields.defra_itemId, defra_item_application_question.Fields.defra_itemid);
linkItemApplicationQuestion.LinkCriteria.AddCondition(defra_item_application_question.Fields.StateCode,
ConditionOperator.Equal, (int)defra_item_application_questionState.Active);
linkItemApplicationQuestion.Columns.AddColumns(defra_item_application_question.Fields.defra_scope);
linkItemApplicationQuestion.EntityAlias = "linker";
// 4. Link to Application Question
LinkEntity linkQuestion = linkItemApplicationQuestion.AddLink(
defra_applicationquestion.EntityLogicalName,
defra_item_application_question.Fields.defra_applicationquestionid,
defra_applicationquestion.Fields.defra_applicationquestionId);
linkQuestion.EntityAlias = "question";
linkQuestion.Columns.AddColumns(defra_applicationquestion.Fields.defra_applicationquestionId);
linkQuestion.LinkCriteria.AddCondition(defra_applicationquestion.Fields.StateCode, ConditionOperator.Equal,
(int)defra_applicationquestionState.Active);
// Talk to CRM, get results
EntityCollection resultEntities = OrganisationService.RetrieveMultiple(query);
// No results
if (resultEntities?.Entities == null || resultEntities.Entities.Count < 1)
{
return(null);
}
// Return simple model result
string scopeAttributeName = $"{linkItemApplicationQuestion.EntityAlias}.{defra_item_application_question.Fields.defra_scope}";
string questionIdAttributeName = $"{linkQuestion.EntityAlias}.{defra_applicationquestion.Fields.defra_applicationquestionId}";
return(resultEntities.Entities.Select(entity =>
new ApplicationQuestionsAndLines
{
ApplicationLineId = entity.GetAttributeId(defra_applicationline.Fields.defra_applicationlineId),
ApplicationQuestionId = entity.GetAliasedAttributeId(questionIdAttributeName),
Scope = entity.GetAliasedOptionSetValue(scopeAttributeName),
}).ToList());
}
public static void AddRequiredQueryJoins(this XrmService xrmService, QueryExpression query, string source)
{
var typeFieldPaths = xrmService.GetTypeFieldPath(source, query.EntityName);
var splitOutFunction = source.Split(':');
if (splitOutFunction.Count() > 1)
{
source = splitOutFunction.ElementAt(1);
}
var splitTokens = source.Split('.');
if (typeFieldPaths.Count() == 1)
{
query.ColumnSet.AddColumn(typeFieldPaths.First().Value);
}
else
{
LinkEntity thisLink = null;
for (var i = 0; i < typeFieldPaths.Count() - 1; i++)
{
var lookupField = typeFieldPaths.ElementAt(i).Value;
var path = string.Join(".", splitTokens.Take(i + 1)).Replace("|", "_");
if (i == 0)
{
var targetType = typeFieldPaths.ElementAt(i + 1).Key;
var matchingLinks = query.LinkEntities.Where(le => le.EntityAlias == path);
if (matchingLinks.Any())
{
thisLink = matchingLinks.First();
}
else
{
thisLink = query.AddLink(targetType, lookupField, xrmService.GetPrimaryKeyField(targetType), JoinOperator.LeftOuter);
thisLink.EntityAlias = path;
thisLink.Columns = xrmService.CreateColumnSet(new string[0]);
}
}
else
{
var targetType = xrmService.GetLookupTargetEntity(lookupField, thisLink.LinkToEntityName);
var matchingLinks = thisLink.LinkEntities.Where(le => le.EntityAlias == path);
if (matchingLinks.Any())
{
thisLink = matchingLinks.First();
}
else
{
thisLink = thisLink.AddLink(targetType, lookupField, xrmService.GetPrimaryKeyField(targetType), JoinOperator.LeftOuter);
thisLink.EntityAlias = path;
thisLink.Columns = xrmService.CreateColumnSet(new string[0]);
}
}
}
thisLink.Columns.AddColumn(typeFieldPaths.ElementAt(typeFieldPaths.Count() - 1).Value);
}
}
public LinkEntity AddLink(string linkToEntityName, string linkFromAttributeName, string linkToAttributeName, ConditionExpression linkCriteria = null)
{
var link = _query?.AddLink(linkToEntityName, linkFromAttributeName, linkToAttributeName, JoinOperator.LeftOuter)
?? _link.AddLink(linkToEntityName, linkFromAttributeName, linkToAttributeName, JoinOperator.LeftOuter);
if (linkCriteria != null)
{
link.LinkCriteria.AddCondition(linkCriteria);
}
return(link);
}
private List <CrmEarlyBound.Campaign> GetAllStartedCampaignsThatMarketingListIsAssociated(IOrganizationService service, List listId)
{
QueryExpression QEcampaign = new QueryExpression("campaign");
QEcampaign.ColumnSet.AddColumns("find_mailchimpcampaignid", "name", "find_platformmarketing");
QEcampaign.Criteria.AddCondition("find_mail_integration_started", ConditionOperator.Equal, false);
LinkEntity QEcampaign_campaignitem = QEcampaign.AddLink("campaignitem", "campaignid", "campaignid");
LinkEntity QEcampaign_campaignitem_list = QEcampaign_campaignitem.AddLink("list", "entityid", "listid");
QEcampaign_campaignitem_list.LinkCriteria.AddCondition("listid", ConditionOperator.Equal, listId.Id);
return(service.RetrieveMultiple(QEcampaign).Entities.Select(entity => entity.ToEntity <CrmEarlyBound.Campaign>()).ToList());
}
public void Can_add_link_generic_from_to_on_link_entity()
{
var linkEntity = new LinkEntity
{
LinkFromEntityName = xts_entity.EntityLogicalName
};
linkEntity.AddLink <xts_entity, xts_relatedentity>(e => e.xts_attribute, e => e.xts_relatedid);
var linkedLinkEntity = linkEntity.LinkEntities[0];
Assert.Equal("xts_entity", linkedLinkEntity.LinkFromEntityName);
Assert.Equal("xts_relatedentity", linkedLinkEntity.LinkToEntityName);
Assert.Equal("xts_attribute", linkedLinkEntity.LinkFromAttributeName);
Assert.Equal("xts_relatedid", linkedLinkEntity.LinkToAttributeName);
}
private IDictionary <Guid, string> IndexUserTimeZones(List <Guid> usersToNotifyIds)
{
var linkEntity = new LinkEntity(Entities.systemuser, Entities.usersettings, Fields.systemuser_.systemuserid, Fields.usersettings_.systemuserid, JoinOperator.Inner);
var tzLink = linkEntity.AddLink(Entities.timezonedefinition, Fields.usersettings_.timezonecode, Fields.timezonedefinition_.timezonecode);
tzLink.EntityAlias = "TZ";
tzLink.Columns = XrmService.CreateColumnSet(new[] { Fields.timezonedefinition_.standardname });
var users = XrmService.RetrieveAllOrClauses(Entities.systemuser
, usersToNotifyIds.Select(uid => new ConditionExpression(Fields.systemuser_.systemuserid, ConditionOperator.Equal, uid))
, new string[0]
, linkEntity);
return(users
.ToDictionary(u => u.Id, u => (string)u.GetFieldValue("TZ." + Fields.timezonedefinition_.standardname)));
}
public void AddLink2Test()
{
// Setup
string expectedFromEntityName = EntityFrom.EnityLogicalName;
string expectedToEntityName = EntityTo.EnityLogicalName;
string expectedFromAttributName = nameof(EntityFrom.FromId).ToLower();
string expectedToAttributName = nameof(EntityTo.ToId).ToLower();
JoinOperator expectedOperator = JoinOperator.Inner;
// Act
LinkEntity <EntityFrom, EntityTo> linkGen = new LinkEntity <EntityFrom, EntityTo>
{
LinkFromEntityName = expectedFromEntityName
};
LinkEntity newLink = linkGen.AddLink(f => f.FromId, t => t.ToId);
// Assert
Assert.AreEqual(expectedFromEntityName, newLink.LinkFromEntityName);
Assert.AreEqual(expectedToEntityName, newLink.LinkToEntityName);
Assert.AreEqual(expectedFromAttributName, newLink.LinkFromAttributeName);
Assert.AreEqual(expectedToAttributName, newLink.LinkToAttributeName);
Assert.AreEqual(expectedOperator, newLink.JoinOperator);
}
private void AddReferenceConfigJoins(LinkEntity linkToReferenced, Entity thisEntity, string field)
{
var referencedType = XrmEntity.GetLookupType(thisEntity.GetFieldValue(field));
var referencedTypeConfig = XrmRecordService.GetTypeConfigs().GetFor(referencedType);
if (referencedTypeConfig != null && referencedTypeConfig.UniqueChildFields != null)
{
foreach (var uniqueField in referencedTypeConfig.UniqueChildFields)
{
var theValue = thisEntity.GetFieldValue($"{field}.{uniqueField}");
if (theValue == null)
{
linkToReferenced.LinkCriteria.AddCondition(new ConditionExpression(uniqueField, ConditionOperator.Null));
}
else if (theValue is EntityReference)
{
var name = XrmEntity.GetLookupName(theValue);
var type = XrmEntity.GetLookupType(theValue);
var nextLinkToReferenced = linkToReferenced.AddLink(type, uniqueField, XrmService.GetPrimaryKeyField(type));
if (name == null)
{
nextLinkToReferenced.LinkCriteria.AddCondition(XrmService.GetPrimaryNameField(type), ConditionOperator.Null);
}
else
{
nextLinkToReferenced.LinkCriteria.AddCondition(XrmService.GetPrimaryNameField(type), ConditionOperator.Equal, name);
AddReferenceConfigJoins(nextLinkToReferenced, thisEntity, $"{field}.{uniqueField}");
}
}
else
{
linkToReferenced.LinkCriteria.AddCondition(new ConditionExpression(uniqueField, ConditionOperator.Equal, XrmService.ConvertToQueryValue(uniqueField, referencedType, theValue)));
}
}
}
}
public List <T> ListarPorCriterioDeParaContas(DeParaDeUnidadeDoKonviva objDePara, Guid idUnidadePadrao)
{
var query = GetQueryExpression <T>(true);
#region Condições
query.ColumnSet = new ColumnSet(true);
query.Distinct = true;
#region Status
query.Criteria.Conditions.Add(new ConditionExpression("statecode", ConditionOperator.Equal, (int)Domain.Enum.StateCode.Ativo));
#endregion
query.Criteria.Conditions.Add(new ConditionExpression("itbc_unidadekonvivaid", ConditionOperator.Equal, idUnidadePadrao));
LinkEntity link = query.AddLink("contact", "itbc_contatoid", "contactid", JoinOperator.Inner);
link.EntityAlias = "ctt";
LinkEntity link2 = link.AddLink("account", "parentcustomerid", "accountid", JoinOperator.Inner);
link2.EntityAlias = "act";
if (objDePara.Categoria != null)
{
LinkEntity link3 = link2.AddLink("itbc_categoriasdocanal", "accountid", "itbc_canalid", JoinOperator.Inner);
link3.EntityAlias = "cat";
query.Criteria.AddCondition("cat", "itbc_categoria", ConditionOperator.Equal, objDePara.Categoria.Id);
}
query.Criteria.AddCondition("act", "itbc_classificacaoid", ConditionOperator.Equal, objDePara.Classificacao.Id);
query.Criteria.AddCondition("act", "itbc_subclassificacaoid", ConditionOperator.Equal, objDePara.SubClassificacao.Id);
query.Criteria.AddCondition("ctt", "statecode", ConditionOperator.Equal, (int)Domain.Enum.CategoriaCanal.StateCode.Ativado);
#endregion
return((List <T>) this.RetrieveMultiple(query).List);
}
/// <summary>
/// Assumes that the linkFromAttributeName and the linkToAttributeName are the same
/// </summary>
/// <param name="link">The link.</param>
/// <param name="linkToEntityName">Name of the link to entity.</param>
/// <param name="linkAttributesName">Name of the link from and link to attribute.</param>
/// <param name="joinType">Type of the join to perform.</param>
/// <returns></returns>
public static LinkEntity AddLink(this LinkEntity link, string linkToEntityName, string linkAttributesName, JoinOperator joinType)
{
return(link.AddLink(linkToEntityName, linkAttributesName, linkAttributesName, joinType));
}
/// <summary>
/// Assumes that the linkFromAttributeName and the linkToAttributeName are the same
/// </summary>
/// <param name="link">The link.</param>
/// <param name="linkToEntityName">Name of the link to entity.</param>
/// <param name="linkAttributesName">Name of the link from and link to attribute.</param>
/// <returns></returns>
public static LinkEntity AddLink(this LinkEntity link, string linkToEntityName, string linkAttributesName)
{
return(link.AddLink(linkToEntityName, linkAttributesName, linkAttributesName));
}
/// <summary>
/// Adds the type T as a child linked entity, additionally ensuring it is active.
/// Assumes both entities have the same attribute name to link on.
/// </summary>
/// <typeparam name="T">The type of the entity that is to me linked</typeparam>
/// <param name="link">The link.</param>
/// <param name="linkAttributesName">Name of the link from and link to attribute.</param>
/// <param name="joinType">Type of the join to perform.</param>
/// <param name="anonymousTypeInitializer">An Anonymous Type Initializer where the properties of the anonymous
/// type are the column names to add</param>
/// <returns></returns>
public static LinkEntity AddLink <T>(this LinkEntity link, string linkAttributesName, JoinOperator joinType, Expression <Func <T, object> > anonymousTypeInitializer) where T : Entity
{
return(link.AddLink(linkAttributesName, linkAttributesName, joinType, anonymousTypeInitializer));
}
/// <summary>
/// Adds the type T as a child linked entity, additionally ensuring it is active.
/// Assumes both entities have the same attribute name to link on.
/// </summary>
/// <typeparam name="T">The type of the entity that is to me linked</typeparam>
/// <param name="link">The link.</param>
/// <param name="linkAttributesName">Name of the link from and link to attribute.</param>
/// <param name="joinType">Type of the join to perform.</param>
/// <returns></returns>
public static LinkEntity AddLink <T>(this LinkEntity link, string linkAttributesName, JoinOperator joinType) where T : Entity
{
return(link.AddLink <T>(linkAttributesName, linkAttributesName, joinType));
}
/// <summary>
/// Adds the type T as a child linked entity to the LinkEntity, additionally ensuring it is active.
/// Assumes both entities have the same attribute name to link on.
/// </summary>
/// <typeparam name="T">The type of the entity that is to be linked</typeparam>
/// <param name="link">The link.</param>
/// <param name="linkAttributesName">Name of the link from and link to attribute.</param>
/// <returns></returns>
public static LinkEntity AddLink <T>(this LinkEntity link, string linkAttributesName) where T : Entity
{
return(link.AddLink <T>(linkAttributesName, linkAttributesName));
}
public override void PostUpdate(Entity entity, ConnectionHelper helper)
{
Entity image = helper.PluginExecutionContext.PostEntityImages["Image"];
if (entity.Contains("nmc_syncmembers") &&
entity["nmc_syncmembers"] != null &&
(bool)entity["nmc_syncmembers"])
{
Common.LogToCRM(helper.OrganizationService, $"Marketing list sync triggered: {entity.Id.ToString()}", "Update triggered on marketing list record");
try
{
#region check config params
string apikey = Common.GetParamValue(helper.OrganizationService, "ApiKey");
string userid = Common.GetParamValue(helper.OrganizationService, "UserId");
string nmList = Common.GetParamValue(helper.OrganizationService, "Default List");
if (apikey == null || userid == null || nmList == null)
{
Common.LogToCRM(helper.OrganizationService, $"Marketing list sync ignored: {entity.Id.ToString()}", "Missing Newsman API configuration!");
return;
}
#endregion
using (NewsmanAPI api = new NewsmanAPI(apikey, userid))
{
#region Generate query criteria
int memberTypeCode = image.GetOptionSetValue("createdfromcode");
string memberType = memberTypeCode == 1 ? "account" : (memberTypeCode == 2 ? "contact" : "lead");
QueryExpression qry = new QueryExpression(memberType);
ColumnSet cols = null;
switch (memberType)
{
case "account":
cols = new ColumnSet("name", "emailaddress1", "emailaddress2", "emailaddress3");
break;
case "contact":
case "lead":
cols = new ColumnSet("firstname", "lastname", "emailaddress1", "emailaddress2", "emailaddress3");
break;
default:
cols = new ColumnSet(false);
break;
}
qry.ColumnSet = cols;
LinkEntity listMember = qry.AddLink("listmember", memberType + "id", "entityid", JoinOperator.Inner);
LinkEntity list = listMember.AddLink("list", "listid", "listid");
list.LinkCriteria.AddCondition("listid", ConditionOperator.Equal, entity.Id);
#endregion
#region Send to Newsman
StringBuilder importIDs = new StringBuilder();
int totalRecordCount = 0;
string segment = (string)image.GetValue("nmc_newsmansegmentid");
qry.PageInfo = new PagingInfo();
qry.PageInfo.Count = 5000;
qry.PageInfo.PageNumber = 1;
qry.PageInfo.PagingCookie = null;
qry.PageInfo.ReturnTotalRecordCount = true;
EntityCollection members = helper.OrganizationService.RetrieveMultiple(qry);
Common.LogToCRM(helper.OrganizationService, $"Started synchronization for {(string)image["listname"]}", $"First page has {members.TotalRecordCount.ToString("N0")} record(s)");
totalRecordCount += members.TotalRecordCount;
//first batch
string importId = api.ImportSubscribers(nmList, segment, Common.CreateSubscribers(members));
importIDs.Append($"{importId};");
//rest of the batches
while (members.MoreRecords)
{
members = helper.OrganizationService.RetrieveMultiple(qry);
importId = api.ImportSubscribers(nmList, segment, Common.CreateSubscribers(members));
importIDs.Append($"{importId};");
qry.PageInfo.PageNumber++;
qry.PageInfo.PagingCookie = members.PagingCookie;
totalRecordCount += members.TotalRecordCount;
}
;
Common.LogToCRM(helper.OrganizationService, $"Finished synchronization for {(string)image["listname"]}", $"Total number of records is: {totalRecordCount.ToString("N0")}. List of generated Newsman import ids: {importIDs.ToString()}");
#endregion
}
}
catch (Exception ex)
{
Common.LogToCRM(helper.OrganizationService, $"Error syncing list members for {(string)image["listname"]}", $"Error message:{ex.Message}, stack trace: {ex.StackTrace}");
}
finally
{
Entity resetList = new Entity(entity.LogicalName, entity.Id);
resetList.Attributes["nmc_syncmembers"] = false;
helper.OrganizationService.Update(resetList);
}
}
}
/// <summary>
/// Return the entity record which is configured as the logical parent of this records autonumber
/// </summary>
public Entity GetParentEntity(Entity entity, XrmAutonumber autonumber, IEnumerable <string> fields)
{
//Need to split the links to the parent and create a query which returns the parent record via the links
if (!entity.Contains(autonumber.FirstLinkLookup))
{
return(null);
}
//Create a query which traverses through the keys and entities we defined in our autonumber links
var query = new QueryExpression();
query.ColumnSet = XrmService.CreateColumnSet(fields);
LinkEntity carry = null;
//for each foreign key entity pairing work from last to first
for (var i = autonumber.LinksToParent.LinkToParents.Count(); i > 0; i--)
{
var thisLink = autonumber.LinksToParent.LinkToParents.ElementAt(i - 1);
//if this is the last item we need to create it as the type of entity we are returning
if (i == autonumber.LinksToParent.LinkToParents.Count())
{
query.EntityName = thisLink.LinkTarget;
}
//otherwise if this is not the last item we need to add a link from the previous type to this type
else
{
var previousPair = autonumber.LinksToParent.LinkToParents.ElementAt(i);
if (carry == null)
{
carry = query.AddLink(thisLink.LinkTarget, previousPair.LinkFieldTarget, previousPair.LinkFieldSource);
}
else
{
carry = carry.AddLink(thisLink.LinkTarget, previousPair.LinkFieldTarget, previousPair.LinkFieldSource);
}
}
//if this is the first item we need to add a filter on the first id with the value in the lookup from the record we are creating the autonumber for
if (i == 1)
{
var thisLookupId = entity.GetLookupGuid(thisLink.LinkFieldSource);
if (!thisLookupId.HasValue)
{
return(null);
}
if (autonumber.LinksToParent.LinkToParents.Count() != 1)
{
carry.LinkCriteria.AddCondition(carry.LinkToEntityName + "id", ConditionOperator.Equal, thisLookupId.Value);
}
else
{
query.Criteria.AddCondition(query.EntityName + "id", ConditionOperator.Equal, thisLookupId.Value);
}
}
}
//Run the query and if a result return it
var parent = XrmService.RetrieveMultiple(query);
if (parent.Entities.Count > 0)
{
return(parent.Entities[0]);
}
return(null);
}
