public bool ValidateInstance(string jsonData, out string errorMsg)
        {
            errorMsg = "";
            bool result = false;
            ValidationResults validateResult = new ValidationResults();

            try
            {
                //反序列化
                DEEntityInstance resultInstance = JSONSerializerExecute.Deserialize <DEEntityInstanceBase>(jsonData) as DEEntityInstance;
                validateResult = resultInstance.Validate();

                if (validateResult.IsValid())
                {
                    result = true;
                }
                else
                {
                    //错误信息格式 json格式
                    errorMsg = "[";
                    foreach (var rst in validateResult)
                    {
                        errorMsg += string.Format("{{{0}}},", rst.Message.ToString());
                    }
                    errorMsg = errorMsg.TrimEnd(',') + "]";
                }
            }
            catch (Exception e)
            {
                errorMsg = string.Format("[{{'ErrorMsg':'{0}'}}]", e.Message);
            }

            return(result);
        }
示例#2
0
        /// <summary>
        /// 创建该实体定义的实例(提醒一下各位Coder:实体实例不能New出来只能调用此方法获得)
        /// </summary>
        /// <param name="instenceID">流程示例ID</param>
        /// <returns>流程示例</returns>
        public DEEntityInstanceBase CreateInstance(string instenceID)
        {
            DynamicEntity        entity = DEDynamicEntityAdapter.Instance.LoadWithCache(this.ID) as DynamicEntity;
            DEEntityInstanceBase result = new DEEntityInstance(entity.ID);

            result.ID          = instenceID.IsNotEmpty() ? instenceID : UuidHelper.NewUuidString();
            result.Name        = this.Name + "实体实例";
            result.Description = this.Description;
            return(result);
        }
        /// <summary>
        /// 验证实体实例的值得类型是否合法
        /// </summary>
        /// <param name="objectToValidate"></param>
        /// <param name="currentObject"></param>
        /// <param name="key"></param>
        /// <param name="validateResults"></param>
        protected override void DoValidate(object objectToValidate, object currentObject, string key, Validation.ValidationResults validateResults)
        {
            DEEntityInstance instanceData = objectToValidate as DEEntityInstance;

            instanceData.Fields.ForEach(f =>
            {
                //字段的值
                object fieldValue = f.GetRealValue();

                if (f.Definition.FieldType == Enums.FieldTypeEnum.Collection)
                {
                    DEEntityInstanceBaseCollection childEntities = f.GetRealValue() as DEEntityInstanceBaseCollection;
                    if (fieldValue is string)
                    {
                        //"实体实例'{0}'(实体的ID:{1})的字段'{2}'长度没有通过验证"
                        RecordValidationResult(validateResults,
                                               string.Format(this.MessageTemplate, f.Definition.ID),
                                               instanceData,
                                               key);
                    }
                    childEntities.ForEach(ce =>
                    {
                        ce.Validate();
                    });
                }
                else
                {
                    //添加验证,调用值转换函数
                    if (!IsOk(f.Definition.FieldType.ToString(), f.StringValue))
                    {
                        RecordValidationResult(validateResults,
                                               string.Format(this.MessageTemplate, f.Definition.ID),
                                               instanceData,
                                               key);
                    }
                    //if (f.StringValue is string && f.Definition.FieldType != Enums.FieldTypeEnum.String)
                    //{
                    //    RecordValidationResult(validateResults,
                    //        string.Format(this.MessageTemplate, instanceData.Name, instanceData.ID, f.Definition.Name),
                    //        instanceData,
                    //        key);
                    //}
                }
            });
        }
        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public DEEntityInstanceBaseCollection LoadByEntityID(string entityID, int pageIndex, int pageSize, ref int totalNum)
        {
            DataView dataView = InnerQuery(entityID, pageIndex, pageSize, "CreateDate", ref totalNum);

            DataTable table = dataView.ToTable();

            Dictionary <string, DynamicEntity> schemaElements = new Dictionary <string, DynamicEntity>(StringComparer.OrdinalIgnoreCase);

            DEEntityInstanceBaseCollection instanceCollection = new DEEntityInstanceBaseCollection();

            for (int i = 0; i < table.Rows.Count; i++)
            {
                DynamicEntity dynamicEntity = null;

                string entityCode = table.Rows[i]["EntityCode"].ToString();
                string data       = table.Rows[i]["Data"].ToString();

                if (schemaElements.TryGetValue(entityCode, out dynamicEntity) == false)
                {
                    dynamicEntity = DESchemaObjectAdapter.Instance.Load(entityCode) as DynamicEntity;
                    schemaElements.Add(entityCode, dynamicEntity);
                }

                if (dynamicEntity != null)
                {
                    DEEntityInstance obj = (DEEntityInstance)dynamicEntity.CreateInstance();

                    obj.FromString(data);

                    ORMapping.DataRowToObject(table.Rows[i], obj);

                    if (instanceCollection.ContainsKey(obj.ID) == false)
                    {
                        instanceCollection.Add(obj);
                    }
                }
            }

            return(instanceCollection);
        }
        protected override void DoValidate(object objectToValidate, object currentObject, string key, Validation.ValidationResults validateResults)
        {
            DEEntityInstance instanceData = objectToValidate as DEEntityInstance;

            instanceData.Fields.ForEach(f =>
            {
                if (f.Definition.FieldType == Enums.FieldTypeEnum.Collection)
                {
                    DEEntityInstanceBaseCollection childEntities = f.GetRealValue() as DEEntityInstanceBaseCollection;
                    if (childEntities.Count > f.Definition.Length)
                    {
                        //"实体实例'{0}'(实体的ID:{1})的字段'{2}'长度没有通过验证"
                        RecordValidationResult(validateResults,
                                               string.Format(this.MessageTemplate, f.Definition.ID),
                                               instanceData,
                                               key);
                    }
                    childEntities.ForEach(ce =>
                    {
                        ce.Validate();
                    });
                }
                else
                {
                    if ((((f.Definition.FieldType == Enums.FieldTypeEnum.Bool) && (f.Definition.Length != 1)) ||
                         ((f.Definition.FieldType != Enums.FieldTypeEnum.Bool) && (f.StringValue.Length > f.Definition.Length))
                         ) && (f.Definition.FieldType != Enums.FieldTypeEnum.DateTime)
                        )
                    {
                        RecordValidationResult(validateResults,
                                               string.Format(this.MessageTemplate, f.Definition.ID),
                                               instanceData,
                                               key);
                    }
                }
            });
        }