重邮项目(发布公告)（中）

上次我们说完了视图的项目，这次我们来说说控制器的代码。控制器的代码会比较多，但效果都相似。发布公告的控制器分为五个部分。第一，发布公告管理页面功能。第二，公告类型基础信息维护以及公告类型明细的新增修改删除。第三，公告新增。第四，公告修改。第五，发布公告，文件处理。

删除公告以及公告详情都包含在发布公告管理页面功能中，公告明细也包含在其中

#region 1.发布公告管理页面功能
        /// <summary>
        /// 1.1 查询公告类型
        /// </summary>
        /// <returns></returns>
        public ActionResult SelectNoticeType()
        {
            var list = myModel.SYS_NoticeTypeTable.Select(m => new { id = m.NoticeTypeID, text = m.NoticeTypeName }).ToList();
            return Json(list, JsonRequestBehavior.AllowGet);
        }

        /// <summary>
        /// 1.2 查询公告信息
        /// </summary>
        /// <param name="layuiTablePage">layuitable分页参数</param>
        /// <param name="noticeName">公告名称</param>
        /// <param name="releaseTime">发布时间</param>
        /// <param name="noticeTypeId">公告类型ID</param>
        /// <returns></returns>
        public ActionResult SelectNoticeAll(LayuiTablePage layuiTablePage, string noticeName, string releaseTime, int noticeTypeId)
        {
            #region 数据查询操作
            var list = from tbNotices in myModel.PW_NoticeTable
                       join tbNoticeDetail in myModel.SYS_NoticeTypeDetail on tbNotices.NoticeTypeDetailID equals tbNoticeDetail.NoticeTypeDetailID
                       join tbNoticeType in myModel.SYS_NoticeTypeTable on tbNoticeDetail.NoticeTypeID equals tbNoticeType.NoticeTypeID
                       join tbTeacher in myModel.PW_Teacher on tbNotices.UserID equals tbTeacher.UserID
                       orderby tbNotices.NoticeID descending
                       select new NoticeVo
                       {
                           NoticeID = tbNotices.NoticeID,
                           NoticeName = tbNotices.NoticeName,
                           ReleaseTime = tbNotices.ReleaseTime,
                           NoticeContent = tbNotices.NoticeContent,
                           BrowsingTimes = tbNotices.BrowsingTimes,
                           Editor = tbTeacher.TeacherName,
                           NoticeTypeName = tbNoticeType.NoticeTypeName,
                           NoticeTypeID = tbNoticeType.NoticeTypeID,
                           NoticeTypeDetailName = tbNoticeDetail.NoticeTypeDetailName,
                           ReleaseTimeStr = tbNotices.ReleaseTime.ToString()
                       };
            #endregion
            #region 多条件拼接
            //公告名称不为空
            if (!string.IsNullOrEmpty(noticeName))
            {
                list = list.Where(p => p.NoticeName.Contains(noticeName.Trim()));
            }
            //发布时间不为空
            if (!string.IsNullOrEmpty(releaseTime))
            {
                //Convert.ToDateTime万能转换
                DateTime dtreleaseTime = Convert.ToDateTime(releaseTime);
                list = list.Where(p => p.ReleaseTime == dtreleaseTime);
            }
            //类型ID不为空
            if (noticeTypeId > 0)
            {
                list = list.Where(p => p.NoticeTypeID == noticeTypeId);
            }
            #endregion

            int intTotalRow = list.Count();//总行数
            List<NoticeVo> listNotices = list.Skip(layuiTablePage.GetStartIndex()).Take(layuiTablePage.limit).ToList();//分页
            LayuiTableData<NoticeVo> layuiTableData = new LayuiTableData<NoticeVo>
            {
                count = intTotalRow,
                data = listNotices
            };
            return Json(layuiTableData, JsonRequestBehavior.AllowGet);

        }

        /// <summary>
        /// 1.3 根据公告ID查询附件信息
        /// </summary>
        /// <param name="layuiTablePage">layuitable 分页</param>
        /// <param name="noticeId">公告ID</param>
        /// <returns></returns>
        public ActionResult SelectFileByNoticeId(LayuiTablePage layuiTablePage, int noticeId)
        {
            var linqItems = from tbFile in myModel.PW_File//附件表
                            join tbNoticeTable in myModel.PW_NoticeTable on tbFile.NoticeID equals tbNoticeTable.NoticeID//公告表
                            join tbFileType in myModel.SYS_FileType on tbFile.FileTypeID equals tbFileType.FileTypeID//文件类型表
                            where tbFile.NoticeID == noticeId
                            orderby tbFile.FileID
                            select new FilesVo
                            {
                                FileID = tbFile.FileID,//文件ID
                                Files = tbFile.Files,//文件
                                NoticeName = tbNoticeTable.NoticeName,//公告名称
                                FileTypeName = tbFileType.FileTypeName,//文件类型
                                FileTypeID = tbFileType.FileTypeID,
                                NoticeID = tbFile.NoticeID
                            };
            //总行数
            int intTotalRow = linqItems.Count();
            //查询数据
            List<FilesVo> listFile = linqItems.Skip(layuiTablePage.GetStartIndex()).Take(layuiTablePage.limit).ToList();//分页
            LayuiTableData<FilesVo> layuiTableData = new LayuiTableData<FilesVo>
            {
                count = intTotalRow,
                data = listFile
            };
            return Json(layuiTableData, JsonRequestBehavior.AllowGet);
        }
        /// <summary>
        /// 1.4 删除 公告信息
        /// </summary>
        /// <param name="noticeId">公告ID</param>
        /// <returns></returns>
        public ActionResult DeleteNotice(int noticeId) 
        {
            ReturnJson msg = new ReturnJson();
            try
            {
                PW_NoticeTable tbNotice = myModel.PW_NoticeTable.Where(m => m.NoticeID == noticeId).Single();
                myModel.PW_NoticeTable.Remove(tbNotice); //删除公告数据
                                                         //删除插图数据 公告内容字段存储的是公告文件.txt 的文件名称
                                                         //tbNotice.NoticeContent
                #region  删除插图数据(富文本框中的数据) 和公告内容
                string textFileName = Server.MapPath("~/Document/Notice/Text/") + tbNotice.NoticeContent;
                if (System.IO.File.Exists(textFileName)) {
                    //读取文件内容
                    string oldTextContent = System.IO.File.ReadAllText(textFileName);
                    //匹配出图片文件名称 -> 删除
                    MatchCollection oldMatchs = Regex.Matches(oldTextContent, "(?<=/Document/Notice/Image/).+?(?=\")");
                    foreach (Match match in oldMatchs) //通过遍历 删除  /Document/Notice/Image/ 目录下的文件
                    {
                        //match.Value
                        //需要删除的图片文件的路径
                        string dfilePath = Server.MapPath("~/Document/Notice/Image/") + match.Value;
                        try
                        {
                            if (System.IO.File.Exists(dfilePath))
                            {
                                System.IO.File.Delete(dfilePath);
                            }
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine(e);
                        }
                    }

                }
                //================>删除公告内容txt文件
                System.IO.File.Delete(textFileName);
                #endregion

                #region 删除附件数据 
                //查询附件信息
                List<PW_File> listFiles = myModel.PW_File.Where(m => m.NoticeID == noticeId).ToList();
                foreach (PW_File file in listFiles)//删除附件信息
                {
                    string filePath = "~/Document/Notice/Attachment/" + Regex.Match(file.Files, "(?<=fileName=).+?(?=\")").Value;
                    // 删除文件
                    string dfilePath = Server.MapPath(filePath);
                    try
                    {
                        if (System.IO.File.Exists(dfilePath))
                        {
                            System.IO.File.Delete(dfilePath);
                        }
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(e);
                    }
                }
                //===============>删除附件数据
                myModel.PW_File.RemoveRange(listFiles);
                #endregion
                #region 删除轮播的数据
                //能否获取原来的轮播(可能有, 可能没有)
                PW_NoticeCarousel tbNoticeCarousel = myModel.PW_NoticeCarousel.Where(m => m.NoticeID == noticeId).SingleOrDefault();
                if (tbNoticeCarousel != default(PW_NoticeCarousel))
                {
                    try
                    {
                        System.IO.File.Delete(Server.MapPath("~" + tbNoticeCarousel.NoticeCarousel));
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(e);
                    }
                    myModel.PW_NoticeCarousel.Remove(tbNoticeCarousel);//删除轮播图片
                }
                #endregion
                if (myModel.SaveChanges() > 0)
                {
                    msg.State = true;
                    msg.Text = "删除数据成功！";
                }
                else
                {
                    msg.Text = "删除失败!";
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                msg.Text = "数据异常！";
            }
            return Json(msg, JsonRequestBehavior.AllowGet);
        }

        /// <summary>
        ///  1.5 查看公告详情
        /// </summary>
        /// <param name="noticeId">公告ID</param>
        /// <returns></returns>
        public ActionResult NoticeDetailed(int? noticeId)
        {
            try
            {
                #region  通过公告ID查询公告信息
                //通过公告ID查询公告信息
                NoticeVo notice = (from tbNotice in myModel.PW_NoticeTable
                                   join tbNoticeTypeDetail in myModel.SYS_NoticeTypeDetail on tbNotice.NoticeTypeDetailID equals tbNoticeTypeDetail.NoticeTypeDetailID
                                   join tbNoticeType in myModel.SYS_NoticeTypeTable on tbNoticeTypeDetail.NoticeTypeID equals tbNoticeType.NoticeTypeID
                                   join tbTeacher in myModel.PW_Teacher on tbNotice.UserID equals tbTeacher.UserID
                                   where tbNotice.NoticeID == noticeId
                                   select new NoticeVo
                                   {
                                       NoticeName = tbNotice.NoticeName,
                                       ReleaseTime = tbNotice.ReleaseTime,
                                       schoolRelated = tbNotice.schoolRelated,
                                       NoticeContent = tbNotice.NoticeContent,
                                       Editor = tbTeacher.TeacherName,
                                       NoticeTypeName = tbNoticeType.NoticeTypeName,
                                       NoticeTypeDetailName = tbNoticeTypeDetail.NoticeTypeDetailName,
                                       ReleaseTimeStr = tbNotice.ReleaseTime.ToString()
                                   }).Single();
                #endregion

                //读取公告内容
                #region 读取公告内容
                string textFileName = Server.MapPath("~/Document/Notice/Text/") + notice.NoticeContent;
                if (System.IO.File.Exists(textFileName))
                {
                    //文件存在
                    notice.NoticeContent = System.IO.File.ReadAllText(textFileName);
                }
                else
                {
                    //文件不存在
                    notice.NoticeContent = "<p>没有找到公告内容,可能文件已经丢失;请重新编辑发布</p>";
                }
                #endregion

                #region 查询附件列表
                //查询附件列表
                List<FilesVo> files = (from tbFile in myModel.PW_File
                                       join tbNoticeTable in myModel.PW_NoticeTable on tbFile.NoticeID equals tbNoticeTable.NoticeID
                                       join tbFileType in myModel.SYS_FileType on tbFile.FileTypeID equals tbFileType.FileTypeID
                                       where tbFile.NoticeID == noticeId
                                       select new FilesVo
                                       {
                                           FileID = tbFile.FileID,
                                           FileTypeID = tbFile.FileTypeID,
                                           Files = tbFile.Files,
                                           FileTypeName = tbFileType.FileTypeName,
                                           FileName = tbFile.Files
                                       }).ToList();
                #endregion

                //记录数据
                ViewBag.notice = notice;//显示的公告一条数据
                ViewBag.files = files;//公告对应的附件列表
            }
            catch (Exception)
            {
                //重定向到登录视图
                return Redirect("/Main/Login");
            }
            return View();
        }
        #endregion

第一部分“发布公告管理页面功能”包含的数据比较多，除了公告删除，公告详情以外，都是查询。代码量多是因为需要对数据库中的图片进行处理，也需要对项目中的文件进行处理。

#region 2.公告类型基础信息维护 ->公告类型增删改查-> 公告类型明细增删改查
        /// <summary>
        ///  2.0公告类型数据维护 公告类型明细数据维护
        /// </summary>
        /// <returns></returns>
        public ActionResult BaseInfor()//基础信息维护
        {
            return View();
        }
        /// <summary>
        ///  2.1 查询全部公告类型数据
        /// </summary>
        /// <param name="layuiTablePage"></param>
        /// <returns></returns>
        public ActionResult SelectNoticeTypeAll(LayuiTablePage layuiTablePage)
        {
            //查询公告类型
            var listNoticeType = myModel.SYS_NoticeTypeTable.ToList();
            //分页总条数
            int count = listNoticeType.Count();
            //查询分页数据
            listNoticeType = listNoticeType.OrderByDescending(m => m.NoticeTypeID)
               .Skip(layuiTablePage.GetStartIndex()).Take(layuiTablePage.limit).ToList();
            //返回列表
            LayuiTableData<SYS_NoticeTypeTable> layuiTableData = new LayuiTableData<SYS_NoticeTypeTable>();
            layuiTableData.count = count;
            layuiTableData.data = listNoticeType;
            return Json(layuiTableData, JsonRequestBehavior.AllowGet);
        }
        /// <summary>
        /// 2.2根据公告类型ID查询公告明细数据
        /// </summary>
        /// <param name="layuiTablePage">分页</param>
        /// <param name="noticeTypeId">公告类型ID</param>
        /// <returns></returns>
        public ActionResult SelectNoticeTypeDetailByNoticeTypeID(LayuiTablePage layuiTablePage, int noticeTypeId)
        {
            var listNoticeTypeDetail = (from tbNoticeTypeDetail in myModel.SYS_NoticeTypeDetail
                                        orderby tbNoticeTypeDetail.NoticeTypeDetailID descending
                                        where tbNoticeTypeDetail.NoticeTypeID == noticeTypeId
                                        select tbNoticeTypeDetail);
            //分页操作
            List<SYS_NoticeTypeDetail> listnNoticeTypeData =
                listNoticeTypeDetail.Skip(layuiTablePage.GetStartIndex())
                .Take(layuiTablePage.limit).ToList();

            //返回列表
            LayuiTableData<SYS_NoticeTypeDetail> layuiTableData = new LayuiTableData<SYS_NoticeTypeDetail>();
            layuiTableData.count = listNoticeTypeDetail.Count();
            layuiTableData.data = listnNoticeTypeData;
            return Json(layuiTableData, JsonRequestBehavior.AllowGet);
        }
        /// <summary>
        /// 2.3 新增公告类型
        /// </summary>
        /// <param name="modNoticeType">公告类型</param>
        /// <returns></returns>
        public ActionResult InsertNoticeType(SYS_NoticeTypeTable modNoticeType)
        {
            //实例化
            ReturnJson msg = new ReturnJson();
            try
            {
                if (!string.IsNullOrEmpty(modNoticeType.NoticeTypeName))
                {
                    //1.0：查询重复
                    //根据公告名称查询是否已经存在
                    int oldCount = (from tbNoticeType in myModel.SYS_NoticeTypeTable
                                    where tbNoticeType.NoticeTypeName == modNoticeType.NoticeTypeName.Trim()
                                    select tbNoticeType).Count();
                    if (oldCount == 0)//公告类型不存在
                    {
                        myModel.SYS_NoticeTypeTable.Add(modNoticeType);
                        if (myModel.SaveChanges() > 0)
                        {
                            msg.State = true;
                            msg.Text = "保存成功！";
                        }
                        else
                        {
                            msg.Text = "保存失败！";
                        }
                    }
                    else
                    {
                        msg.Text = "已经存在！";
                    }
                }
                else
                {
                    msg.Text = "数据不完整！";
                }
            }
            catch (Exception)
            {
                msg.Text = "数据异常！";
            }
            return Json(msg, JsonRequestBehavior.AllowGet);
        }
        /// <summary>
        /// 2.4 根据公告类型ID查询公告信息
        /// </summary>
        /// <param name="noticeTypeId">公告类型ID</param>
        /// <returns></returns>
        public ActionResult SelectNoticeTypeById(int noticeTypeId)
        {
            try
            {
                SYS_NoticeTypeTable noticeType = (from tbNoticeType in myModel.SYS_NoticeTypeTable
                                                  where tbNoticeType.NoticeTypeID == noticeTypeId
                                                  select tbNoticeType).Single();
                return Json(noticeType, JsonRequestBehavior.AllowGet);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                return Json(null, JsonRequestBehavior.AllowGet);
            }
        }
        /// <summary>
        /// 2.5 修改公告信息
        /// </summary>
        /// <param name="sysNoticeType"></param>
        /// <returns></returns>
        public ActionResult UpdateNoticeType(SYS_NoticeTypeTable sysNoticeType)
        {
            ReturnJson msg = new ReturnJson();
            if (!string.IsNullOrEmpty(sysNoticeType.NoticeTypeName))
            {
                try
                {
                    //查询除了自身外 公告类型名称查询是否已经存在
                    int oldCount = (from tbNoticeType in myModel.SYS_NoticeTypeTable
                                    where tbNoticeType.NoticeTypeID != sysNoticeType.NoticeTypeID
                                    && tbNoticeType.NoticeTypeName == sysNoticeType.NoticeTypeName.Trim()
                                    select tbNoticeType).Count();
                    if (oldCount == 0)
                    {
                        //修改公告类型
                        myModel.Entry(sysNoticeType).State = System.Data.Entity.EntityState.Modified;
                        if (myModel.SaveChanges() > 0)
                        {
                            msg.State = true;
                            msg.Text = "保存成功！";
                        }
                        else
                        {
                            msg.Text = "修改失败！";
                        }
                    }
                    else
                    {
                        msg.Text = "公告类型已经存在！";
                    }
                }
                catch (Exception)
                {
                    msg.Text = "数据异常！";
                }
            }
            else
            {
                msg.Text = "请填写完整！";
            }
            return Json(msg, JsonRequestBehavior.AllowGet);
        }
        /// <summary>
        /// 2.6 根据公告类型ID 删除公告信息
        /// </summary>
        /// <param name="noticeTypeId">公告类型ID</param>
        /// <returns></returns>
        public ActionResult DeleteNoticeType(int noticeTypeId)
        {
            ReturnJson msg = new ReturnJson();
            try
            {
                //查询公告类型 是否有公告类型明细
                int noticeTypeDetailCount = (from tbNoticeTypeDetails in myModel.SYS_NoticeTypeDetail
                                             where tbNoticeTypeDetails.NoticeTypeID == noticeTypeId
                                             select tbNoticeTypeDetails).Count();
                if (noticeTypeDetailCount == 0) //没有
                {
                    //查询出公告类型
                    SYS_NoticeTypeTable dbNoticeType = (from tbNoticeType in myModel.SYS_NoticeTypeTable
                                                        where tbNoticeType.NoticeTypeID == noticeTypeId
                                                        select tbNoticeType).Single();
                    myModel.SYS_NoticeTypeTable.Remove(dbNoticeType);//删除
                    if (myModel.SaveChanges() > 0)
                    {
                        msg.State = true;
                        msg.Text = "删除成功！";
                    }
                    else
                    {
                        msg.Text = "删除失败！";
                    }
                }
                else
                {
                    msg.Text = "有明细信息，不能删除！";
                }
            }
            catch (Exception)
            {
                msg.Text = "数据异常";
            }
            return Json(msg, JsonRequestBehavior.AllowGet);
        }
        /// <summary>
        /// 2.7 新增公告类型明细
        /// </summary>
        /// <param name="sysNoticeTypeDetail"></param>
        /// <returns></returns>
        public ActionResult InsertNoticeDetailType(SYS_NoticeTypeDetail sysNoticeTypeDetail)
        {
            ReturnJson msg = new ReturnJson();
            msg.State = false;
            try
            {
                //公告类型明细名称不能为空
                if (!string.IsNullOrEmpty(sysNoticeTypeDetail.NoticeTypeDetailName))
                {
                    //查询在同一公告类型下是否已经存在公告类型明细
                    int oldCount = (from tbNoticeTypeDetail in myModel.SYS_NoticeTypeDetail
                                    where
                                    tbNoticeTypeDetail.NoticeTypeID == sysNoticeTypeDetail.NoticeTypeID &&
                                    tbNoticeTypeDetail.NoticeTypeDetailName == sysNoticeTypeDetail.NoticeTypeDetailName.Trim()
                                    select tbNoticeTypeDetail).Count();
                    if (oldCount == 0)
                    {
                        //新增公告类型明细
                        myModel.SYS_NoticeTypeDetail.Add(sysNoticeTypeDetail);
                        if (myModel.SaveChanges() > 0)
                        {
                            msg.State = true;
                            msg.Text = "新增成功！";
                        }
                        else
                        {
                            msg.Text = "新增失败！";
                        }
                    }
                    else
                    {
                        msg.Text = "该公告类型明细已经存在！";
                    }
                }
                else
                {
                    msg.Text = "数据不完整！";
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                msg.Text = "数据异常！";
            }
            return Json(msg, JsonRequestBehavior.AllowGet);
        }
        /// <summary>
        /// 2.8 根据公告类型明细ID查询数据 修改数据回填
        /// </summary>
        /// <param name="noticeTypeDetailId">公告类型明细ID</param>
        /// <returns></returns>
        public ActionResult SelectNoticeTypeDetailByID(int noticeTypeDetailId)
        {
            try
            {
                SYS_NoticeTypeDetail noticeTypeDetail = (from tbNoticeTypeDetail in myModel.SYS_NoticeTypeDetail
                                                         where tbNoticeTypeDetail.NoticeTypeDetailID == noticeTypeDetailId
                                                         select tbNoticeTypeDetail).Single();
                return Json(noticeTypeDetail, JsonRequestBehavior.AllowGet);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                return Json(null, JsonRequestBehavior.AllowGet);
            }
        }
        /// <summary>
        /// 2.9 修改公告类型明细
        /// </summary>
        /// <param name="sysNoticeTypeDetail"></param>
        /// <returns></returns>
        public ActionResult UpdateNoticeTypeDetail(SYS_NoticeTypeDetail sysNoticeTypeDetail)
        {
            ReturnJson msg = new ReturnJson();
            msg.State = false;
            try
            {
                //判断公告类型明细名称是否为空
                if (!string.IsNullOrEmpty(sysNoticeTypeDetail.NoticeTypeDetailName))
                {
                    //查询同一公告类型下是除自身外否已经存在该公告类型明细名称
                    int oldCount = (from tbNoticeTypeDetail in myModel.SYS_NoticeTypeDetail
                                    where tbNoticeTypeDetail.NoticeTypeDetailID != sysNoticeTypeDetail.NoticeTypeDetailID
                                          && tbNoticeTypeDetail.NoticeTypeID == sysNoticeTypeDetail.NoticeTypeID
                                          && tbNoticeTypeDetail.NoticeTypeDetailName == sysNoticeTypeDetail.NoticeTypeDetailName
                                    select tbNoticeTypeDetail).Count();
                    if (oldCount == 0)
                    {
                        //修改
                        myModel.Entry(sysNoticeTypeDetail).State = System.Data.Entity.EntityState.Modified;
                        if (myModel.SaveChanges() > 0)
                        {
                            msg.State = true;
                            msg.Text = "修改成功！";
                        }
                        else
                        {
                            msg.Text = "修改失败！";
                        }
                    }
                    else
                    {
                        msg.Text = "已经存在！";
                    }
                }
                else
                {
                    msg.Text = "数据不完整！";
                }
            }
            catch (Exception)
            {
                msg.Text = "数据异常！";
            }
            return Json(msg, JsonRequestBehavior.AllowGet);
        }
        /// <summary>
        /// 2.10 修改公告类型明细
        /// </summary>
        /// <param name="noticeTypeDetailId">公告类型明细ID</param>
        /// <returns></returns>
        public ActionResult DeleteNoticeTypeDetail(int noticeTypeDetailId)
        {
            ReturnJson msg = new ReturnJson();
            msg.State = false;
            try
            {
                //根据ID查询出公告类别明细
                SYS_NoticeTypeDetail dbNoticeTypeDetail = myModel.SYS_NoticeTypeDetail.Where(m => m.NoticeTypeDetailID == noticeTypeDetailId).Single();
                myModel.SYS_NoticeTypeDetail.Remove(dbNoticeTypeDetail);
                if (myModel.SaveChanges() > 0)
                {
                    msg.State = true;
                    msg.Text = "删除成功！";
                }
                else
                {
                    msg.Text = "删除失败！";
                }
            }
            catch (Exception)
            {
                msg.Text = "数据异常！";
            }

            return Json(msg, JsonRequestBehavior.AllowGet);
        }
        #endregion

第二部分是“公告类型基础信息维护，以及公告类型明细的新增修改删除”，包含了公告明细的新增修改删除。

#region 3.公告新增
        /// <summary>
        /// 3.1新增发布公告视图
        /// </summary>
        /// <returns></returns>
        public ActionResult InsertNotice()
        {
            //检查用户是否登录，没有登录跳转到登录页面
            if (Session["UserID"] == null)
            {
                //重定向到登录       
                return Redirect("/Main/Login");
            }
            Session.Remove("sessionFiles");//清空session
            return View();
        }
        /// <summary>
        /// 3.2 根据公告类型ID查询公告类型明细
        /// </summary>
        /// <param name="NoticeTypeID">公告类型ID</param>
        /// <returns></returns>
        public ActionResult SelectNoticeDetailByID(int NoticeTypeID)
        {
            var list = myModel.SYS_NoticeTypeDetail.Where(m => m.NoticeTypeID == NoticeTypeID).Select(m => new { id = m.NoticeTypeDetailID, text = m.NoticeTypeDetailName }).ToList();
            return Json(list, JsonRequestBehavior.AllowGet);
        }
        /// <summary>
        /// 3.3 新增公告信息
        /// </summary>
        /// <param name="pwNotice">公告信息</param>
        /// <param name="noticeCarouseImage">公告轮播图</param>
        /// <param name="noticeCarousel">是否进行轮播</param>
        /// <returns></returns>
        [ValidateInput(false)]//由于要存入HTML，关闭验证
        /*[ValidateInput(false)]取消危险字符的验证 如 “<> %$#”等等 。
          为了安全起见，正常的Post提交是不允许提交诸如<>$/等敏感字符的（有点类似脚本注入），
         * 如果你有必要提交这些东西的话，就需要加上ValidateInput标签，比如富文本编辑的时候*/
        public ActionResult InsertNoticeInfor(PW_NoticeTable pwNotice, HttpPostedFileBase noticeCarouseImage, string noticeCarousel)
        {
            ReturnJson msg = new ReturnJson();
            try
            {
                #region 1.0 从session中获取UserID与UserType
                int UserID = Convert.ToInt32(Session["UserID"].ToString());
                //获得usertypeID
                int UserTypeID = Convert.ToInt32(Session["UserTypeID"].ToString());
                List<string> savedImageList = new List<string>();//图片列表
                #endregion
                #region 1.1文件夹处理 轮播图片 富文本框图片 附件文件 
                //检查 存放公告内容的 目录是否存在,不存在就创建
                if (!Directory.Exists(Server.MapPath("~/Document/Notice/Text/")))
                {
                    Directory.CreateDirectory(Server.MapPath("~/Document/Notice/Text/"));
                }
                //检查 存放轮播图片的 目录是否存在,不存在就创建
                if (!Directory.Exists(Server.MapPath("~/Document/Notice/NoticeCarousel/")))
                {
                    Directory.CreateDirectory(Server.MapPath("~/Document/Notice/NoticeCarousel/"));
                }
                //检查 存放附件 目录是否存在,不存在就创建
                if (!Directory.Exists(Server.MapPath("~/Document/Notice/Attachment/")))
                {
                    Directory.CreateDirectory(Server.MapPath("~/Document/Notice/Attachment/"));
                }
                //检查 存放正文内容图片的 目录是否存在,不存在就创建
                if (!Directory.Exists(Server.MapPath("~/Document/Notice/Image/")))
                {
                    Directory.CreateDirectory(Server.MapPath("~/Document/Notice/Image/"));
                }
                #endregion
                #region 1.2 保存公告内容 用.txt文件来保存公告内容
                //txt文件名称
                string fileName = DateTime.Now.ToString("yyyy-MM-dd") + "-" + Guid.NewGuid() + ".txt";
                //txt文件路径
                string filePath = Server.MapPath("~/Document/Notice/Text/") + fileName;
                //txt文件内容
                string textContent = pwNotice.NoticeContent;
                //txtimg 匹配出图片文件名称 移动
                MatchCollection oldMatchs = Regex.Matches(textContent, "(?<=/Document/Temp/).+?(?=\".+?/>)");
                foreach (Match match in oldMatchs) {
                    // 移动文件
                    string oldImgPath = Server.MapPath("~/Document/Temp/") + match.Value;
                    string newPath = Server.MapPath("~/Document/Notice/Image/") + match.Value;
                    try
                    {
                        //移动
                        System.IO.File.Move(oldImgPath, newPath);
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(e);
                    }
                }
                //替换所有图片路径
                textContent = textContent.Replace("/Document/Temp/", "/Document/Notice/Image/");
                //保存文件 txt文件
                TextWriter textWriter = new StreamWriter(filePath, false, new System.Text.UTF8Encoding(false));
                textWriter.Write(textContent);
                textWriter.Close();
                #endregion
                #region 1.3 保存公告信息
                //保存公告信息
                //保存公告信息
                pwNotice.UserID = UserID;//用户ID
                pwNotice.NoticeContent = fileName;//公告内容
                pwNotice.AcademeID = 1;//学院id
                pwNotice.schoolRelated = true;//是否学校相关
                pwNotice.ReleaseTime = DateTime.Now;//发布时间
                pwNotice.BrowsingTimes = 0;//浏览次数
                if (pwNotice.Overhead == null)//是否置顶 没有勾选
                {
                    pwNotice.Overhead = false;
                }
                //根据登录的userId获取学院id
                SYS_Academe academe = (from tbAcademe in myModel.SYS_Academe
                                       join tbTeacher in myModel.PW_Teacher on tbAcademe.AcademeID equals tbTeacher.AcademeID
                                       where tbTeacher.UserID == UserID
                                       select tbAcademe).SingleOrDefault();
                //C#中的关键词default函数，其作用是default(T)返回一个该类型T的默认值，一般情况下用于在不知道类型参数具体为值类型还是引用类型的情况
                if (academe != default(SYS_Academe))//null  
                {
                    pwNotice.AcademeID = academe.AcademeID;
                }
                //获取用户类型 判断是否学校相关
                SYS_UserType userType = (from tbUserType in myModel.SYS_UserType
                                         where tbUserType.UserTypeID == UserTypeID
                                         select tbUserType).SingleOrDefault();
                if (userType != default(SYS_UserType))
                {
                    if (userType.UserType == "超级管理员" || userType.UserType == "系统管理员" || userType.UserType == "试题管理员" || userType.UserType == "试卷管理员" || userType.UserType == "考试管理员")
                    {
                        pwNotice.schoolRelated = true;
                    }
                    else
                    {
                        pwNotice.schoolRelated = false;
                    }
                }
                //保存数据
                myModel.PW_NoticeTable.Add(pwNotice);
                #endregion
                #region 1.4 处理附件信息 公告轮播图
                if (myModel.SaveChanges() > 0)
                {
                    #region 1.5 处理附件文件
                    int intNoticeId = pwNotice.NoticeID;
                    //--->（二）保存附件文件
                    //获取session中的文件表
                    List<FilesVo> sessionFiles = new List<FilesVo>();
                    if (Session["sessionFiles"] != null)
                    {
                        sessionFiles = Session["sessionFiles"] as List<FilesVo>;
                    }
                    //有上传的附件
                    if (sessionFiles != null && sessionFiles.Count > 0)
                    {
                        List<PW_File> listfFiles = new List<PW_File>();
                        for (int i = 0; i < sessionFiles.Count; i++)
                        {
                            PW_File file = new PW_File();
                            file.FileTypeID = sessionFiles[i].FileTypeID;
                            file.NoticeID = intNoticeId;
                            file.Files = sessionFiles[i].Files.Replace("DownloadAttachment", "DownloadAttachment2");
                            listfFiles.Add(file);
                            //移动附件
                            string strAttachmentFileName = sessionFiles[i].FileName;
                            //上传附件的临时文件夹
                            string strAttachmentOldPath = Server.MapPath("~/Document/Temp/") + strAttachmentFileName;
                            //附件最终保存的路径
                            string strstrAttachmentNewPath = Server.MapPath("~/Document/Notice/Attachment/") + strAttachmentFileName;
                            // 将临时文件夹里面的附件 移动  
                            try
                            {
                                System.IO.File.Move(strAttachmentOldPath, strstrAttachmentNewPath);
                            }
                            catch (Exception e)
                            {
                                Console.WriteLine(e);
                            }
                        }
                        //附件的批量保存
                        myModel.PW_File.AddRange(listfFiles);
                        myModel.SaveChanges();
                    }
                    #endregion

                    #region 1.6 处理轮播图片
                    if (noticeCarousel != null && noticeCarousel == "true" && noticeCarouseImage != null && noticeCarouseImage.ContentLength > 0)
                    {
                        //noticeCarouseImage
                        //文件类型
                        string imgExtension = Path.GetExtension(noticeCarouseImage.FileName);
                        //文件名称  ToUniversalTime：协调世界时,又称世界统一时间、世界标准时间、国际协调时间
                        //2021-09-07
                        string imgFileName = DateTime.Now.ToUniversalTime().ToString("yyyy-MM-dd") + "-" + Guid.NewGuid() + imgExtension;
                        //保存文件的路径
                        string imgFilePath = Server.MapPath("~/Document/Notice/NoticeCarousel/") + imgFileName;
                        //保存文件
                        noticeCarouseImage.SaveAs(imgFilePath);

                        PW_NoticeCarousel pwNoticeCarousel = new PW_NoticeCarousel();
                        pwNoticeCarousel.NoticeID = intNoticeId;
                        pwNoticeCarousel.NoticeCarousel = "/Document/Notice/NoticeCarousel/" + imgFileName;
                        myModel.PW_NoticeCarousel.Add(pwNoticeCarousel);
                        myModel.SaveChanges();
                    }
                    #endregion

                    msg.State = true;
                    msg.Text = "新增成功！";
                    Session.Remove("sessionFiles");
                }
                #endregion
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                msg.Text = "数据异常！";
            }
            return Json(msg, JsonRequestBehavior.AllowGet);
        }
        #endregion

第三部分虽然只有一个新增公告信息。但是新增公告信息中包含了，字体，图片，附件等数据，所以代码量不必前两个部分少，主要在于图片比较难以处理。只能将图片转换为二进制数组，再将二进制数组转换成内存流，存入项目中的文件夹中。同时还需要判断文件夹是否存在，不存在则需要使用代码创建一个新的文件夹。