示例#1
0
        /// <summary>
        /// 删除一条数据
        /// </summary>
        public bool Delete(int UserID, int ID)
        {
            Model.REPORT original = GetModel(UserID, ID);

            #region Clear columns from ReportColumn table first
            REPORTCOLUMN dalRC = new REPORTCOLUMN();
            List <Model.REPORTCOLUMN> rclist = dalRC.GetModelListForReport(UserID, ID);
            foreach (Model.REPORTCOLUMN rc in rclist)
            {
                dalRC.Delete(UserID, rc.ID);
            }
            #endregion

            StringBuilder strSql = new StringBuilder();
            strSql.Append("delete from REPORT ");
            strSql.Append(" where ID=@ID");
            SqlParameter[] parameters =
            {
                new SqlParameter("@ID", SqlDbType.Int, 4)
            };
            parameters[0].Value = ID;

            int rows = DbHelperSQL.ExecuteSql(UserID, strSql.ToString(), parameters);
            if (rows > 0)
            {
                Model.AUDITLOG auditobj = original.GetAuditLogObject(null);
                auditobj.UserID      = UserID;
                auditobj.CreateDate  = DateTime.Now;
                auditobj.MessageType = Model.AUDITLOG.Severity.Audit;
                auditobj.ModuleName  = "DAL.REPORT.Delete";
                auditobj.Message     = String.Format(AppNum.AuditMessage.ReportDeleteSuccess, ID);

                AUDITLOG.Add(auditobj);

                return(true);
            }
            else
            {
                return(false);
            }
        }
示例#2
0
        /// <summary>
        /// Create AUDITLOG object and set MessageDetail according to object difference
        /// </summary>
        /// <param name="newvalue">Model holding new values</param>
        /// <param name="oldvalue">Model holding original values, can be null if it's insert action</param>
        /// <returns></returns>
        internal static Model.AUDITLOG GetAuditLogObject(this Model.REPORT newvalue, Model.REPORT oldvalue)
        {
            Model.AUDITLOG result = new Model.AUDITLOG();
            PropertyInfo[] pinfo  = typeof(Model.REPORT).GetProperties();
            StringBuilder  sb     = new StringBuilder();

            if (oldvalue == null)
            {
                // new record
                foreach (PropertyInfo p in pinfo)
                {
                    switch (p.Name)
                    {
                    case "TYPE":
                    case "EXTENDFIELD":
                    case "PRINT_ORIENTATION":
                    case "REPORT_HEADER":
                    {
                        // skip these properties
                    }
                    break;

                    case "ReportColumns":
                    {
                        PropertyInfo[] rcinfo = typeof(Model.REPORTCOLUMN).GetProperties();
                        for (int i = 0; i < newvalue.ReportColumns.Count; i++)
                        {
                            foreach (PropertyInfo rcp in rcinfo)
                            {
                                switch (rcp.Name)
                                {
                                case "COLUMNFUNC":
                                case "COLUMNTYPE":
                                case "SelectStatement":
                                {
                                    // skip these properties
                                }
                                break;

                                default:
                                {
                                    sb.AppendFormat("ReportColumns[{0}].{1} = {2}\r\n", i, rcp.Name, rcp.GetValue(newvalue.ReportColumns[i], null));
                                }
                                break;
                                }
                            }
                        }
                    }
                    break;

                    case "WordFile":
                    {
                        if (newvalue.WordFile != null)
                        {
                            PropertyInfo[] wfinfo = typeof(Model.WORDFILE).GetProperties();
                            foreach (PropertyInfo wfp in wfinfo)
                            {
                                sb.AppendFormat("WordFile.{0} = {1}\r\n", wfp.Name, wfp.GetValue(newvalue.WordFile, null));
                            }
                        }
                        else
                        {
                            sb.Append("WordFile = (null)\r\n");
                        }
                    }
                    break;

                    default:
                    {
                        sb.AppendFormat("{0} = {1}\r\n", p.Name, p.GetValue(newvalue, null));
                    }
                    break;
                    }
                }
            }
            else
            {
                // old record
                foreach (PropertyInfo p in pinfo)
                {
                    switch (p.Name)
                    {
                    case "TYPE":
                    case "EXTENDFIELD":
                    case "PRINT_ORIENTATION":
                    case "REPORT_HEADER":
                    {
                        // skip these properties
                    }
                    break;

                    case "ReportColumns":
                    {
                        PropertyInfo[] rcinfo = typeof(Model.REPORTCOLUMN).GetProperties();
                        #region Check for new and updated columns
                        Model.REPORTCOLUMN oldrc = null;
                        for (int i = 0; i < newvalue.ReportColumns.Count; i++)
                        {
                            oldrc = oldvalue.ReportColumns.Where(x => (x.COLUMNFUNC == newvalue.ReportColumns[i].COLUMNFUNC) &&
                                                                 (x.COLUMNTYPE == newvalue.ReportColumns[i].COLUMNTYPE) &&
                                                                 (x.DisplayName == newvalue.ReportColumns[i].DisplayName)).FirstOrDefault();
                            if (oldrc == null)
                            {
                                // new report column
                                foreach (PropertyInfo rcp in rcinfo)
                                {
                                    switch (rcp.Name)
                                    {
                                    case "COLUMNFUNC":
                                    case "COLUMNTYPE":
                                    case "SelectStatement":
                                    {
                                        // skip these properties
                                    }
                                    break;

                                    default:
                                    {
                                        sb.AppendFormat("ReportColumns[{0}].{1} = {2}\r\n", i, rcp.Name, rcp.GetValue(newvalue.ReportColumns[i], null));
                                    }
                                    break;
                                    }
                                }
                            }
                            else
                            {
                                // modified column
                                foreach (PropertyInfo rcp in rcinfo)
                                {
                                    switch (rcp.Name)
                                    {
                                    case "COLUMNFUNC":
                                    case "COLUMNTYPE":
                                    case "SelectStatement":
                                    {
                                        // skip these properties
                                    }
                                    break;

                                    default:
                                    {
                                        if (Convert.ToString(rcp.GetValue(newvalue.ReportColumns[i], null)) != Convert.ToString(rcp.GetValue(oldrc, null)))
                                        {
                                            sb.AppendFormat("ReportColumns[{0}].{1} = {2} -> {3}\r\n", i, rcp.Name, rcp.GetValue(oldrc, null), rcp.GetValue(newvalue.ReportColumns[i], null));
                                        }
                                    }
                                    break;
                                    }
                                }
                            }
                        }
                        #endregion Check for new and updated columns

                        #region Check for delete columns
                        int deletecounter = 0;
                        foreach (Model.REPORTCOLUMN item in oldvalue.ReportColumns)
                        {
                            if (newvalue.ReportColumns.Where(x => (x.COLUMNFUNC == item.COLUMNFUNC) &&
                                                             (x.COLUMNTYPE == item.COLUMNTYPE) &&
                                                             (x.DisplayName == item.DisplayName)).Count() == 0)
                            {
                                foreach (PropertyInfo rcp in rcinfo)
                                {
                                    switch (rcp.Name)
                                    {
                                    case "COLUMNFUNC":
                                    case "COLUMNTYPE":
                                    case "SelectStatement":
                                    {
                                        // skip these properties
                                    }
                                    break;

                                    default:
                                    {
                                        sb.AppendFormat("ReportColumns[deleted {0}].{1} = {2}\r\n", deletecounter, rcp.Name, rcp.GetValue(item, null));
                                    }
                                    break;
                                    }
                                }
                                deletecounter++;
                            }
                        }
                        #endregion
                    }
                    break;

                    case "WordFile":
                    {
                        if (newvalue.WordFile != null)
                        {
                            if (oldvalue.WordFile != null)
                            {
                                PropertyInfo[] wfinfo = typeof(Model.WORDFILE).GetProperties();
                                foreach (PropertyInfo wfp in wfinfo)
                                {
                                    if (Convert.ToString(wfp.GetValue(newvalue.WordFile, null)) != Convert.ToString(wfp.GetValue(oldvalue.WordFile, null)))
                                    {
                                        sb.AppendFormat("WordFile.{0} = {1} -> {2}\r\n", wfp.Name, wfp.GetValue(oldvalue.WordFile, null), wfp.GetValue(newvalue.WordFile, null));
                                    }
                                }
                            }
                            else
                            {
                                // new Wordfile entry
                                PropertyInfo[] wfinfo = typeof(Model.WORDFILE).GetProperties();
                                foreach (PropertyInfo wfp in wfinfo)
                                {
                                    sb.AppendFormat("WordFile.{0} = {1}\r\n", wfp.Name, wfp.GetValue(newvalue.WordFile, null));
                                }
                            }
                        }
                        else
                        {
                            if (oldvalue.WordFile != null)
                            {
                                sb.Append("WordFile = (removed)\r\n");
                            }
                        }
                    }
                    break;

                    default:
                    {
                        if (Convert.ToString(p.GetValue(newvalue, null)) != Convert.ToString(p.GetValue(oldvalue, null)))
                        {
                            sb.AppendFormat("{0} = {1} -> {2}\r\n", p.Name, p.GetValue(oldvalue, null), p.GetValue(newvalue, null));
                        }
                    }
                    break;
                    }
                }
            }

            result.MessageDetail = sb.ToString();

            return(result);
        }