Beispiel #1
0
        /// <summary>
        ///  获取实体对象的配置主键。
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="entityMappingInfo"></param>
        /// <returns></returns>
        public string GetPrimaryKey(object entity, ref MB.Orm.Mapping.ModelMappingInfo entityMappingInfo)
        {
            Type entityType = entity.GetType();

            MB.Orm.Mapping.ModelMappingInfo mappingInfo = MB.Orm.Mapping.AttMappingManager.Instance.GetModelMappingInfo(entityType);

            if (string.IsNullOrEmpty(mappingInfo.MapTable))
            {
                throw new MB.Util.APPException(string.Format("数据实体{0} 配置有误,没有指定映射到的表。", entityType.FullName), MB.Util.APPMessageType.SysErrInfo);
            }

            if (mappingInfo.PrimaryKeys == null || mappingInfo.PrimaryKeys.Count != 1)
            {
                throw new MB.Util.APPException(string.Format("数据实体{0} 配置有误,没有指定主键或者不是单一主键配置。", entityType.FullName), MB.Util.APPMessageType.SysErrInfo);
            }

            MB.Orm.Mapping.FieldPropertyInfo keyInfo = mappingInfo.PrimaryKeys.Values.FirstOrDefault <MB.Orm.Mapping.FieldPropertyInfo>();
            if (keyInfo == null || !MB.Util.MyReflection.Instance.CheckObjectExistsProperty(entity, keyInfo.FieldName))
            {
                throw new MB.Util.APPException(string.Format("在检查下级对象引用时,对象主键{0}在对象{1}中不存在。请检查配置信息!", keyInfo.FieldName, entity.GetType().FullName), MB.Util.APPMessageType.DisplayToUser);
            }

            entityMappingInfo = mappingInfo;
            return(keyInfo.FieldName);
        }
Beispiel #2
0
        public BuilderData(Type entityType)
        {
            _EntityType    = entityType;
            _EntityMapping = MB.Orm.Mapping.AttMappingManager.Instance.GetModelMappingInfo(entityType);

            Parameters = new List <SqlParamInfo>();
            Columns    = new List <SmartTableColumnInfo>();
            Where      = new List <SmartTableColumnInfo>();
        }
        /// <summary>
        /// 批量创建实体对象。
        /// </summary>
        /// <param name="baseRule"></param>
        /// <param name="dataInDocType"></param>
        /// <param name="createCount"></param>
        /// <returns></returns>
        public IList CreateNewEntityBatch(IBaseRule baseRule, object dataInDocType, int createCount)
        {
            ObjectDataMappingAttribute mappingAtt = AttributeConfigHelper.Instance.GetObjectDataMappingAttribute(dataInDocType);

            if (mappingAtt == null)
            {
                throw new MB.RuleBase.Exceptions.RequireConfigDataMappingException(dataInDocType);
            }
            Type entityType = mappingAtt.EntityType;

            if (string.Compare(entityType.FullName, "System.Object", true) == 0)
            {
                if (mappingAtt.EntityType == null)
                {
                    throw new MB.Util.APPException("业务类:" + baseRule.GetType().FullName + " 中的:" +
                                                   dataInDocType.GetType() + " 的数据值:" + dataInDocType.ToString() +
                                                   " 在配置ObjectDataMapping时需要配置 EntityType", MB.Util.APPMessageType.SysErrInfo);
                }
            }
            List <object> lstData = new List <object>();
            int           id      = 0;

            //判断是否为自增列
            if (mappingAtt.KeyIsSelfAdd)
            {
                id = MB.Orm.Persistence.EntityIdentityHelper.NewInstance.GetEntityIdentity(mappingAtt.MappingTableName, createCount);
            }
            for (int i = 0; i < createCount; i++)
            {
                object entity = MB.Util.DllFactory.Instance.CreateInstance(entityType);
                //判断是否为自增列
                if (id > 0)
                {
                    MB.Util.MyReflection.Instance.InvokePropertyForSet(entity, mappingAtt.KeyName, id++);
                }
                if (entity.GetType().IsSubclassOf(typeof(MB.Orm.Common.BaseModel)))
                {
                    (entity as MB.Orm.Common.BaseModel).EntityState = EntityState.New;
                }
                //设置默认值
                MB.Orm.Mapping.ModelMappingInfo mappingInfo = MB.Orm.Mapping.AttMappingManager.Instance.GetModelMappingInfo(entityType);
                foreach (MB.Orm.Mapping.FieldPropertyInfo colProperty in mappingInfo.FieldPropertys.Values)
                {
                    if (colProperty.DefaultValue == null)
                    {
                        continue;
                    }

                    System.Reflection.PropertyInfo proInfo = entityType.GetProperty(colProperty.PropertyName);
                    proInfo.SetValue(entity, colProperty.DefaultValue, null);
                }
                lstData.Add(entity);
            }
            return(lstData);
        }
        /// <summary>
        /// 提交指定的业务处理数据。
        /// </summary>
        /// <param name="baseRule"></param>
        /// <param name="mainEntity"></param>
        /// <returns></returns>
        public int ObjectSubmit(MB.RuleBase.IFace.IBaseRule baseRule, object mainEntity)
        {
            MB.Orm.Mapping.ModelMappingInfo mappingInfo = null;
            string keyName = MB.Orm.Mapping.AttMappingManager.Instance.GetPrimaryKey(mainEntity, ref mappingInfo);


            object keyValue = MB.Util.MyReflection.Instance.InvokePropertyForGet(mainEntity, keyName);
            string sql      = string.Format("UPDATE  {0} SET {1} = '1',{2} = SYSTIMESTAMP WHERE {3} = '{4}' ", mappingInfo.MapTable, ENTITY_DOC_STATE, ENTITY_LAST_MODIFIED_DATE, keyName, keyValue.ToString());

            Database db = MB.Orm.Persistence.DatabaseHelper.CreateDatabase();

            //在提交之前先检查服务器日期
            MB.Orm.Persistence.EntityDistributedHelper.NewInstance.CheckEntityCanSave(mainEntity);

            DbCommand cmd = db.GetSqlStringCommand(sql);

            _DbExexuteHelper.ExecuteNonQuery(db, cmd);

            return(1);
        }
        /// <summary>
        /// 检查当前对象是否已被其它对象引用。
        /// </summary>
        /// <param name="db"></param>
        /// <param name="baseRule"></param>
        /// <param name="mainEntity"></param>
        /// <param name="restrictOption"></param>
        /// <returns></returns>
        public bool ObjectOwnerless(Database db, MB.RuleBase.IFace.IBaseRule baseRule, object mainEntity, LinkRestrictOption restrictOption)
        {
            if (restrictOption == LinkRestrictOption.CancelSubmit)
            {
                if (!CheckExistsDocState(mainEntity))
                {
                    return(true);
                }

                var docState = GetEntityDocState(mainEntity);

                if (docState == DocState.Progress)
                {
                    return(true);
                }
            }
            RuleSettingAttribute ruleSettAtt = MB.RuleBase.Atts.AttributeConfigHelper.Instance.GetRuleSettingAtt(baseRule);

            //如果用户没有配置那么表示不需要上级引用的约束控制
            if (ruleSettAtt == null || ruleSettAtt.BaseDataType == null)
            {
                return(true);
            }

            NextOwnAttribute[] atts = MB.RuleBase.Atts.AttributeConfigHelper.Instance.GetNextOwnAttByType(ruleSettAtt.BaseDataType);
            if (atts == null || atts.Length == 0)
            {
                return(true);
            }


            List <DbCommand> cmds           = new List <DbCommand>();
            string           objDescription = string.Empty;

            MB.Orm.Mapping.ModelMappingInfo mappingInfo = null;
            string keyName = MB.Orm.Mapping.AttMappingManager.Instance.GetPrimaryKey(mainEntity, ref mappingInfo);

            object keyValue = MB.Util.MyReflection.Instance.InvokePropertyForGet(mainEntity, keyName);

            foreach (NextOwnAttribute att in atts)
            {
                //只有配置成 阻止撤消提交的,才进行这样的处理
                if (att.RestrictOption != restrictOption)
                {
                    continue;
                }

                if (string.IsNullOrEmpty(att.CfgXmlSqlName))
                {
                    string sql = string.Format("SELECT 1 FROM {0} WHERE {1}='{2}'", att.OwnTableName, att.OwnFieldName, keyValue.ToString());
                    if (!string.IsNullOrEmpty(att.OwnFilter))
                    {
                        sql += string.Format(att.OwnFilter, keyValue.ToString());
                    }
                    DbCommand tempCmd = db.GetSqlStringCommand(sql);
                    cmds.Add(tempCmd);
                }
                else
                {
                    System.Data.Common.DbCommand[] tempCmds = MB.Orm.Persistence.PersistenceManagerHelper.NewInstance.CreateDbCommandByXml(db,
                                                                                                                                           mappingInfo.XmlConfigFileName, att.CfgXmlSqlName, keyValue);

                    if (tempCmds.Length != 1)
                    {
                        throw new MB.RuleBase.Exceptions.SelectSqlXmlConfigException(mappingInfo.XmlConfigFileName, att.CfgXmlSqlName);
                    }

                    cmds.AddRange(tempCmds);
                }

                if (objDescription.Length == 0)
                {
                    objDescription = "<<" + att.OwnDescription + ">>";
                }
                else
                {
                    objDescription += "或 <<" + att.OwnDescription + ">>";
                }
            }
            foreach (DbCommand dbCmd in cmds)
            {
                object val = _DbExexuteHelper.ExecuteScalar(db, dbCmd);
                if (val != null && val != System.DBNull.Value)
                {
                    throw new MB.Util.APPException(string.Format("由于该对象已生成{0},不能再进行重做。", objDescription),
                                                   MB.Util.APPMessageType.DisplayToUser);
                }
            }

            return(true);
        }
        /// <summary>
        /// 根据键值获取包含值的实体对象。
        /// </summary>
        /// <typeparam name="T">从MB.Orm.Common.BaseModel 中继承的数据对象类型。</typeparam>
        /// <param name="baseRule">获取实体对象集合的业务类。</param>
        /// <param name="dataInDocType">在业务类中的数据类型。</param>
        /// <param name="keyValue">需要获取实体键值。</param>
        /// <returns>返回指定类型的实体对象。</returns>
        public T GetObjectByKey <T>(IBaseRule baseRule, object dataInDocType, object keyValue)
        {
            ObjectDataMappingAttribute mappingAtt = AttributeConfigHelper.Instance.GetObjectDataMappingAttribute(dataInDocType);

            if (mappingAtt == null)
            {
                throw new MB.RuleBase.Exceptions.RequireConfigDataMappingException(dataInDocType);
            }

            Database db = MB.Orm.Persistence.DatabaseHelper.CreateDatabase();

            System.Data.Common.DbCommand[] cmds = MB.Orm.Persistence.PersistenceManagerHelper.NewInstance.CreateDbCommandByXml(db,
                                                                                                                               mappingAtt.MappingXmlFileName, MB.Orm.Mapping.Xml.XmlSqlMappingInfo.SQL_SELECT_BY_KEY, keyValue);

            if (cmds.Length != 1)
            {
                throw new MB.RuleBase.Exceptions.SelectSqlXmlConfigException(mappingAtt.MappingXmlFileName, MB.Orm.Mapping.Xml.XmlSqlMappingInfo.SQL_SELECT_BY_KEY);
            }

            System.Data.Common.DbCommand cmd = cmds[0];
            Type entityType = typeof(T);

            if (string.Compare(entityType.FullName, "System.Object", true) == 0)
            {
                if (mappingAtt.EntityType == null)
                {
                    throw new MB.Util.APPException("业务类:" + baseRule.GetType().FullName + " 中的:" +
                                                   dataInDocType.GetType() + " 的数据值:" + dataInDocType.ToString() +
                                                   " 在配置ObjectDataMapping时需要配置 EntityType", MB.Util.APPMessageType.SysErrInfo);
                }
                entityType = mappingAtt.EntityType;
            }
            bool isBaseModelSub = entityType.IsSubclassOf(typeof(BaseModel));

            MB.Orm.Mapping.ModelMappingInfo modelMapping = MB.Orm.Mapping.AttMappingManager.Instance.GetModelMappingInfo(entityType);
            object entity = MB.Util.DllFactory.Instance.CreateInstance(entityType);
            string cmdMsg = MB.Orm.Persistence.DbCommandExecuteTrack.Instance.CommandToTrackMessage(db, cmd);

            MB.Util.TraceEx.Write("正在执行:" + cmdMsg);
            using (new Util.MethodTraceWithTime(cmdMsg))
            {
                using (IDataReader reader = db.ExecuteReader(cmd))
                {
                    try
                    {
                        DataTable dtReader = reader.GetSchemaTable();
                        while (reader.Read())
                        {
                            foreach (MB.Orm.Mapping.FieldPropertyInfo proInfo in modelMapping.FieldPropertys.Values)
                            {
                                if (dtReader.Select(string.Format("ColumnName='{0}'", proInfo.FieldName)).Length <= 0)
                                {
                                    continue;
                                }
                                if (reader[proInfo.FieldName] != System.DBNull.Value)
                                {
                                    MB.Util.MyReflection.Instance.InvokePropertyForSet(entity, proInfo.PropertyName, reader[proInfo.FieldName]);
                                }
                            }
                            break;
                        }
                    }
                    catch (Exception ex)
                    {
                        throw new MB.RuleBase.Exceptions.DatabaseExecuteException("执行" + baseRule.GetType().FullName + "GetObjectByKey<T> 出错!", ex);
                    }
                    finally
                    {
                    }
                }
            }
            if (isBaseModelSub)
            {
                MB.Orm.Common.BaseModel temp = entity as MB.Orm.Common.BaseModel;
                //if (temp == null)
                //    throw new MB.Util.APPException(string.Format("所有的数据实体对象都必须从MB.Orm.Common.BaseModel 继承,请检查{0}", entity.GetType()));
                temp.EntityState = EntityState.Persistent;
            }
            return((T)entity);
        }