public bool Update(Schema.Domain.Entity entityMetadata, Entity data)
{
//exists summary field?
var summaryFields = _attributeFinder.Query(n => n.Where(f => f.SummaryEntityId == entityMetadata.EntityId));
if (summaryFields.NotEmpty())
{
foreach (var item in summaryFields)
{
var ae = new AttributeAggregateExpression();
ae = ae.DeserializeFromJson(item.SummaryExpression);
if (!data.ContainsKey(ae.Field))
{
continue;
}
if (ae.EntityName.IsCaseInsensitiveEqual(data.Name))
{
var rs = _relationShipFinder.FindByName(ae.RelationshipName);
_fieldValueUpdater.UpdateSummaryValue(entityMetadata, data, item, rs, ae);
//字段公式计算
var formulaAttributes = _attributeFinder.FindByEntityName(rs.ReferencedEntityName).Where(n => n.ValueType == 2).ToList();
if (formulaAttributes.NotEmpty())
{
_fieldValueUpdater.UpdateFormulaValue(rs.ReferencedEntityName, formulaAttributes, data.GetGuidValue(rs.ReferencedAttributeName));
}
}
}
}
return(true);
}
public IActionResult Post(CreateRecordModel model)
{
if (model.Data.IsEmpty())
{
return(JError("data is empty"));
}
Schema.Domain.Entity entityMeta = null;
if (model.EntityId.HasValue && !model.EntityId.Value.Equals(Guid.Empty))
{
entityMeta = _entityFinder.FindById(model.EntityId.Value);
}
else if (model.EntityName.IsNotEmpty())
{
entityMeta = _entityFinder.FindByName(model.EntityName);
}
if (entityMeta == null)
{
return(NotFound());
}
var childAttributes = _attributeFinder.FindByEntityName(entityMeta.Name);
if (model.Data.StartsWith("["))
{
var details = new List <Entity>();
var items = JArray.Parse(model.Data.UrlDecode());
if (items.Count > 0)
{
foreach (var c in items)
{
dynamic root = JObject.Parse(c.ToString());
Entity detail = new Entity(entityMeta.Name);
foreach (JProperty p in root)
{
var attr = childAttributes.Find(n => n.Name.IsCaseInsensitiveEqual(p.Name));
if (attr != null && p.Value != null)
{
detail.SetAttributeValue(p.Name.ToString().ToLower(), detail.WrapAttributeValue(_entityFinder, attr, p.Value.ToString()));
}
}
details.Add(detail);
}
}
return(_dataCreater.CreateMany(details).CreateResult(T));
}
else
{
dynamic root = JObject.Parse(model.Data.UrlDecode());
Entity detail = new Entity(entityMeta.Name);
foreach (JProperty p in root)
{
var attr = childAttributes.Find(n => n.Name.IsCaseInsensitiveEqual(p.Name));
if (attr != null)
{
detail.SetAttributeValue(p.Name.ToString().ToLower(), detail.WrapAttributeValue(_entityFinder, attr, p.Value.ToString()));
}
}
var id = _dataCreater.Create(detail);
return(CreateSuccess(new { id = id }));
}
}
public bool Update(Schema.Domain.Entity targetEntityMetadata, Entity targetRecord, bool onDelete = false)
{
var entityMaps = _entityMapFinder.Query(n => n.Where(f => f.TargetEntityId == targetEntityMetadata.EntityId && (f.MapType == MapType.Control || f.MapType == MapType.ForceControl)));
if (entityMaps.IsEmpty())
{
return(true);
}
if (targetRecord.IsEmpty())
{
return(false);
}
Guid headSourceId = Guid.Empty;
var emptyGuid = Guid.Empty;
foreach (var em in entityMaps)
{
var attributeMaps = _attributeMapFinder.Query(n => n.Where(f => f.EntityMapId == em.EntityMapId && f.RemainAttributeId != emptyGuid));
//单据头
if (attributeMaps.NotEmpty())
{
var sourceAttributesMeta = _attributeFinder.FindByEntityId(em.SourceEntityId);
var targetEntityMetas = _entityFinder.FindById(em.TargetEntityId);
var targetAttributesMeta = _attributeFinder.FindByEntityId(em.TargetEntityId);
//引用源单据的字段
var refSourceAttr = targetAttributesMeta.Find(n => n.ReferencedEntityId.HasValue && n.ReferencedEntityId.Value == em.SourceEntityId);
//更新单据头相关字段
_fieldValueUpdater.UpdateControlMap(em, attributeMaps, targetRecord.GetGuidValue(refSourceAttr.Name), refSourceAttr, sourceAttributesMeta, targetAttributesMeta, onDelete);
}
return(true);
}
return(true);
}
public bool AssignedLog(Entity data, OwnerObject from, OwnerObject to, Schema.Domain.Entity entityMetadata)
{
if (!entityMetadata.LogEnabled)
{
return(false);
}
EntityLog entity = new EntityLog
{
EntityId = entityMetadata.EntityId,
EntityLogId = Guid.NewGuid(),
OperationType = OperationTypeEnum.Assign,
UserId = _currentUser.SystemUserId,
OrganizationId = _currentUser.OrganizationId,
CreatedOn = DateTime.Now,
RecordId = data.GetIdValue()
};
var datas = new List <EntityLogChangeData>
{
new EntityLogChangeData()
{
Name = "ownerid", Original = from.SerializeToJson(), Value = to.SerializeToJson()
}
};
entity.ChangeData = datas.SerializeToJson();
return(Create(entity));
}
/// <summary>
/// 更新业务对象的处理状态
/// </summary>
/// <param name="entityId"></param>
/// <param name="objectId"></param>
/// <param name="state"></param>
/// <param name="entityName"></param>
private void Update(Schema.Domain.Entity entityMetaData, Guid objectId, WorkFlowProcessState state)
{
var entity = new Core.Data.Entity(entityMetaData.Name);
entity.SetIdValue(objectId);
entity.SetAttributeValue("ProcessState", new OptionSetValue((int)state));
_dataUpdater.Update(entity, true);
}
/// <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 bool UpdateSummaryValue(Schema.Domain.Entity entityMetadata, Entity data, Schema.Domain.Attribute summaryField, Schema.Domain.RelationShip relationShipMetadata, AttributeAggregateExpression aggExp)
{
var sql = string.Format("UPDATE {0} SET {1}=(SELECT {6}({2}) FROM {3} WITH(NOLOCK) WHERE {4}='{5}') WHERE {4} = '{5}'"
, summaryField.EntityName, summaryField.Name, aggExp.Field, aggExp.EntityName
, relationShipMetadata.ReferencedAttributeName, data[relationShipMetadata.ReferencingAttributeName].ToString()
, aggExp.Aggregate);
_repository.Execute(sql, null);
return(true);
}
public bool CreateDefaultButtons(Schema.Domain.Entity entity)
{
var defaultButtons = _defaultButtonProvider.Get(entity.EntityMask);
defaultButtons.ForEach((b) =>
{
b.RibbonButtonId = Guid.NewGuid();
b.CreatedBy = entity.CreatedBy;
b.EntityId = entity.EntityId;
b.SolutionId = entity.SolutionId;
b.ComponentState = entity.ComponentState;
});
return(CreateMany(defaultButtons));
}
/// <summary>
/// 校验新建数据
/// </summary>
/// <param name="entity"></param>
/// <param name="entityMetadata"></param>
/// <param name="attributeMetadatas"></param>
private void VerifyCreate(Entity entity, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas, bool ignorePermissions = false)
{
_entityValidator.VerifyValues(entity, entityMetadata, attributeMetadatas, (e) =>
{
OnException(string.Join("\n", e));
});
if (attributeMetadatas.Exists(n => n.Name.IsCaseInsensitiveEqual("createdby")))
{
entity["createdby"] = new EntityReference("systemuser", _user.SystemUserId);
}
if (attributeMetadatas.Exists(n => n.Name.IsCaseInsensitiveEqual("ownerid")))
{
entity.AddIfNotContain("ownerid", new OwnerObject(OwnerTypes.SystemUser, _user.SystemUserId));
}
if (attributeMetadatas.Exists(n => n.Name.IsCaseInsensitiveEqual("owningbusinessunit")) && !_user.BusinessUnitId.Equals(Guid.Empty))
{
entity["owningbusinessunit"] = new EntityReference("businessunit", _user.BusinessUnitId);
}
if (!entity.IdName.IsCaseInsensitiveEqual("organizationid") && attributeMetadatas.Exists(n => n.Name.IsCaseInsensitiveEqual("organizationid")))
{
entity["organizationid"] = new EntityReference("organization", _user.OrganizationId);
}
if (attributeMetadatas.Exists(n => n.Name.IsCaseInsensitiveEqual("createdon")))
{
entity["createdon"] = DateTime.Now;
}
var primaryAttr = attributeMetadatas.Find(n => n.TypeIsPrimaryKey());
if (!entity.ContainsKey(primaryAttr.Name) || entity.GetIdValue().Equals(Guid.Empty))
{
entity.SetAttributeValue(primaryAttr.Name, Guid.NewGuid());
}
//set attribute default value
foreach (var item in attributeMetadatas.Where(n => n.DefaultValue.IsNotEmpty()))
{
entity.AddIfNotContain(item.Name, item.DefaultValue);
}
if (attributeMetadatas.Exists(n => n.Name.IsCaseInsensitiveEqual("statecode")))
{
entity.AddIfNotContain("statecode", true);
}
if (attributeMetadatas.Exists(n => n.Name.IsCaseInsensitiveEqual("statuscode")))
{
entity.AddIfNotContain("statuscode", new OptionSetValue(0));
}
if (!ignorePermissions)
{
VerifyEntityPermission(entity, AccessRightValue.Create, entityMetadata);
}
}
public void Execute(OperationTypeEnum op, Entity data, Schema.Domain.Entity entityMetadata)
{
List <FilterRule> rules = _filterRuleFinder.QueryByEntityId(entityMetadata.EntityId, Enum.GetName(typeof(OperationTypeEnum), op), RecordState.Enabled);
if (rules.NotEmpty())
{
foreach (var rule in rules)
{
if (rule.IsTrue(_attributeFinder, data))
{
throw new XmsException(rule.ToolTip);
}
}
}
}
public bool UpdatedLog(Entity originData, Entity newData, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
if (!entityMetadata.LogEnabled)
{
return(false);
}
EntityLog entity = new EntityLog
{
EntityId = entityMetadata.EntityId,
EntityLogId = Guid.NewGuid(),
OperationType = OperationTypeEnum.Update,
UserId = _currentUser.SystemUserId,
OrganizationId = _currentUser.OrganizationId,
CreatedOn = DateTime.Now,
RecordId = newData.GetIdValue(),
AttributeMask = string.Join(",", newData.Keys)
};
var datas = new List <EntityLogChangeData>();
foreach (var item in newData)
{
var originValue = originData.TryGetValue(item.Key, out object value) ? value.ToString() : "";
if (!originValue.IsCaseInsensitiveEqual(item.Value != null ? item.Value.ToString() : ""))
{
var attr = attributeMetadatas.Find(n => n.Name.IsCaseInsensitiveEqual(item.Key));
if (!item.Key.IsCaseInsensitiveEqual("createdon") && !item.Key.IsCaseInsensitiveEqual("createdby") &&
!item.Key.IsCaseInsensitiveEqual("modifiedon") && !item.Key.IsCaseInsensitiveEqual("modifiedby") &&
!item.Key.IsCaseInsensitiveEqual("versionnumber"))
{
if (attr != null && (attr.TypeIsText() || attr.TypeIsNText()))
{
continue;
}
datas.Add(new EntityLogChangeData()
{
Name = item.Key, Original = originData[item.Key].ToString(), Value = item.Value != null ? item.Value.ToString() : ""
});
}
}
}
entity.ChangeData = datas.SerializeToJson();
return(Create(entity));
}
public bool SharedLog(Entity data, Schema.Domain.Entity entityMetadata)
{
if (!entityMetadata.LogEnabled)
{
return(false);
}
EntityLog entity = new EntityLog
{
EntityId = entityMetadata.EntityId,
EntityLogId = Guid.NewGuid(),
OperationType = OperationTypeEnum.Share,
UserId = _currentUser.SystemUserId,
OrganizationId = _currentUser.OrganizationId,
CreatedOn = DateTime.Now,
RecordId = data.GetIdValue()
};
return(Create(entity));
}
/// <summary>
/// 删除记录时触发的事件
/// </summary>
/// <param name="data"></param>
/// <param name="stage"></param>
/// <param name="entityMetadata"></param>
private void InternalOnDelete(Entity data, OperationStage stage, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
//plugin
_entityPluginExecutor.Execute(OperationTypeEnum.Delete, stage, data, entityMetadata, attributeMetadatas);
if (stage == OperationStage.PreOperation)
{
_eventPublisher.Publish(new EntityDeletingEvent(data)
{
EntityMetadata = entityMetadata, AttributeMetadatas = attributeMetadatas
});
}
else if (stage == OperationStage.PostOperation)
{
_eventPublisher.Publish(new EntityDeletedEvent(data)
{
EntityMetadata = entityMetadata, AttributeMetadatas = attributeMetadatas
});
}
OnDelete(data, stage, entityMetadata, attributeMetadatas);
}
/// <summary>
/// 共享记录时触发的事件
/// </summary>
/// <param name="data"></param>
/// <param name="stage"></param>
/// <param name="entityMetadata"></param>
private void InternalOnShare(Entity data, OperationStage stage, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
//plugin
_entityPluginExecutor.Execute(OperationTypeEnum.Share, stage, data, entityMetadata, attributeMetadatas);
if (stage == OperationStage.PreOperation)
{
_eventPublisher.Publish(new EntitySharingEvent()
{
Data = data, EntityMetadata = entityMetadata, Principals = null
});
}
else if (stage == OperationStage.PostOperation)
{
_eventPublisher.Publish(new EntitySharedEvent()
{
Data = data, EntityMetadata = entityMetadata, Principals = null
});
}
OnShare(data, stage, entityMetadata, attributeMetadatas);
}
/// <summary>
/// 校验更新数据
/// </summary>
/// <param name="entity"></param>
private void VerifyUpdate(Entity entity, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
if (!entity.ContainsKey(entity.IdName))
{
OnException(_loc["sdk_notspecified_primarykey"]);
}
if (!entity[entity.IdName].ToString().IsGuid() || entity.GetGuidValue(entity.IdName).Equals(Guid.Empty))
{
OnException(_loc["sdk_notspecified_primaryvalue"]);
}
_entityValidator.VerifyValues(entity, entityMetadata, attributeMetadatas, (e) => {
OnException(string.Join("\n", e));
});
if (attributeMetadatas.Exists(x => x.Name.IsCaseInsensitiveEqual("modifiedon")))
{
entity.AddIfNotContain("modifiedon", DateTime.Now);
}
if (attributeMetadatas.Exists(x => x.Name.IsCaseInsensitiveEqual("modifiedby")))
{
entity.AddIfNotContain("modifiedby", _user.SystemUserId);
}
}
public IActionResult CreateEntity(CreateEntityModel model)
{
if (ModelState.IsValid)
{
model.Name = model.Name.Trim();
var entity = new Schema.Domain.Entity();
model.CopyTo(entity);
entity.EntityId = Guid.NewGuid();
entity.IsCustomizable = true;
entity.CreatedBy = CurrentUser.SystemUserId;
entity.OrganizationId = CurrentUser.OrganizationId;
if (model.EntityGroupId.NotEmpty())
{
entity.EntityGroups = model.EntityGroupId.SerializeToJson();
}
if (_entityCreater.Create(entity, model.DefaultAttributes))
{
//创建默认按钮
if (model.DefaultButtons.NotEmpty())
{
_eventPublisher.Publish(new CreateDefaultButtonsEvent(entity, model.DefaultButtons));
}
//创建默认表单
if (model.CreateDefaultForm)
{
_eventPublisher.Publish(new CreateDefaultFormEvent(entity));
}
//创建默认视图
if (model.CreateDefaultView)
{
_eventPublisher.Publish(new CreateDefaultViewEvent(entity));
}
return(CreateSuccess(new { id = entity.EntityId }));
}
return(CreateFailure());
}
return(CreateFailure(GetModelErrors()));
}
public IActionResult Post(CreateEntityModel model)
{
if (ModelState.IsValid)
{
if (_entityFinder.FindByName(model.Name) != null)
{
return(JError(T["name_already_exists"]));
}
model.Name = model.Name.Trim();
var entity = new Schema.Domain.Entity();
model.CopyTo(entity);
entity.SolutionId = _solutionId.Value;
entity.IsCustomizable = true;
entity.EntityId = Guid.NewGuid();
entity.CreatedBy = CurrentUser.SystemUserId;
entity.CreatedOn = DateTime.Now;
entity.OrganizationId = CurrentUser.OrganizationId;
_entityCreater.Create(entity);
return(CreateSuccess(new { id = entity.EntityId }));
}
return(CreateFailure(GetModelErrors()));
}
private bool DeleteRelatedRecords(Schema.Domain.Entity entityMetaData, List <Schema.Domain.Attribute> attributeMetadatas, List <Schema.Domain.RelationShip> relationships, Guid parentId)
{
var result = true;
var primaryKeyField = attributeMetadatas.Find(x => x.TypeIsPrimaryKey());
foreach (var rs in relationships)
{
//delete the 'N' records
var query = new QueryExpression(rs.ReferencingEntityName, _languageId);
query.ColumnSet.AddColumn(primaryKeyField.Name);
query.Criteria.AddCondition(rs.ReferencingAttributeName, ConditionOperator.Equal, parentId);
var datas = _organizationDataRetriever.RetrieveAll(query, true)?.ToList();
if (datas.NotEmpty())
{
var entityMetadata2 = GetEntityMetaData(datas.First().Name);
var relationships2 = _relationShipFinder.Query(n => n
.Where(f => f.ReferencedEntityId == entityMetadata2.EntityId && f.RelationshipType == RelationShipType.ManyToOne && f.CascadeDelete == (int)CascadeDeleteType.All)
);
foreach (var item in datas)
{
if (relationships2.NotEmpty())
{
DeleteRelatedRecords(entityMetadata2, attributeMetadatas, relationships2, item.GetIdValue());
}
InternalOnDelete(item, OperationStage.PreOperation, entityMetaData, attributeMetadatas);
result = _organizationDataProvider.Delete(item.Name, item.GetIdValue());
if (result)
{
InternalOnDelete(item, OperationStage.PostOperation, entityMetaData, attributeMetadatas);
_mapUpdater.Update(entityMetadata2, item, true);
_formulaUpdater.Update(entityMetadata2, item);
}
}
}
}
return(result);
}
/// <summary>
/// 校验实体权限
/// </summary>
/// <param name="entity"></param>
/// <param name="access"></param>
/// <param name="entityMetadata"></param>
protected void VerifyEntityPermission(Entity entity, AccessRightValue access, Schema.Domain.Entity entityMetadata = null)
{
entityMetadata = entityMetadata ?? GetEntityMetaData(entity.Name);
//authorization disabled or user is administrator group
if (!entityMetadata.AuthorizationEnabled || _user.IsSuperAdmin)
{
return;
}
bool hasPermission = false;
//operation permission
var roleEntityPermission = _roleObjectAccessEntityPermissionService.FindUserPermission(entity.Name, _user.LoginName, access);
//if (roleEntityPermission == null) return;
//permission depth
var depth = "none";
if (roleEntityPermission != null)
{
var data = entity.UnWrapAttributeValue();
if (entityMetadata.EntityMask == EntityMaskEnum.Organization)
{
var b = data.GetGuidValue("organizationid");
hasPermission = (roleEntityPermission.AccessRightsMask != EntityPermissionDepth.None && this._user.OrganizationId.Equals(b));
}
else
{
var ownerIdType = data.GetIntValue("owneridtype");
//full
if (roleEntityPermission.AccessRightsMask == EntityPermissionDepth.Organization)
{
hasPermission = true;
}
else if (ownerIdType == (int)OwnerTypes.SystemUser)
{
//basic
if (roleEntityPermission.AccessRightsMask == EntityPermissionDepth.Self)
{
hasPermission = data.GetGuidValue("ownerid").Equals(this._user.SystemUserId);
}
//local
else if (roleEntityPermission.AccessRightsMask == EntityPermissionDepth.BusinessUnit)
{
var b = data.GetGuidValue("owningbusinessunit");
hasPermission = _user.BusinessUnitId.Equals(b);
}
//deep
else if (roleEntityPermission.AccessRightsMask == EntityPermissionDepth.BusinessUnitAndChild)
{
var b = data.GetGuidValue("owningbusinessunit");
hasPermission = _businessUnitService.IsChild(this._user.BusinessUnitId, b);
}
}
else if (ownerIdType == (int)OwnerTypes.Team)
{
//basic
if (roleEntityPermission.AccessRightsMask == EntityPermissionDepth.Self)
{
hasPermission = data.GetGuidValue("ownerid").Equals(this._user.SystemUserId);
}
//local
else if (roleEntityPermission.AccessRightsMask == EntityPermissionDepth.BusinessUnit)
{
var b = data.GetGuidValue("owningbusinessunit");
hasPermission = _user.BusinessUnitId.Equals(b);
}
//deep
else if (roleEntityPermission.AccessRightsMask == EntityPermissionDepth.BusinessUnitAndChild)
{
var b = data.GetGuidValue("owningbusinessunit");
hasPermission = _businessUnitService.IsChild(this._user.BusinessUnitId, b);
}
}
}
depth = roleEntityPermission.AccessRightsMask.ToString();
}
//shared permission
if (!hasPermission)
{
var objectId = entity.GetIdValue();
var poa = _principalObjectAccessService.Find(n => n.ObjectId == objectId && n.AccessRightsMask == access);
hasPermission = poa != null;
}
if (!hasPermission)
{
var msg = Enum.GetName(typeof(AccessRightValue), access);
msg = _loc["security_" + msg];
OnException(string.Format(_loc["security_noentitypermission"] + " " + depth, entityMetadata.LocalizedName, msg));
}
}
private void PublishEvents(Entity originData, Entity newData, OperationStage stage, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
if (stage == OperationStage.PreOperation)
{
_eventPublisher.Publish(new EntityUpdatingEvent(originData, newData)
{
EntityMetadata = entityMetadata, AttributeMetadatas = attributeMetadatas
});
}
else if (stage == OperationStage.PostOperation)
{
_eventPublisher.Publish(new EntityUpdatedEvent(originData, newData)
{
EntityMetadata = entityMetadata, AttributeMetadatas = attributeMetadatas
});
}
}
/// <summary>
/// 更新记录时触发的事件
/// </summary>
/// <param name="originData"></param>
/// <param name="newData"></param>
/// <param name="stage"></param>
/// <param name="entityMetadata"></param>
private void InternalOnUpdate(Entity originData, Entity newData, OperationStage stage, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
//plugin
_entityPluginExecutor.Execute(OperationTypeEnum.Update, stage, newData, entityMetadata, attributeMetadatas);
OnUpdate(originData, newData, stage, entityMetadata, attributeMetadatas);
}
/// <summary>
/// 更新记录时执行的方法
/// 运行于事务中
/// </summary>
/// <param name="existsData"></param>
/// <param name="newData"></param>
/// <param name="stage"></param>
/// <param name="entityMetadata"></param>
public virtual void OnUpdate(Entity existsData, Entity newData, OperationStage stage, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
}
/// <summary>
/// 校验各字段值格式
/// </summary>
/// <param name="entity">实体记录</param>
/// <param name="entityMetadata">实体元数据</param>
/// <param name="attributeMetadatas">字段元数据</param>
/// <param name="onError">失败时执行的回调</param>
public void VerifyValues(Entity entity, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas, Action <string> onError)
{
List <string> errors = new List <string>();
foreach (var item in entity)
{
var value = item.Value;
if (value == null)
{
continue;
}
var attr = attributeMetadatas.Find(n => n.Name.IsCaseInsensitiveEqual(item.Key));
if (attr != null)
{
if (attr.TypeIsBit() || attr.TypeIsState())
{
//是否存在该值
if (!(value is bool) && !value.ToString().IsInteger())
{
errors.Add(string.Format("{0}'s value({1}) is not valid, it's type should be 'bool' or integer", attr.Name, value.ToString()));
}
}
else if (attr.TypeIsLookUp())
{
if (value is EntityReference)
{
var er = value as EntityReference;
//是否存在该引用实体
if (!_entityFinder.Exists(er.ReferencedEntityName))
{
errors.Add(string.Format("referenced entity '{0}' is not found by attribute '{1}'", er.ReferencedEntityName, attr.Name));
}
//是否存在该值
//var referencedRecord =
}
else
{
errors.Add(string.Format("{0}'s value({1}) is not valid, it's type should be 'SDK.EntityReference'", attr.Name, value.ToString()));
}
}
else if (attr.TypeIsPickList() || attr.TypeIsStatus())
{
//是否正确的格式
if (!(value is OptionSetValue) && !value.ToString().IsInteger())
{
errors.Add(string.Format("{0}'s value({1}) is not valid, it's type should be 'SDK.OptionSetValue' or integer", attr.Name, value.ToString()));
}
//是否存在该值
}
else if (attr.TypeIsOwner())
{
//是否正确的格式
if (!(value is OwnerObject))
{
errors.Add(string.Format("{0}'s value({1}) is not valid, it's type should be 'SDK.OwnerObject'", attr.Name, value.ToString()));
}
//是否存在该值
}
else if (attr.TypeIsInt())
{
//是否正确的格式
if (!value.ToString().IsInteger())
{
errors.Add(string.Format("{0}'s value({1}) is not valid, it's type should be 'int'", attr.Name, value.ToString()));
}
}
else if (attr.TypeIsFloat())
{
//是否正确的格式
if (!value.ToString().IsNumeric())
{
errors.Add(string.Format("{0}'s value({1}) is not valid, it's type should be 'float'", attr.Name, value.ToString()));
}
}
else if (attr.TypeIsMoney())
{
//是否正确的格式
if (!(value is Money))
{
errors.Add(string.Format("{0}'s value({1}) is not valid, it's type should be 'SDK.Money'", attr.Name, value.ToString()));
}
}
else if (attr.TypeIsDateTime())
{
//是否正确的格式
if (!value.ToString().IsDateTime())
{
errors.Add(string.Format("{0}'s value({1}) is not valid, it's type should be 'datetime'", attr.Name, value.ToString()));
}
}
}
else
{
errors.Add(string.Format("attribute with name'{0}' is not found", item.Key, value.ToString()));
}
}
if (errors.NotEmpty())
{
onError(string.Join("\n", errors));
}
}
/// <summary>
/// 单据转换时执行的方法
/// 运行于事务中
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
/// <param name="stage"></param>
/// <param name="entityMetadata"></param>
public virtual void OnMap(Entity source, Entity target, OperationStage stage, Schema.Domain.Entity targetEntityMeta, List <Schema.Domain.Attribute> targetAttributeMetadatas)
{
}
/// <summary>
/// 单据转换时触发的事件
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
/// <param name="stage"></param>
/// <param name="targetEntityMeta"></param>
private void InternalOnMap(Entity source, Entity target, OperationStage stage, Schema.Domain.Entity targetEntityMeta, List <Schema.Domain.Attribute> targetAttributeMetadatas)
{
//plugin
_entityPluginExecutor.Execute(OperationTypeEnum.Merge, stage, target, targetEntityMeta, targetAttributeMetadatas);
if (stage == OperationStage.PreOperation)
{
_eventPublisher.Publish(new EntityMappingEvent()
{
Source = source, Target = target, EntityMetadata = targetEntityMeta
});
}
else if (stage == OperationStage.PostOperation)
{
_eventPublisher.Publish(new EntityMappedEvent()
{
Source = source, Target = target, EntityMetadata = targetEntityMeta
});
}
OnMap(source, target, stage, targetEntityMeta, targetAttributeMetadatas);
}
/// <summary>
/// 分派记录时触发的事件
/// </summary>
/// <param name="data"></param>
/// <param name="newOwnerEntity"></param>
/// <param name="stage"></param>
/// <param name="entityMetadata"></param>
private void InternalOnAssign(Entity data, Entity newOwnerEntity, OperationStage stage, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
//plugin
_entityPluginExecutor.Execute(OperationTypeEnum.Assign, stage, newOwnerEntity, entityMetadata, attributeMetadatas);
if (stage == OperationStage.PreOperation)
{
_eventPublisher.Publish(new EntityAssigningEvent()
{
OriginData = data, Data = newOwnerEntity, EntityMetadata = entityMetadata
});
}
else if (stage == OperationStage.PostOperation)
{
_eventPublisher.Publish(new EntityAssignedEvent()
{
OriginData = data, Data = newOwnerEntity, EntityMetadata = entityMetadata
});
}
OnAssign(data, newOwnerEntity, stage, entityMetadata, attributeMetadatas);
}
/// <summary>
/// 生成默认视图
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public (Domain.QueryView DefaultView, List <Dependency.Domain.Dependency> Dependents) Get(Schema.Domain.Entity entity, List <Schema.Domain.Attribute> attributes)
{
Domain.QueryView view = new Domain.QueryView
{
Name = entity.LocalizedName,
EntityId = entity.EntityId,
EntityName = entity.Name,
IsDefault = true,
StateCode = Core.RecordState.Enabled,
IsPrivate = false,
QueryViewId = Guid.NewGuid(),
CreatedBy = entity.CreatedBy
};
//fetch
QueryExpression _queryExpression = new QueryExpression(entity.Name, _appContext.GetFeature <ICurrentUser>().UserSettings.LanguageId);
_queryExpression.Distinct = false;
_queryExpression.NoLock = true;
_queryExpression.AddOrder("createdon", OrderType.Descending);
var primaryField = attributes.Find(n => n.IsPrimaryField);
_queryExpression.ColumnSet = new ColumnSet(primaryField.Name.ToLower(), "createdon");
if (entity.EntityMask == EntityMaskEnum.User)
{
_queryExpression.ColumnSet.AddColumn("ownerid");
}
view.FetchConfig = _queryExpression.SerializeToJson();
//layout
GridDescriptor grid = new GridDescriptor();
RowDescriptor row = new RowDescriptor();
row.AddCell(new CellDescriptor()
{
Name = primaryField.Name.ToLower(), EntityName = entity.Name, IsHidden = false, IsSortable = true, Width = 150
});
row.AddCell(new CellDescriptor()
{
Name = "createdon", EntityName = entity.Name, IsHidden = false, IsSortable = true, Width = 150
});
if (entity.EntityMask == EntityMaskEnum.User)
{
row.AddCell(new CellDescriptor()
{
Name = "ownerid", EntityName = entity.Name, IsHidden = false, IsSortable = true, Width = 150
});
}
grid.AddRow(row);
grid.AddSort(new QueryColumnSortInfo("createdon", false));
view.LayoutConfig = grid.SerializeToJson(false);
var dependents = new List <Dependency.Domain.Dependency>();
foreach (var item in attributes.Where(x => x.Name.IsCaseInsensitiveEqual(primaryField.Name) || x.Name.IsCaseInsensitiveEqual("createdon") || x.Name.IsCaseInsensitiveEqual("ownerid")))
{
var dp = new Dependency.Domain.Dependency();
//dp.DependentComponentType = DependencyComponentTypes.Get(QueryViewDefaults.ModuleName);
dp.DependentObjectId = view.QueryViewId;
//dp.RequiredComponentType = DependencyComponentTypes.Get(AttributeDefaults.ModuleName);
dp.RequiredObjectId = item.AttributeId;
dependents.Add(dp);
}
return(view, dependents);
}
public bool Assign(Schema.Domain.Entity entityMetadata, Entity entity, OwnerObject owner, bool ignorePermissions = false)
{
if (!ignorePermissions)
{
VerifyEntityPermission(entity, AccessRightValue.Assign, entityMetadata);
}
var recordId = entity.GetIdValue();
Entity ownerEntity = null;
Entity updateEntity = new Entity(entityMetadata.Name);
updateEntity.SetIdValue(recordId);
updateEntity.SetAttributeValue("ownerid", owner);
if (owner.OwnerType == OwnerTypes.SystemUser)
{
if (owner.OwnerId.Equals(_user.SystemUserId))
{
updateEntity.SetAttributeValue("owningbusinessunit", _user.BusinessUnitId);
}
else
{
//business unit
var queryBusinessUnit = new QueryExpression("systemuser", _languageId);
queryBusinessUnit.ColumnSet.AddColumn("businessunitid");
queryBusinessUnit.Criteria.AddCondition("systemuserid", ConditionOperator.Equal, owner.OwnerId);
ownerEntity = _organizationDataRetriever.Retrieve(queryBusinessUnit, true);
updateEntity.SetAttributeValue("owningbusinessunit", ownerEntity.GetGuidValue("businessunitid"));
}
updateEntity.SetAttributeValue("modifiedon", DateTime.Now);
updateEntity.SetAttributeValue("modifiedby", _user.SystemUserId);
}
else
{
updateEntity.SetAttributeValue("owningbusinessunit", null);
}
var attributeMetadatas = _attributeFinder.FindByEntityId(entityMetadata.EntityId);
var result = true;
try
{
_organizationDataProvider.BeginTransaction();
InternalOnAssign(entity, updateEntity, OperationStage.PreOperation, entityMetadata, attributeMetadatas);
result = _organizationDataProvider.Update(updateEntity);
if (result)
{
//assign cascade relationship, 1: N
var relationships = _relationShipFinder.Query(n => n
.Where(f => f.ReferencedEntityId == entityMetadata.EntityId && f.CascadeAssign != (int)CascadeUpdateType.None)
);
if (relationships.NotEmpty())
{
foreach (var rs in relationships)
{
var relatedEntityMeta = _entityFinder.FindById(rs.ReferencingEntityId);
if (relatedEntityMeta.EntityMask == EntityMaskEnum.Organization)
{
continue;
}
var queryRelated = new QueryExpression(rs.ReferencingEntityName, _languageId);
queryRelated.ColumnSet.AddColumns(rs.ReferencingEntityName + "id");
queryRelated.Criteria.AddCondition(rs.ReferencingAttributeName, ConditionOperator.Equal, recordId);
//update related records
Entity updEntity = new Entity(rs.ReferencingEntityName);
updEntity.SetAttributeValue("ownerid", owner);
if (owner.OwnerType == OwnerTypes.SystemUser)
{
updEntity.SetAttributeValue("owningbusinessunit", ownerEntity.GetGuidValue("businessunitid"));
}
else
{
updEntity.SetAttributeValue("owningbusinessunit", null);
}
updEntity.SetAttributeValue("modifiedon", DateTime.Now);
updEntity.SetAttributeValue("modifiedby", _user.SystemUserId);
_organizationDataProvider.Update(updEntity, _queryResolverFactory.Get(queryRelated), true);
}
}
_organizationDataProvider.CommitTransaction();
InternalOnAssign(entity, updateEntity, OperationStage.PostOperation, entityMetadata, attributeMetadatas);
}
else
{
_organizationDataProvider.RollBackTransaction();
}
}
catch (Exception e)
{
_organizationDataProvider.RollBackTransaction();
return(OnException(e));
}
return(true);
}
/// <summary>
/// 新建记录时执行的方法
/// 运行于事务中
/// </summary>
/// <param name="data"></param>
/// <param name="stage"></param>
/// <param name="entityMetadata"></param>
public virtual void OnCreate(Entity data, OperationStage stage, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
}
public bool CreateDefaultForm(Schema.Domain.Entity entity)
{
var(DefaultForm, Dependents) = _defaultSystemFormProvider.Get(entity);
return(this.Create(DefaultForm));
}
