public bool Share(Guid entityId, Guid recordId, List <PrincipalObjectAccess> principals, bool ignorePermissions = false)
{
try
{
var entityMetadata = _entityFinder.FindById(entityId);
var query = new QueryExpression(entityMetadata.Name, _languageId);
query.ColumnSet.AllColumns = true;
query.Criteria.AddCondition(entityMetadata.Name + "id", ConditionOperator.Equal, recordId);
var entity = _dataFinder.Retrieve(query);
if (!ignorePermissions)
{
VerifyEntityPermission(entity, AccessRightValue.Share, entityMetadata);
}
var attributeMetadatas = _attributeFinder.FindByEntityId(entityMetadata.EntityId);
_organizationDataProvider.BeginTransaction();
InternalOnShare(entity, OperationStage.PreOperation, entityMetadata, attributeMetadatas);
_principalObjectAccessService.DeleteByObjectId(entityId, recordId);
if (principals.NotEmpty())
{
foreach (var item in principals)
{
item.PrincipalObjectAccessId = Guid.NewGuid();
}
_principalObjectAccessService.CreateMany(principals);
}
_organizationDataProvider.CommitTransaction();
InternalOnShare(entity, OperationStage.PostOperation, entityMetadata, attributeMetadatas);
return(true);
}
catch (Exception e)
{
_organizationDataProvider.RollBackTransaction();
return(OnException(e));
}
}
public static Entity RetrieveById(this IDataFinder finder, string entityName, Guid id, string primarykey = "", bool ignorePermissions = false)
{
var q = new QueryExpression(entityName, LanguageCode.CHS);
q.ColumnSet.AllColumns = true;
q.Criteria.AddCondition(primarykey.IfEmpty(entityName + "ID"), ConditionOperator.Equal, id);
return(finder.Retrieve(q, ignorePermissions));
}
/// <summary>
/// 重复规则命中
/// </summary>
/// <param name="organizationService"></param>
/// <param name="data"></param>
/// <param name="entityMetadata"></param>
/// <param name="attributeMetadatas"></param>
/// <returns></returns>
public virtual IEnumerable <DuplicateRuleHitResult> ExecuteCore(Entity data, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
if (!entityMetadata.DuplicateEnabled)
{
yield break;
}
var duplicateRules = _duplicateRuleFinder.QueryByEntityId(entityMetadata.EntityId, RecordState.Enabled);
if (duplicateRules.NotEmpty())
{
var languageId = _appContext.GetFeature <ICurrentUser>().UserSettings.LanguageId;
foreach (var rule in duplicateRules)
{
rule.Conditions = _duplicateRuleConditionService.Query(n => n.Where(w => w.DuplicateRuleId == rule.DuplicateRuleId));
var attrid = rule.Conditions.Select(s => s.AttributeId).ToArray();
var attributes = attributeMetadatas.Where(w => attrid.Contains(w.AttributeId));
QueryExpression qe = new QueryExpression(data.Name, languageId);
qe.AddColumns(attributes.Select(s => s.Name).ToArray());
FilterExpression filter = new FilterExpression(LogicalOperator.And);
foreach (var item in qe.ColumnSet.Columns)
{
if (!data.ContainsKey(item))
{
continue;
}
var attr = attributeMetadatas.Find(n => n.Name.IsCaseInsensitiveEqual(item));
object value = data.UnWrapAttributeValue(attr);
//忽略空值
if (rule.Conditions.Find(x => x.AttributeId == attr.AttributeId).IgnoreNullValues)
{
if (value == null || value.ToString().IsEmpty())
{
continue;
}
}
filter.AddCondition(item, ConditionOperator.NotNull);
filter.AddCondition(item, ConditionOperator.Equal, value);
}
if (filter.Conditions.NotEmpty() && data.ContainsKey(data.IdName))
{
//排除自身的比较
filter.AddCondition(data.IdName, ConditionOperator.NotEqual, data.GetIdValue());
}
if (filter.Conditions.NotEmpty())
{
qe.Criteria.AddFilter(filter);
var record = _dataFinder.Retrieve(qe, true);
if (record != null && record.Count > 0)
{
yield return(new DuplicateRuleHitResult {
Rule = rule, Target = record
});
}
}
}
}
}
public IActionResult RetrieveReferencedRecord(RetrieveReferencedRecordModel args)
{
if (args.EntityId.Equals(Guid.Empty) || args.Value.IsEmpty())
{
return(NotFound());
}
var entity = _entityFinder.FindById(args.EntityId);
if (entity == null)
{
return(NotFound());
}
var entityName = entity.Name;
QueryByAttribute qba = new QueryByAttribute(entityName, CurrentUser.UserSettings.LanguageId);
if (args.AllColumns)
{
qba.ColumnSet.AllColumns = true;
}
else
{
qba.ColumnSet.AddColumns(entityName + "id", "name");
}
qba.Attributes.Add(entityName + "id");
qba.Values.Add(args.Value);
var result = _dataFinder.Retrieve(qba);
if (result != null && result.Count > 0)
{
if (!args.AllColumns)
{
result.AddIfNotContain("id", result[entityName + "id"]);
result.Remove(entityName + "id");
}
else
{
result = DataHelper.WrapOptionName(_attributeFinder.FindByEntityId(args.EntityId), result);
}
}
return(JOk(result));
}
public IActionResult AssignHandler(Guid processId, string userName)
{
//查找用户
var query = new QueryExpression("systemuser", CurrentUser.UserSettings.LanguageId);
query.ColumnSet.AddColumns("systemuserid", "name");
query.Criteria.FilterOperator = LogicalOperator.Or;
query.Criteria.AddCondition("loginname", ConditionOperator.Equal, userName);
query.Criteria.AddCondition("usernumber", ConditionOperator.Equal, userName);
var user = _dataFinder.Retrieve(query);
if (user == null || user.Count == 0)
{
return(JError(T["workflow_nomatchuser"]));
}
Guid handlerId = user.GetIdValue();
//当前步骤
var processInfo = _workFlowProcessFinder.FindById(processId);
if (processInfo == null)
{
return(NotFound());
}
if (handlerId == CurrentUser.SystemUserId)
{
return(JError(T["workflow_notallowtome"]));
}
var instance = _workFlowInstanceService.FindById(processInfo.WorkFlowInstanceId);
if (handlerId == instance.ApplicantId)
{
return(JError(T["workflow_notallowtoapplier"]));
}
//验证是否有移交权限
//...
var log = new WorkFlowProcessLog();
log.CreatedOn = DateTime.Now;
log.OperatorId = CurrentUser.SystemUserId;
log.Title = T["workflow_assignto"];
log.WorkFlowProcessId = Guid.Empty;
log.WorkFlowProcessLogId = Guid.NewGuid();
log.WorkFlowInstanceId = Guid.Empty;
_workFlowProcessLogService.Create(log);
return(JOk(T["operation_success"]));
}
public static Entity RetrieveByAttribute(this IDataFinder finder, string entityName, Dictionary <string, object> key_value, List <string> columns = null, bool ignorePermissions = false)
{
var q = new QueryExpression(entityName, LanguageCode.CHS);
if (columns.IsEmpty())
{
q.ColumnSet.AllColumns = true;
}
else
{
q.ColumnSet.AddColumns(columns.ToArray());
}
foreach (var item in key_value)
{
q.Criteria.AddCondition(item.Key, ConditionOperator.Equal, item.Value);
}
return(finder.Retrieve(q, ignorePermissions));
}
private Guid CreateFromMap_Copy(EntityMap entityMap, Guid sourceRecordId)
{
var headTargetEntityMeta = _entityFinder.FindById(entityMap.TargetEntityId);
var headTargetAttributes = _attributeFinder.FindByEntityId(entityMap.TargetEntityId);
//引用源实体的字段
var headRelationShipMeta = _relationShipFinder.FindByName(entityMap.RelationShipName);
var refAttr = headTargetAttributes.Find(n => n.AttributeId == headRelationShipMeta.ReferencingAttributeId);
if (entityMap.MapType == MapType.CopyOne)
{
//查询是否已生成记录
QueryExpression query_target = new QueryExpression(headTargetEntityMeta.Name, _languageId);
query_target.ColumnSet.AddColumn(headTargetAttributes.Find(n => n.TypeIsPrimaryKey()).Name);
query_target.Criteria.AddCondition(refAttr.Name, ConditionOperator.Equal, sourceRecordId);
var existsRecord = _dataFinder.Retrieve(query_target);
if (existsRecord.NotEmpty())
{
OnException(_loc["entitymap_copyone_error"]);
return(Guid.Empty);
}
}
Guid newId = Guid.Empty;
//源记录
var sourceRecord = _dataFinder.RetrieveById(entityMap.SourceEnttiyName, sourceRecordId);
if (sourceRecord.IsEmpty())
{
OnException(_loc["notfound_record"]);
return(Guid.Empty);
}
//单据头
var attributeMaps = _attributeMapFinder.Query(n => n.Where(f => f.EntityMapId == entityMap.EntityMapId));
if (attributeMaps.IsEmpty())
{
OnException(_loc["entitymap_emptyheadattributemap"]);
return(Guid.Empty);
}
//单据体
var childEntityMap = _entityMapFinder.FindByParentId(entityMap.EntityMapId);
//单据头字段元数据
var headSourceAttributes = _attributeFinder.FindByEntityId(entityMap.SourceEntityId);
//新增单据头信息
Entity headEntity = new Entity(entityMap.TargetEnttiyName);
foreach (var attrMap in attributeMaps)
{
if (!headSourceAttributes.Exists(n => n.AttributeId == attrMap.SourceAttributeId) || !headTargetAttributes.Exists(n => n.AttributeId == attrMap.TargetAttributeId))
{
continue;
}
var attr = headTargetAttributes.Find(n => n.AttributeId == attrMap.TargetAttributeId);
if (attr == null)
{
continue;
}
var value = sourceRecord[attrMap.SourceAttributeName];
if (value == null && attrMap.DefaultValue.IsNotEmpty())
{
value = attrMap.DefaultValue;
}
headEntity.SetAttributeValue(attr.Name, sourceRecord.WrapAttributeValue(_entityFinder, attr, value));
}
//关联来源单据ID
headEntity.SetAttributeValue(refAttr.Name, sourceRecord.WrapAttributeValue(_entityFinder, refAttr, sourceRecord.GetIdValue()));
try
{
_organizationDataProvider.BeginTransaction();
InternalOnMap(sourceRecord, headEntity, OperationStage.PreOperation, headTargetEntityMeta, headTargetAttributes);
newId = _dataCreater.Create(headEntity);
//新增单据体信息
if (childEntityMap != null)
{
var childAttributeMaps = _attributeMapFinder.Query(n => n.Where(f => f.EntityMapId == childEntityMap.EntityMapId));
if (childAttributeMaps.NotEmpty())
{
var childTargetEntityMeta = _entityFinder.FindById(childEntityMap.TargetEntityId);
var childTargetAttributesMeta = _attributeFinder.FindByEntityId(childEntityMap.TargetEntityId);
var childSourceAttributesMeta = _attributeFinder.FindByEntityId(childEntityMap.SourceEntityId);
var childRelationShips = childEntityMap.RelationShipName.SplitSafe(",");
//源单据体与源单据头的关系
var childSourceRelationShipMeta = _relationShipFinder.FindByName(childRelationShips[0]);
//目标单据体与目标单据头的关系
var childTargetRelationShipMeta = _relationShipFinder.FindByName(childRelationShips[1]);
//源单据体数据
QueryExpression query_source = new QueryExpression(childEntityMap.SourceEnttiyName, _languageId);
query_source.ColumnSet.AllColumns = true;
var refKey = headSourceAttributes.Find(n => n.AttributeId == childSourceRelationShipMeta.ReferencedAttributeId).Name;
query_source.Criteria.AddCondition(refKey, ConditionOperator.Equal, sourceRecordId);
var childSourceRecords = _dataFinder.RetrieveAll(query_source);
if (childSourceRecords.NotEmpty())
{
//引用单据头的字段
var headRefAttr = childTargetAttributesMeta.Find(n => n.AttributeId == childTargetRelationShipMeta.ReferencingAttributeId);
//引用源单据体的字段
var refSourceAttr = childTargetAttributesMeta.Find(n => n.ReferencedEntityId.HasValue && n.ReferencedEntityId.Value == childEntityMap.SourceEntityId);
foreach (var item in childSourceRecords)
{
//目标单据体
Entity childTargetRecord = new Entity(childEntityMap.TargetEnttiyName);
foreach (var attrMap in childAttributeMaps)
{
if (!childSourceAttributesMeta.Exists(n => n.AttributeId == attrMap.SourceAttributeId) || !childTargetAttributesMeta.Exists(n => n.AttributeId == attrMap.TargetAttributeId))
{
continue;
}
var attr = childTargetAttributesMeta.Find(n => n.AttributeId == attrMap.TargetAttributeId);
if (attr == null)
{
continue;
}
var value = item[attrMap.SourceAttributeName];
if (value == null && attrMap.DefaultValue.IsNotEmpty())
{
value = attrMap.DefaultValue;
}
childTargetRecord.SetAttributeValue(attrMap.TargetAttributeName, sourceRecord.WrapAttributeValue(_entityFinder, attr, value));
}
//关联来源单据体记录ID
if (refSourceAttr != null)
{
childTargetRecord.SetAttributeValue(refSourceAttr.Name, sourceRecord.WrapAttributeValue(_entityFinder, refSourceAttr, item.GetIdValue()));
}
//单据头ID
childTargetRecord.SetAttributeValue(headRefAttr.Name, sourceRecord.WrapAttributeValue(_entityFinder, headRefAttr, newId));
_dataCreater.Create(childTargetRecord);
}
}
}
}
_organizationDataProvider.CommitTransaction();
InternalOnMap(sourceRecord, headEntity, OperationStage.PostOperation, headTargetEntityMeta, headTargetAttributes);
}
catch (Exception e)
{
_organizationDataProvider.RollBackTransaction();
newId = Guid.Empty;
OnException(e);
}
return(newId);
}
public bool Merge(Guid entityId, Guid mainRecordId, Guid mergedRecordId, Dictionary <string, Guid> attributeMaps, bool ignorePermissions = false)
{
var entityMetadata = _entityFinder.FindById(entityId);
//retrive main record
var queryMain = new QueryExpression(entityMetadata.Name, _languageId);
queryMain.ColumnSet.AllColumns = true;
queryMain.Criteria.AddCondition(entityMetadata.Name + "id", ConditionOperator.Equal, mainRecordId);
var mainRecord = _dataFinder.Retrieve(queryMain, ignorePermissions);
if (mainRecord.IsEmpty())
{
return(OnException(_loc["notfound_record"]));
}
//retrive merged record
var queryMerged = new QueryExpression(entityMetadata.Name, _languageId);
queryMerged.ColumnSet.AllColumns = true;
queryMerged.Criteria.AddCondition(entityMetadata.Name + "id", ConditionOperator.Equal, mergedRecordId);
var mergedRecord = _dataFinder.Retrieve(queryMerged, ignorePermissions);
if (mergedRecord.IsEmpty())
{
return(OnException(_loc["notfound_record"]));
}
var attributeMetadatas = _attributeFinder.FindByEntityId(entityId);
var updatedRecord = new Entity(entityMetadata.Name);
//set target record values
foreach (var attr in attributeMetadatas)
{
if (attr.IsSystemControl())
{
continue;
}
if (attributeMaps.ContainsKey(attr.Name))
{
var eid = attributeMaps[attr.Name];
updatedRecord.SetAttributeValue(attr.Name, eid.Equals(mainRecordId) ? updatedRecord.WrapAttributeValue(_entityFinder, attr, mainRecord[attr.Name]) : updatedRecord.WrapAttributeValue(_entityFinder, attr, mergedRecord[attr.Name]));
}
else
{
updatedRecord.SetAttributeValue(attr.Name, updatedRecord.WrapAttributeValue(_entityFinder, attr, mainRecord[attr.Name]));
}
}
//this.VerifyUpdate(updatedRecord);
updatedRecord.AddIfNotContain("modifiedon", DateTime.Now);
updatedRecord.AddIfNotContain("modifiedby", _user.SystemUserId);
var result = false;
try
{
_organizationDataProvider.BeginTransaction();
InternalOnMerge(mergedRecord, updatedRecord, OperationStage.PreOperation, entityMetadata, attributeMetadatas);
//result = _dataUpdater.Update(updatedRecord, ignorePermissions);
result = _organizationDataProvider.Update(updatedRecord);
//update referencing records
var relationships = _relationShipFinder.QueryByEntityId(null, entityId);
foreach (var rs in relationships)
{
var relatedEntity = new Entity(rs.ReferencingEntityName);
relatedEntity.SetAttributeValue(rs.ReferencingAttributeName, mainRecordId);
var queryRelated = new QueryExpression(rs.ReferencingEntityName, _languageId);
queryRelated.ColumnSet.AddColumns(rs.ReferencingEntityName + "id");
queryRelated.Criteria.AddCondition(rs.ReferencingAttributeName, ConditionOperator.Equal, mergedRecordId);
_organizationDataProvider.Update(relatedEntity, _queryResolverFactory.Get(queryRelated), ignorePermissions: true);
}
//disabled original record
var disabledEntity = new Entity(entityMetadata.Name);
disabledEntity.SetIdValue(mergedRecordId);
disabledEntity.SetAttributeValue("statecode", false);
//result = _dataUpdater.Update(disabledEntity, ignorePermissions);
result = _organizationDataProvider.Update(disabledEntity);
if (result)
{
_organizationDataProvider.CommitTransaction();
InternalOnMerge(mergedRecord, updatedRecord, OperationStage.PostOperation, entityMetadata, attributeMetadatas);
}
else
{
_organizationDataProvider.RollBackTransaction();
}
}
catch (Exception e)
{
_organizationDataProvider.RollBackTransaction();
OnException(e);
}
return(result);
}
