public EntityMetadata GetEntityMetadata(Dynamics365Connection connection)
{
ConnectionCache cache = new ConnectionCache(connection);
string cacheKey = string.Format("GetEntityMetadata:{0}", LogicalName);
EntityMetadata entityMetadata = (EntityMetadata)cache[cacheKey];
if (entityMetadata == default(EntityMetadata))
{
RetrieveEntityRequest request = new RetrieveEntityRequest()
{
EntityFilters = EntityFilters.Attributes,
LogicalName = LogicalName,
RetrieveAsIfPublished = true
};
using (OrganizationServiceProxy proxy = (connection).OrganizationServiceProxy)
{
RetrieveEntityResponse response = (RetrieveEntityResponse)proxy.Execute(request);
entityMetadata = response.EntityMetadata;
}
cache[cacheKey] = entityMetadata;
}
return(entityMetadata);
}
/// <summary>
/// Creates a new instance of the Dynamics365Entity class from an entity with the specified logical name in the specified Dynamics instance.
/// </summary>
/// <param name="logicalName"></param>
/// <param name="connection"></param>
/// <returns></returns>
public static Dynamics365Entity Create(string logicalName, Dynamics365Connection connection)
{
ConnectionCache cache = new ConnectionCache(connection);
string cacheKey = string.Format("GetEntity:{0}", logicalName);
Dynamics365Entity entity = (Dynamics365Entity)cache[cacheKey];
if (entity == null)
{
RetrieveEntityRequest request = new RetrieveEntityRequest()
{
LogicalName = logicalName,
EntityFilters = EntityFilters.Attributes,
RetrieveAsIfPublished = false
};
using (OrganizationServiceProxy proxy = connection.OrganizationServiceProxy)
{
RetrieveEntityResponse response = (RetrieveEntityResponse)proxy.Execute(request);
entity = CreateFromMetadata(response.EntityMetadata, connection, true);
}
cache[cacheKey] = entity;
}
return(entity);
}
/// <summary>
/// Gets entity fields relevant to the operation type.
/// </summary>
/// <param name="operationType">The operation type.</param>
/// <returns>The fields.</returns>
public static List <Dynamics365Field> GetFields(Dynamics365Entity entity, Dynamics365Connection connection)
{
if (entity == default(Dynamics365Entity))
{
throw new ArgumentException("Entity cannot be null", nameof(entity));
}
if (connection == default(Dynamics365Connection))
{
throw new ArgumentException("Connection cannot be null", nameof(connection));
}
ConnectionCache cache = new ConnectionCache(connection);
string cacheKey = string.Format("GetFields:{0}", entity.LogicalName);
List <Dynamics365Field> fields = (List <Dynamics365Field>)cache[cacheKey];
if (fields == default(List <Dynamics365Field>))
{
fields = new List <Dynamics365Field>();
RetrieveEntityRequest request = new RetrieveEntityRequest()
{
LogicalName = entity.LogicalName,
EntityFilters = EntityFilters.Attributes,
RetrieveAsIfPublished = false
};
using (OrganizationServiceProxy proxy = connection.OrganizationServiceProxy)
{
RetrieveEntityResponse response = (RetrieveEntityResponse)proxy.Execute(request);
foreach (AttributeMetadata attributeMetadata in response.EntityMetadata.Attributes)
{
if ((bool)attributeMetadata.IsValidForRead)
{
Dynamics365Field field = CreateFromMetadata(attributeMetadata, connection);
if (field != null)
{
fields.Add(field);
}
}
}
}
fields.Sort((field1, field2) => field1.DisplayName.CompareTo(field2.DisplayName));
cache[string.Format(cacheKey, entity.LogicalName)] = fields;
}
return(fields);
}
public static List <Dynamics365Process> GetProcesses(Dynamics365Connection connection, string entityLogicalName)
{
ConnectionCache cache = new ConnectionCache(connection);
string cacheKey = "GetProcesses";
List <Dynamics365Process> processes = (List <Dynamics365Process>)cache[cacheKey];
if (processes == default(List <Dynamics365Process>))
{
processes = new List <Dynamics365Process>();
processes.Sort((process1, process2) => process1.Name.CompareTo(process2.Name));
cache[cacheKey] = processes;
}
return(processes);
}
/// <summary>
///
/// </summary>
/// <param name="connection"></param>
/// <param name="entityLogicalName"></param>
/// <returns></returns>
public static List <Dynamics365Workflow> GetWorkflows(Dynamics365Connection connection, string entityLogicalName)
{
ConnectionCache cache = new ConnectionCache(connection);
string cacheKey = string.Format("GetOnDemandWorkflows:{0}", entityLogicalName);
List <Dynamics365Workflow> workflows = (List <Dynamics365Workflow>)cache[cacheKey];
if (workflows == default(List <Dynamics365Workflow>))
{
workflows = new List <Dynamics365Workflow>();
QueryExpression workflowQuery = new QueryExpression("workflow")
{
ColumnSet = new ColumnSet(true)
};
using (OrganizationServiceProxy proxy = connection.OrganizationServiceProxy)
{
workflowQuery.Criteria.AddCondition(new ConditionExpression("category", ConditionOperator.Equal, 0)); // workflow
workflowQuery.Criteria.AddCondition(new ConditionExpression("primaryentity", ConditionOperator.Equal, entityLogicalName));
workflowQuery.Criteria.AddCondition(new ConditionExpression("statecode", ConditionOperator.Equal, 1)); // activated
workflowQuery.Criteria.AddCondition(new ConditionExpression("type", ConditionOperator.Equal, 1)); // definition
workflowQuery.Criteria.AddCondition(new ConditionExpression("ondemand", ConditionOperator.Equal, true));
RetrieveMultipleRequest workflowRequest = new RetrieveMultipleRequest()
{
Query = workflowQuery
};
RetrieveMultipleResponse workflowResponse = (RetrieveMultipleResponse)proxy.Execute(workflowRequest);
foreach (Microsoft.Xrm.Sdk.Entity workflowMetadata in workflowResponse.EntityCollection.Entities)
{
workflows.Add(new Dynamics365Workflow()
{
ID = workflowMetadata.Id,
Name = workflowMetadata.Attributes["name"].ToString()
});
}
}
workflows.Sort((workflow1, workflow2) => workflow1.Name.CompareTo(workflow2.Name));
cache[cacheKey] = workflows;
}
return(workflows);
}
public static List <Dynamics365Team> GetTeams(Dynamics365Connection connection)
{
ConnectionCache cache = new ConnectionCache(connection);
string cacheKey = "GetTeams:{0}";
List <Dynamics365Team> teams = (List <Dynamics365Team>)cache[cacheKey];
if (teams == default(List <Dynamics365Team>))
{
teams = new List <Dynamics365Team>();
QueryExpression teamQuery = new QueryExpression("team")
{
ColumnSet = new ColumnSet(true)
};
using (OrganizationServiceProxy proxy = connection.OrganizationServiceProxy)
{
if (connection.IsVersionOrAbove(CrmVersion.Crm2013))
{
teamQuery.Criteria.AddCondition(new ConditionExpression("teamtype", ConditionOperator.Equal, 0));
}
RetrieveMultipleRequest teamRequest = new RetrieveMultipleRequest()
{
Query = teamQuery
};
RetrieveMultipleResponse teamResponse = (RetrieveMultipleResponse)proxy.Execute(teamRequest);
foreach (Microsoft.Xrm.Sdk.Entity teamMetadata in teamResponse.EntityCollection.Entities)
{
teams.Add(new Dynamics365Team()
{
ID = teamMetadata.Id,
Name = teamMetadata.Attributes["name"].ToString()
});
}
teams.Sort((team1, team2) => team1.Name.CompareTo(team2.Name));
}
cache[cacheKey] = teams;
}
return(teams);
}
/// <summary>
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
public static List <Dynamics365Solution> GetSolutions(Dynamics365Connection connection)
{
ConnectionCache cache = new ConnectionCache(connection);
string cacheKey = "GetSolutions:{0}";
List <Dynamics365Solution> solutions = (List <Dynamics365Solution>)cache[cacheKey];
if (solutions == default(List <Dynamics365Solution>))
{
// get a list of all solutions in the specified Dynamics 365 instance.
solutions = new List <Dynamics365Solution>();
using (OrganizationServiceProxy proxy = connection.OrganizationServiceProxy)
{
QueryExpression query = new QueryExpression()
{
EntityName = "solution",
ColumnSet = new ColumnSet(true),
Criteria = new FilterExpression()
};
EntityCollection response = proxy.RetrieveMultiple(query);
foreach (Entity entity in response.Entities)
{
Dynamics365Solution solution = new Dynamics365Solution()
{
UniqueName = entity.Attributes["uniquename"].ToString(),
FriendlyName = entity.Attributes["friendlyname"].ToString(),
Version = entity.Attributes["version"].ToString()
};
solutions.Add(solution);
}
solutions.Sort((solution1, solution2) => solution1.FriendlyName.CompareTo(solution2.FriendlyName));
}
cache[cacheKey] = solutions;
}
return(solutions);
}
public static List <Dynamics365User> GetUsers(Dynamics365Connection connection)
{
ConnectionCache cache = new ConnectionCache(connection);
string cacheKey = "GetUsers";
List <Dynamics365User> users = (List <Dynamics365User>)cache[cacheKey];
if (users == null)
{
users = new List <Dynamics365User>();
QueryExpression userQuery = new QueryExpression("systemuser")
{
ColumnSet = new ColumnSet(true)
};
RetrieveMultipleRequest userRequest = new RetrieveMultipleRequest()
{
Query = userQuery
};
using (OrganizationServiceProxy proxy = (connection).OrganizationServiceProxy)
{
RetrieveMultipleResponse formResponse = (RetrieveMultipleResponse)proxy.Execute(userRequest);
foreach (Entity userMetadata in formResponse.EntityCollection.Entities)
{
Dynamics365User user = new Dynamics365User()
{
ID = userMetadata.Id,
Name = userMetadata.Attributes["fullname"].ToString()
};
users.Add(user);
}
users.Sort((user1, user2) => user1.Name.CompareTo(user2.Name));
}
cache[cacheKey] = users;
}
return(users);
}
/// <summary>
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
public static List <Dynamics365Entity> GetEntities(Dynamics365Connection connection)
{
ConnectionCache cache = new ConnectionCache(connection);
string cacheKey = "GetEntities";
List <Dynamics365Entity> entities = (List <Dynamics365Entity>)cache[cacheKey];
if (entities == default(List <Dynamics365Entity>))
{
// Gets a list of all entities in the specified Dynamics 365 instance.
entities = new List <Dynamics365Entity>();
RetrieveAllEntitiesRequest request = new RetrieveAllEntitiesRequest()
{
EntityFilters = EntityFilters.Entity,
RetrieveAsIfPublished = false
};
using (OrganizationServiceProxy proxy = connection.OrganizationServiceProxy)
{
RetrieveAllEntitiesResponse response = (RetrieveAllEntitiesResponse)proxy.Execute(request);
foreach (EntityMetadata entityMetadata in response.EntityMetadata)
{
if (entityMetadata.DisplayName.UserLocalizedLabel != null && (entityMetadata.IsCustomizable.Value || !entityMetadata.IsManaged.Value || entityMetadata.LogicalName == "asyncoperation" || entityMetadata.LogicalName == "post"))
{
Dynamics365Entity entity = CreateFromMetadata(entityMetadata, connection, false);
entities.Add(entity);
}
}
entities.Sort((entity1, entity2) => entity1.DisplayName.CompareTo(entity2.DisplayName));
}
cache[cacheKey] = entities;
}
return(entities);
}
public static List <Dynamics365State> GetStates(Dynamics365Entity entity, Dynamics365Connection connection)
{
ConnectionCache cache = new ConnectionCache(connection);
string cacheKey = string.Format("GetStates:{0}", entity.LogicalName);
List <Dynamics365State> states = (List <Dynamics365State>)cache[cacheKey];
if (states == null)
{
states = new List <Dynamics365State>();
RetrieveEntityRequest request = new RetrieveEntityRequest()
{
LogicalName = entity.LogicalName,
EntityFilters = EntityFilters.Attributes,
RetrieveAsIfPublished = false
};
using (OrganizationServiceProxy proxy = connection.OrganizationServiceProxy)
{
RetrieveEntityResponse response = (RetrieveEntityResponse)proxy.Execute(request);
StateAttributeMetadata stateMetadata = (StateAttributeMetadata)response.EntityMetadata.Attributes.FirstOrDefault(findField => findField is StateAttributeMetadata);
if (stateMetadata != null)
{
foreach (StateOptionMetadata stateOption in stateMetadata.OptionSet.Options)
{
Dynamics365State state = new Dynamics365State()
{
Code = (int)stateOption.Value,
Name = stateOption.Label.UserLocalizedLabel.Label,
LogicalName = stateMetadata.LogicalName
};
StatusAttributeMetadata statusMetadata = (StatusAttributeMetadata)response.EntityMetadata.Attributes.FirstOrDefault(findField => findField is StatusAttributeMetadata);
if (statusMetadata != null)
{
foreach (StatusOptionMetadata statusOption in statusMetadata.OptionSet.Options)
{
if (statusOption.State == state.Code)
{
Dynamics365Status status = new Dynamics365Status()
{
Code = (int)statusOption.Value,
Name = statusOption.Label.UserLocalizedLabel.Label,
LogicalName = statusMetadata.LogicalName
};
state.Statuses.Add(status);
}
}
//state.Statuses.Sort((status1, status2) => status1.Name.CompareTo(status2.Name));
}
states.Add(state);
}
}
}
//states.Sort((state1, state2) => state1.Name.CompareTo(state2.Name));
cache[cacheKey] = states;
}
return(states);
}
/// <summary>
///
/// </summary>
/// <param name="entityMetadata"></param>
/// <param name="saveMetadata"></param>
/// <returns></returns>
public static Dynamics365Entity CreateFromMetadata(EntityMetadata entityMetadata, Dynamics365Connection connection, bool saveMetadata)
{
Dynamics365Entity entity = new Dynamics365Entity()
{
DisplayName = entityMetadata.DisplayName.UserLocalizedLabel.Label,
LogicalName = entityMetadata.LogicalName,
PluralName = entityMetadata.DisplayCollectionName.UserLocalizedLabel.Label,
PrimaryFieldName = entityMetadata.PrimaryNameAttribute,
PrimaryIdFieldName = entityMetadata.PrimaryIdAttribute
};
entity.DisplayName = entityMetadata.DisplayName.UserLocalizedLabel.Label;
entity.IsUserTeamOwned = entityMetadata.OwnershipType == OwnershipTypes.TeamOwned || entityMetadata.OwnershipType == OwnershipTypes.UserOwned ? true : false;
entity.ObjectTypeCode = (int)entityMetadata.ObjectTypeCode;
if (saveMetadata)
{
ConnectionCache cache = new ConnectionCache(connection);
string cacheKey = string.Format("GetEntityMetadata:{0}", entity.LogicalName);
cache[cacheKey] = entityMetadata;
}
return(entity);
}
/// <summary>
/// Gets views of the specified type for the specified enttiy.
/// </summary>
/// <param name="entity"></param>
/// <param name="viewType"></param>
/// <param name="connection"></param>
/// <returns></returns>
public static List <Dynamics365View> GetViews(Dynamics365Entity entity, ViewType viewType, Dynamics365Connection connection)
{
List <Dynamics365View> views = null;
if (viewType == ViewType.System)
{
views = GetSystemViews(entity, connection);
}
else if (viewType == ViewType.Personal)
{
views = GetPersonalViews(entity, connection);
}
return(views);
}
public static object Convert(object value, Dynamics365Entity entity, string attributeLogicalName, Dynamics365Connection connection, string targetEntityLogicalName)
{
object convertedValue = default(object);
EntityMetadata entityMetadata = entity.GetEntityMetadata(connection);
AttributeMetadata attributeMetadata = entityMetadata.Attributes.FirstOrDefault(findField => findField.LogicalName == attributeLogicalName);
Dynamics365TypeConverter converter = new Dynamics365TypeConverter(attributeMetadata, targetEntityLogicalName);
Type destinationType = converter.Dynamics365Type;
if (converter.CanConvertTo(destinationType))
{
try
{
convertedValue = converter.ConvertTo(value, destinationType);
}
catch (Exception ex)
{
throw new ArgumentException(string.Format("Cannot convert {0} '{1}' to {2}: {3}", attributeMetadata.DisplayName.UserLocalizedLabel.Label, value, destinationType.Name, ex.Message), ex);
}
}
else
{
throw new ArgumentException(string.Format("Cannot convert {0} '{1}' to {2}.", attributeMetadata.DisplayName.UserLocalizedLabel.Label, value, destinationType.Name));
}
return(convertedValue);
}
public static object Convert(object value, Dynamics365Entity entity, string attributeLogicalName, Dynamics365Connection connection)
{
return(Convert(value, entity, attributeLogicalName, connection, default(string)));
}
/// <summary>
/// Creates a Dynamics365Field instance from the field's AttributeMetadata.
/// </summary>
/// <param name="attributeMetadata">The AttributeMetadata.</param>
/// <returns>A Dynamics365Field.</returns>
public static Dynamics365Field CreateFromMetadata(AttributeMetadata attributeMetadata, Dynamics365Connection connection)
{
Dynamics365Field field = null;
Dynamics365TypeConverter converter = new Dynamics365TypeConverter(attributeMetadata);
if (converter.CanConvertTo(converter.Dynamics365Type) && attributeMetadata.DisplayName.LocalizedLabels.Count > 0)
{
field = new Dynamics365Field()
{
LogicalName = attributeMetadata.LogicalName,
DisplayName = attributeMetadata.DisplayName.UserLocalizedLabel.Label,
EntityLogicalName = attributeMetadata.EntityLogicalName,
IsPrimaryId = (bool)attributeMetadata.IsPrimaryId,
CanCreate = (bool)attributeMetadata.IsValidForCreate,
CanUpdate = (bool)attributeMetadata.IsValidForUpdate,
Targets = attributeMetadata is LookupAttributeMetadata ? ((LookupAttributeMetadata)attributeMetadata).Targets : default(string[])
};
// see https://docs.microsoft.com/en-us/dynamics365/customer-engagement/developer/configure-activity-feeds
if ((field.EntityLogicalName == "post" || field.EntityLogicalName == "postfollow") && attributeMetadata is LookupAttributeMetadata && field.Targets?.Length == 0)
{
using (OrganizationServiceProxy proxy = connection.OrganizationServiceProxy)
{
ConnectionCache cache = new ConnectionCache(connection);
string cacheKey = string.Format("GetPostConfigurations");
string[] targets = (string[])cache[cacheKey];
if (targets == null)
{
const string ENTITY_NAME_LOGICAL_NAME = "msdyn_entityname";
FilterExpression filter = new FilterExpression();
filter.AddCondition("statecode", ConditionOperator.Equal, 0);
filter.AddCondition("statuscode", ConditionOperator.Equal, 1);
QueryExpression query = new QueryExpression()
{
EntityName = "msdyn_postconfig",
ColumnSet = new ColumnSet(ENTITY_NAME_LOGICAL_NAME),
Criteria = filter,
};
EntityCollection response = proxy.RetrieveMultiple(query);
field.Targets = new string[response.Entities.Count];
for (int entityIndex = 0; entityIndex < response.Entities.Count; entityIndex++)
{
field.Targets[entityIndex] = response.Entities[entityIndex].Attributes[ENTITY_NAME_LOGICAL_NAME].ToString();
}
cache[cacheKey] = field.Targets;
}
}
}
}
return(field);
}
public static List <Dynamics365Relationship> GetRelationships(Dynamics365Entity entity, Dynamics365Connection connection)
{
ConnectionCache cache = new ConnectionCache(connection);
string cacheKey = string.Format("GetRelationships:{0}", entity.LogicalName);
List <Dynamics365Relationship> relationships = (List <Dynamics365Relationship>)cache[cacheKey];
if (relationships == null)
{
relationships = new List <Dynamics365Relationship>();
RetrieveEntityRequest request = new RetrieveEntityRequest()
{
LogicalName = entity.LogicalName,
EntityFilters = EntityFilters.Relationships,
RetrieveAsIfPublished = false
};
using (OrganizationServiceProxy proxy = connection.OrganizationServiceProxy)
{
RetrieveEntityResponse response = (RetrieveEntityResponse)proxy.Execute(request);
foreach (ManyToManyRelationshipMetadata metadata in response.EntityMetadata.ManyToManyRelationships)
{
Dynamics365Relationship relationship = new Dynamics365Relationship()
{
SchemaName = metadata.SchemaName,
EntityLogicalName = metadata.Entity1LogicalName == entity.LogicalName ? metadata.Entity1LogicalName : metadata.Entity2LogicalName,
RelatedEntityLogicalName = metadata.Entity1LogicalName == entity.LogicalName ? metadata.Entity2LogicalName : metadata.Entity1LogicalName
};
relationships.Add(relationship);
}
foreach (OneToManyRelationshipMetadata metadata in response.EntityMetadata.ManyToOneRelationships)
{
Dynamics365Relationship relationship = new Dynamics365Relationship()
{
SchemaName = metadata.SchemaName,
EntityLogicalName = metadata.ReferencedEntity == entity.LogicalName ? metadata.ReferencedEntity : metadata.ReferencingEntity,
RelatedEntityLogicalName = metadata.ReferencedEntity == entity.LogicalName ? metadata.ReferencingEntity : metadata.ReferencedEntity
};
relationships.Add(relationship);
}
foreach (OneToManyRelationshipMetadata metadata in response.EntityMetadata.OneToManyRelationships)
{
Dynamics365Relationship relationship = new Dynamics365Relationship()
{
SchemaName = metadata.SchemaName,
EntityLogicalName = metadata.ReferencedEntity == entity.LogicalName ? metadata.ReferencedEntity : metadata.ReferencingEntity,
RelatedEntityLogicalName = metadata.ReferencedEntity == entity.LogicalName ? metadata.ReferencingEntity : metadata.ReferencedEntity
};
relationships.Add(relationship);
}
}
cache[cacheKey] = relationships;
}
return(relationships);
}
