//用户重复提醒消息
public void UserReviewSysMessage(int userId, int messageId)
{
var filters = new EntityFilters {
And = true
};
filters.Add(new EntityFilter {
Operator = FilterOperator.Equal, PropertyName = "UserId", Value = userId
});
filters.Add(new EntityFilter {
Operator = FilterOperator.Equal, PropertyName = "MessageId", Value = messageId
});
var list = SqlHelper.Filter <SystemMessageReview>(filters);
if (list == null || list.Count < 1)
{
SqlHelper.Insert(new SystemMessageReview
{
Identity = -1,
UserId = userId,
MessageId = messageId,
ReviewTimes = 1
});
}
else
{
var smr = list[0];
smr.ReviewTimes += 1;
SqlHelper.Update(smr);
}
}
private static EntityMetadata MetadataHelper <T>
(IOrganizationService service, EntityFilters filter)
where T : Entity
{
try
{
var logicalName = (Activator.CreateInstance <T>()).LogicalName;
var req = new OrganizationRequest();
var params_ = new ParameterCollection();
params_.Add(@"LogicalName", logicalName);
params_.Add(@"EntityFilters", filter);
params_.Add(@"MetadataId", Guid.Empty);
params_.Add(@"RetrieveAsIfPublished", true);
req.RequestName = @"RetrieveEntity";
req.Parameters.AddRange(params_);
var resp = service.Execute(req);
var metadata = resp.Results.FirstOrDefault();
if (null == metadata.Value)
{
return(null);
}
return((EntityMetadata)metadata.Value);
}
catch (Exception ex)
{
throw new Exception(HU.ErrorMessageWrapper(ex));
};
}
private string GetCacheKey(
EntityFilters metadataFlags,
EntityFilters entityFlags,
string entityName,
string attributeName,
string sortExpression)
{
CacheParameters cacheParameters = Owner.GetCacheParameters();
return(cacheParameters.CacheKey.GetCacheKey(
Context,
Owner,
Owner,
delegate
{
string cacheKey = "MetadataFlags={0}:entityFlags={1}:EntityName={2}:AttributeName={3}:SortExpression={4}".FormatWith(
metadataFlags,
entityFlags,
entityName,
attributeName,
sortExpression);
return "Adxstudio:Type={0}:ID={1}:{2}".FormatWith(Owner.GetType().FullName, Owner.ID, cacheKey);
}));
}
static internal EntityFilters GetEntityFiltersFromString(string value)
{
EntityFilters entityFilters = EntityFilters.Default;
foreach (var entityFilter in value.Split(' '))
{
switch (entityFilter)
{
case "Entity":
entityFilters |= EntityFilters.Entity;
break;
case "Attributes":
entityFilters |= EntityFilters.Attributes;
break;
case "Privileges":
entityFilters |= EntityFilters.Privileges;
break;
case "Relationships":
entityFilters |= EntityFilters.Relationships;
break;
}
}
return(entityFilters);
}
static internal string GetEntityFiltersAsString(EntityFilters enumValue)
{
List <string> valueArray = new List <string>();
string returnValue = "None";
if (enumValue.HasFlag(EntityFilters.Entity) || enumValue.HasFlag(EntityFilters.All))
{
valueArray.Add("Entity");
}
if (enumValue.HasFlag(EntityFilters.Attributes) || enumValue.HasFlag(EntityFilters.All))
{
valueArray.Add("Attributes");
}
if (enumValue.HasFlag(EntityFilters.Privileges) || enumValue.HasFlag(EntityFilters.All))
{
valueArray.Add("Privileges");
}
if (enumValue.HasFlag(EntityFilters.Relationships) || enumValue.HasFlag(EntityFilters.All))
{
valueArray.Add("Relationships");
}
if (returnValue == "None")
{
valueArray.Add("Entity");
}
returnValue = String.Join(" ", valueArray.ToArray());
return(returnValue);
}
//文件描述
public int ReleaseDocument(DocumentRelease dr)
{
if (dr == null)
{
return(-2);
}
var filters = new EntityFilters {
And = true
};
filters.Add(new EntityFilter {
Operator = FilterOperator.Equal, PropertyName = "ReleaseType", Value = dr.ReleaseType
});
filters.Add(new EntityFilter {
Operator = FilterOperator.Equal, PropertyName = "DocumentId", Value = dr.DocumentId
});
filters.Add(new EntityFilter {
Operator = FilterOperator.Equal, PropertyName = "FolderId", Value = dr.FolderId
});
filters.Add(new EntityFilter {
Operator = FilterOperator.Equal, PropertyName = "ReviewUserId", Value = dr.ReviewUserId
});
filters.Add(new EntityFilter {
Operator = FilterOperator.Equal, PropertyName = "ReviewOrgId", Value = dr.ReviewOrgId
});
if (SqlHelper.Filter <DocumentRelease>(filters).Count > 0)
{
return(0);
}
dr.ReleaseTime = DateTime.Now;
return(SqlHelper.Insert(dr));
}
public override Result <Task.Config> Load()
{
var result = base.Load();
var settings = new TaskSettings(Task);
Link = settings.GetValue(Config.LinkName);
Username = settings.GetValue(Config.UserName);
Password = settings.GetValue(Config.PasswordName);
ImportImage = settings.GetBoolValue(Config.ImageImportName);
LastUpdated = settings.GetDateValue(Config.LastUpdatedName);
LastUpdated = (LastUpdated == DateTime.MinValue) ? DateTime.Now.Subtract(TimeSpan.FromDays(1095)) : LastUpdated;
var fields = settings.GetValue(Config.FieldsToUpdateName);
FieldsToUpdate = (fields != null) ? fields.Split(',') : new string[] { };
//Get field filters, if they exist
PersonMapper = new ModelMapper <Person>(FieldsToUpdate);
PersonFilters = new EntityFilters <Person>(PersonMapper).Load(settings);
result.Entity = this;
return(result);
}
/// <summary>
/// Retrieve entities in a list of Entity logical names
/// </summary>
/// <param name="service"></param>
/// <param name="entityLogcialNames"></param>
/// <param name="retrieveAsIfPublished"></param>
/// <param name="entityFilters"></param>
/// <returns></returns>
public static List<EntityMetadata> RetrieveEntity(IOrganizationService service, List<string> entityLogcialNames, bool retrieveAsIfPublished = true, List<EntityFilters> entityFilters = null) {
EntityFilters filters = EntityFilters.Default;
if (entityFilters != null) {
filters = entityFilters.Aggregate<EntityFilters, EntityFilters>(0, (current, item) => current | item);
}
var entities = new List<EntityMetadata>();
// Create an ExecuteMultipleRequest object.
var batchRequest = new ExecuteMultipleRequest() {
Settings = new ExecuteMultipleSettings() {
ContinueOnError = false,
ReturnResponses = true
},
Requests = new OrganizationRequestCollection()
};
foreach (var entityLogicalName in entityLogcialNames) {
batchRequest.Requests.Add(
new RetrieveEntityRequest() {
RetrieveAsIfPublished = retrieveAsIfPublished,
EntityFilters = filters,
LogicalName = entityLogicalName
});
}
var responses = (ExecuteMultipleResponse)service.Execute(batchRequest);
foreach (var resp in responses.Responses) {
entities.Add(((RetrieveEntityResponse)resp.Response).EntityMetadata);
}
return entities;
}
private List <EntityMetadata> GetEntitiesForEntityAttributeExplorer(EntityFilters filters)
{
RetrieveAllEntitiesRequest raer = new RetrieveAllEntitiesRequest()
{
EntityFilters = filters
};
RetrieveAllEntitiesResponse resp = (RetrieveAllEntitiesResponse)_service.Execute(raer);
return(resp.EntityMetadata.OrderBy(ent => ent.LogicalName).ToList());
}
public EntityMetadata GetEntityMetadata(int entityTypeCode, EntityFilters entityFilters)
{
string logicalName = GetEntityLogicalName(entityTypeCode);
if (string.IsNullOrWhiteSpace(logicalName))
{
throw new KeyNotFoundException($"No logical name could be found for type code {entityTypeCode.ToString()}");
}
return(GetEntityMetadata(logicalName, entityFilters));
}
/// <summary>
/// Gets all entities metadata with specified informations
/// </summary>
/// <param name="service">Organization service</param>
/// <param name="filters">Information to retrieve</param>
/// <returns>List of entities metadata</returns>
public static List<EntityMetadata> GetEntitiesMetadata(IOrganizationService service, EntityFilters filters)
{
var request = new RetrieveAllEntitiesRequest
{
EntityFilters = filters
};
var response = (RetrieveAllEntitiesResponse)service.Execute(request);
return response.EntityMetadata.ToList();
}
/// <summary>
/// Get metadata for an entity.
/// </summary>
/// <param name="entityName">Logical name of the entity.</param>
/// <param name="entityFilter">Filter for the type of metadata to retrieve.</param>
/// <returns>EntityMetadata from a RetrieveEntityResponse.</returns>
public EntityMetadata RetrieveEntity(string entityName, EntityFilters entityFilter)
{
var request = new RetrieveEntityRequest
{
LogicalName = entityName.ToLower(),
EntityFilters = entityFilter
};
var response = (RetrieveEntityResponse)_service.Execute(request);
return(response.EntityMetadata);
}
public Dictionary <string, EntityMetadata> GetAllEntitiesMetaData(EntityFilters entityFilter)
{
var retrievesEntitiesRequest = new RetrieveAllEntitiesRequest
{
RetrieveAsIfPublished = true,
EntityFilters = entityFilter
};
var retrieveEntityResponse = (RetrieveAllEntitiesResponse)OrganizationService.Execute(retrievesEntitiesRequest);
return(retrieveEntityResponse.EntityMetadata.ToDictionary(curMetadata => curMetadata.LogicalName));
}
/// <summary>
/// Retrieves all metadata from the CRM solution.. this is a time consuming task
/// </summary>
/// <param name="onlyPublished">only return "published" or "published state" of entities</param>
/// <param name="filter">the depth if detail on the entity to retrieve</param>
/// <returns></returns>
public List <EntityMetadata> GetAllEntityMetadata(bool onlyPublished, EntityFilters filter = EntityFilters.Default)
{
// this will force a retrieve of all metatdata from CRM's entities
List <EntityMetadata> results = new List <EntityMetadata>();
RetrieveAllEntitiesRequest request = new RetrieveAllEntitiesRequest();
request.EntityFilters = filter;
request.RetrieveAsIfPublished = !onlyPublished;
RetrieveAllEntitiesResponse response = (RetrieveAllEntitiesResponse)svcAct.Command_Execute(request, "GetAllEntityMetadata");
if (response != null)
{
foreach (var entity in response.EntityMetadata)
{
if (_entityMetadataCache.ContainsKey(entity.LogicalName))
{
_entityMetadataCache[entity.LogicalName] = entity; // Update local copy of the entity...
}
else
{
_entityMetadataCache.TryAdd(entity.LogicalName, entity);
}
results.Add(entity);
// Preload the entity data catch as this has been called already
if (_entityNameCache.ContainsKey(entity.ObjectTypeCode.Value))
{
continue;
}
else
{
_entityNameCache.TryAdd(entity.ObjectTypeCode.Value, entity.LogicalName);
}
}
TouchMetadataDate();
}
else
{
if (svcAct.LastException != null)
{
throw new DataverseOperationException($"Failed to get metadata from Dataverse.", svcAct.LastException);
}
else
{
throw new DataverseOperationException($"Failed to get metadata from Dataverse", null);
}
}
return(results);
}
//查找角色
public List <SystemRole> SearchRole(string searchKey)
{
var filters = new EntityFilters();
filters.And = false;
filters.Add(new EntityFilter {
Operator = FilterOperator.Like, PropertyName = "RoleCode", Value = searchKey
});
filters.Add(new EntityFilter {
Operator = FilterOperator.Like, PropertyName = "RoleName", Value = searchKey
});
return(SqlHelper.Filter <SystemRole>(filters));
}
private EntityMetadata getEntityMetadata(string entityLogicalName,
IOrganizationService service,
EntityFilters filters)
{
var request = new RetrieveEntityRequest {
EntityFilters = filters,
LogicalName = entityLogicalName,
RetrieveAsIfPublished = true
};
var response = (RetrieveEntityResponse)service.Execute(request);
return(response.EntityMetadata);
}
public static EntityMetadata GetMetadata(this ITransactionContext <Entity> context,
string entityLogicalName, EntityFilters filters = EntityFilters.Default)
{
var entityRequest = new RetrieveEntityRequest
{
EntityFilters = filters,
LogicalName = entityLogicalName,
RetrieveAsIfPublished = false
};
var entityResponse = (RetrieveEntityResponse)context.Service.Execute(entityRequest);
return(entityResponse.EntityMetadata);
}
/// <summary>
/// source: https://crmpolataydin.wordpress.com/2014/12/02/crm-20112013-get-entity-metadata-from-c/
/// </summary>
/// <param name="entityName"></param>
/// <param name="entityFilter"></param>
/// <returns></returns>
public EntityMetadata GetEntityMetaData(string entityName, EntityFilters entityFilter)
{
var retrievesEntityRequest = new RetrieveEntityRequest
{
LogicalName = entityName,
RetrieveAsIfPublished = true,
EntityFilters = entityFilter
};
var retrieveEntityResponse = (RetrieveEntityResponse)OrganizationService.Execute(retrievesEntityRequest);
var entityMetadata = retrieveEntityResponse.EntityMetadata;
return(entityMetadata);
}
public EntityMetadata GetEntityMetadata(string entityName, EntityFilters entityFilters)
{
if (string.IsNullOrWhiteSpace(entityName))
{
throw new ArgumentNullException(nameof(entityName), $"The parameter {nameof(entityName)} cannot be null.");
}
var response = (RetrieveEntityResponse)_organizationService.Execute(new RetrieveEntityRequest()
{
LogicalName = entityName,
EntityFilters = entityFilters
});
return(response.EntityMetadata);
}
public static EntityMetadata[] RetrieveAllEntities(
this OrganizationServiceContext service,
EntityFilters entityFilters = EntityFilters.Default,
bool retrieveAsIfPublished = false)
{
const string requestName = "RetrieveAllEntities";
var parameters = new Dictionary <string, object>
{
{ "EntityFilters", entityFilters },
{ "RetrieveAsIfPublished", retrieveAsIfPublished },
{ "MetadataId", Guid.Empty },
};
return(service.Execute <EntityMetadata[]>(requestName, parameters, "EntityMetadata"));
}
private EntityMetadata GetEntity(string name, EntityFilters filter)
{
OrganizationRequest request = new OrganizationRequest("RetrieveEntity")
{
Parameters = new ParameterCollection
{
{ "LogicalName", name },
{ "EntityFilters", filter },
{ "RetrieveAsIfPublished", true },
{ "MetadataId", default(Guid) }
}
};
OrganizationResponse response = CrmContext.OrganizationProxy.Execute(request);
return((EntityMetadata)response.Results["EntityMetadata"]);
}
public CrmMetadataDataSourceSelectingEventArgs(
CrmMetadataDataSource dataSource,
DataSourceSelectArguments arguments,
string entityName,
string attributeName,
EntityFilters metadataFlags,
EntityFilters entityFlags,
string sortExpression)
{
_dataSource = dataSource;
_arguments = arguments;
_entityName = entityName;
_attributeName = attributeName;
_metadataFlags = metadataFlags;
_entityFlags = entityFlags;
_sortExpression = sortExpression;
}
//搜索组织
public List <Organization> SearchOrganization(string strKey)
{
var filters = new EntityFilters();
filters.And = false;
filters.Add(new EntityFilter {
Operator = FilterOperator.StartWith, PropertyName = "Id", Value = strKey
});
filters.Add(new EntityFilter {
Operator = FilterOperator.StartWith, PropertyName = "ParentId", Value = strKey
});
filters.Add(new EntityFilter {
Operator = FilterOperator.Like, PropertyName = "Code", Value = strKey
});
filters.Add(new EntityFilter {
Operator = FilterOperator.Like, PropertyName = "Name", Value = strKey
});
return(SqlHelper.Filter <Organization>(filters));
}
//获取子文件夹ID
private int GetChildFolderId(int folderId, string folderName)
{
var filters = new EntityFilters {
And = true
};
filters.Add(new EntityFilter {
Operator = FilterOperator.Equal, PropertyName = "ParentId", Value = folderId
});
filters.Add(new EntityFilter {
Operator = FilterOperator.Equal, PropertyName = "Name", Value = folderName
});
var children = SqlHelper.Filter <DocumentFolder>(filters);
if (children == null || children.Count < 1)
{
return(-1);
}
return(children[0].FolderId);
}
public override Result <Task.Config> Load()
{
var result = base.Load();
var settings = new TaskSettings(Task);
//Get field filters, if they exist
var all = new string[] { };
EmployeeMapper = new ModelMapper <R1Employee>(all);
EmployeeFilters = new EntityFilters <R1Employee>(EmployeeMapper).Load(settings);
PersonMapper = new ModelMapper <Person>(all);
PersonFilters = new EntityFilters <Person>(PersonMapper).Load(settings);
ConnectionString = settings.GetValue(ConnectionStringSettingName);
result.Entity = this;
return(result);
}
private EntityMetadata GetEntityMetadataAttributes(Guid idEntityMetadata, EntityFilters filters)
{
try
{
RetrieveEntityRequest request = new RetrieveEntityRequest()
{
MetadataId = idEntityMetadata,
EntityFilters = filters,
};
var response = (RetrieveEntityResponse)_service.Execute(request);
return(response.EntityMetadata);
}
catch (Exception ex)
{
Helpers.DTEHelper.WriteExceptionToOutput(_service.ConnectionData, ex);
return(null);
}
}
//获取文件描述历史
public List <DocumentRelease> GetReleaseHistory(FileSystemEntity fse)
{
var filters = new EntityFilters {
And = true
};
filters.Add(fse.Type == FileSystemEntityType.File
? new EntityFilter
{
Operator = FilterOperator.Equal,
PropertyName = "DocumentId",
Value = fse.FileId
}
: new EntityFilter
{
Operator = FilterOperator.Equal,
PropertyName = "FolderId",
Value = fse.FolderId
});
return(SqlHelper.Filter <DocumentRelease>(filters, true, false));
}
//通过用户获取存档工作流
public List <ArchiveWorkflow> GetArchiveFlowByUser(int userId, AuditStatus status)
{
var filters = new EntityFilters {
And = true
};
filters.Add(new EntityFilter {
Operator = FilterOperator.Equal, PropertyName = "SubmitUserId", Value = userId
});
filters.Add(new EntityFilter {
Operator = FilterOperator.Equal, PropertyName = "Status", Value = status
});
var list = SqlHelper.Filter <ArchiveWorkflow>(filters);
if (status == AuditStatus.Draft)
{
filters[1].Value = AuditStatus.Rejected;
list.AddRange(SqlHelper.Filter <ArchiveWorkflow>(filters));
}
return(list);
}
public EntityMetadata GetEntityMetadata(string entityName, EntityFilters filters = EntityFilters.Attributes)
{
if (!_entityMetadataCache.TryGetValue(entityName, out var metadataDic))
{
metadataDic = new Dictionary <EntityFilters, EntityMetadata>();
_entityMetadataCache.Add(entityName, metadataDic);
}
if (!metadataDic.TryGetValue(filters, out EntityMetadata result))
{
var req = new RetrieveEntityRequest()
{
EntityFilters = filters,
RetrieveAsIfPublished = true,
LogicalName = entityName,
};
result = GlobalTestingContext.ConnectionManager.AdminConnection.Execute <RetrieveEntityResponse>(req).EntityMetadata;
metadataDic.Add(filters, result);
}
return(result);
}
/// <summary>
/// Gets a subset of metadata for the specified entity, as dictated by the filters specified.
/// </summary>
/// <param name="entityLogicalName"></param>
/// <param name="filters"></param>
/// <returns></returns>
public EntityMetadata GetEntityMetadata(string entityLogicalName, EntityFilters filters)
{
var metaRequest = new RetrieveEntityRequest()
{
EntityFilters = EntityFilters.All,
LogicalName = entityLogicalName
};
try
{
IOrganizationService service = _CrmServiceProvider.GetOrganisationService();
using (service as IDisposable)
{
var metaResponse = (RetrieveEntityResponse)service.Execute(metaRequest);
return(metaResponse.EntityMetadata);
}
}
catch (Exception e)
{
throw new Exception("Unable to obtain CRM metadata for entity: " + entityLogicalName + " as CRM returned a fault. See inner exception for details.", e);
}
}
internal static EntityMetadata GetEntityMetadata(string logicalname, EntityFilters filters, IOrganizationService service)
{
return(((RetrieveEntityResponse)service.Execute(new RetrieveEntityRequest {
LogicalName = logicalname, EntityFilters = filters
})).EntityMetadata);
}
/// <summary>
/// Gets the entity metadata for an entity
/// </summary>
/// <param name="entityName">Name of the entity</param>
/// <param name="entityFilters">EntityFilter to use</param>
/// <returns>The entity's metadata</returns>
private EntityMetadata GetCrmEntityMetaData(string entityName, EntityFilters entityFilters = EntityFilters.Attributes)
{
RetrieveEntityResponse response = ExecuteRetrieveEntityRequest(entityName, entityFilters);
return response.EntityMetadata;
}
/// <summary>
/// Executes an entity request query
/// </summary>
/// <param name="entityName">Name of entity to retrieve</param>
/// <returns>Response of query</returns>
private RetrieveEntityResponse ExecuteRetrieveEntityRequest(string entityName, EntityFilters entityFilters)
{
RetrieveEntityRequest request = new RetrieveEntityRequest();
request.LogicalName = entityName;
request.EntityFilters = entityFilters;
return (RetrieveEntityResponse)_service.Execute(request);
}
/// <summary>
/// Gets a subset of metadata for the specified entity, as dictated by the filters specified.
/// </summary>
/// <param name="entityLogicalName"></param>
/// <param name="filters"></param>
/// <returns></returns>
public EntityMetadata GetEntityMetadata(string entityLogicalName, EntityFilters filters)
{
var metaRequest = new RetrieveEntityRequest()
{
EntityFilters = EntityFilters.All,
LogicalName = entityLogicalName
};
try
{
IOrganizationService service = _CrmServiceProvider.GetOrganisationService();
using (service as IDisposable)
{
var metaResponse = (RetrieveEntityResponse)service.Execute(metaRequest);
return metaResponse.EntityMetadata;
}
}
catch (Exception e)
{
throw new Exception("Unable to obtain CRM metadata for entity: " + entityLogicalName + " as CRM returned a fault. See inner exception for details.", e);
}
}
