示例#1
0
 public static bool 更新专家抽选记录(专家抽选记录 p, bool updateModifiedTime = true)
 {
     return Mongo.更新(p, updateModifiedTime);
 }
示例#2
0
 public ActionResult Part_Expert_ChooseApp(int? id)
 {
     专家抽选记录 model = new 专家抽选记录();
     try
     {
         model = 专家抽选管理.查找专家抽选记录((long)id);
         var str = "";
         foreach (var m in model.专家抽选条件)
         {
             str += m.需要专家数量 + ",";
         }
         ViewData["抽取总数列表"] = str.Substring(0, str.Length - 1);
     }
     catch
     {
         return Content("<script>alert('页面有误');location.href='javascript:history.go(-1)';</script>");
     }
     return PartialView("/Views/默认主题/后台/单位用户后台/Procure_Part/Part_Expert_ChooseApp.cshtml", model);
 }
示例#3
0
 public static bool 添加专家抽选历史(专家抽选记录 record)
 {
     return Mongo.添加(record);
 }
示例#4
0
        public ActionResult Expert_Scoring(专家抽选记录 record)
        {
            try
            {
                var parmstr = Request.Form["parmstr"];
                专家抽选记录 model = 专家抽选管理.查找专家抽选记录(record.Id);
                if (!string.IsNullOrWhiteSpace(parmstr) && !model.是否已评分 && model.抽选专家列表 != null)
                {
                    var scoretemplist = parmstr.Split(new[] { "|" }, StringSplitOptions.RemoveEmptyEntries);
                    var i = 0;
                    foreach (var m in model.抽选专家列表)
                    {
                        if (m.预定出席)
                        {
                            var scorelist = scoretemplist[i].Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);
                            m.专家评分.专家水平评分 = (专家水平评分)int.Parse(scorelist[0]);
                            m.专家评分.专家评标态度评分 = (专家评标态度评分)int.Parse(scorelist[1]);
                            i++;
                        }
                    }
                    model.是否已评分 = true;
                    专家抽选管理.更新专家抽选记录(model, false);
                }
            }
            catch
            {

            }
            return RedirectToAction("Expert_Applay_SApp");
        }
示例#5
0
 public ActionResult Part_Expert_ApplayCancelApp(int? id)
 {
     专家抽选记录 model = new 专家抽选记录();
     if (id != null)
     {
         model = 专家抽选管理.查找专家抽选记录((long)id);
     }
     return PartialView("/Views/默认主题/后台/单位用户后台/Procure_Part/Part_Expert_ApplayCancelApp.cshtml", model);
 }
示例#6
0
        public ActionResult Expert_ApplayAudit(专家抽选记录 record)
        {
            string action = Request.Form["action"];
            if (action == "审核通过")
            {
                专家抽选管理.批准专家抽选申请(record.Id, this.HttpContext.获取当前用户<单位用户>().Id, 申请抽选状态.已批准待抽选);
            }

            if (action == "审核不通过")
            {
                专家抽选管理.批准专家抽选申请(record.Id, this.HttpContext.获取当前用户<单位用户>().Id, 申请抽选状态.未获批准);
            }
            if (!string.IsNullOrWhiteSpace(Request.Form["have"]))
            {
                return View("/Views/默认主题/后台/单位用户后台/Expert_ApplayAuditListApp.cshtml");
            }
            return View("/Views/默认主题/后台/单位用户后台/Expert_ApplayAuditList.cshtml");
        }
示例#7
0
        public ActionResult Expert_Applay(int? id)
        {
            专家抽选记录 model = new 专家抽选记录
            {
                申请时间 = DateTime.Now,
                项目编号 = Request.Form["pro_num"],
                项目名称 = Request.Form["pro_name"],
                评标时间 = Convert.ToDateTime(Request.Form["pro_time"]),
                总计预定抽选专家数 = int.Parse(Request.Form["预定抽选总数"]),
                操作人姓名 = Request.Form["prooperate_name"],
                操作人电话 = Request.Form["prooperate_tel"]
            };
            model.经办人.用户ID = this.HttpContext.获取当前用户<单位用户>().Id;
            model.申请抽选状态 = 申请抽选状态.已提交待批准;

            //屏蔽列表
            var outlist = Request.Form["outlistcontent"];
            var l = new List<用户链接<专家>>();
            if (!string.IsNullOrWhiteSpace(outlist))
            {
                foreach (var item in outlist.Split(new[] { "|" }, StringSplitOptions.RemoveEmptyEntries))
                {
                    var z = new 用户链接<专家>
                    {
                        用户ID = long.Parse(item)
                    };
                    l.Add(z);
                }
            }
            model.回避专家列表 = l;

            int count = int.Parse(Request.Form["条件总数"]);
            var condition = new List<专家抽选记录._专家抽选条件>();
            for (int i = 1; i <= count; i++)
            {
                var t_condition = new 专家抽选记录._专家抽选条件();
                t_condition.需要专家数量 = int.Parse(Request.Form["预定抽选个数__" + i]);

                //专家类别
                var tempparmlist = Request.Form["专家类别__" + i];
                if (!string.IsNullOrWhiteSpace(tempparmlist))
                {
                    foreach (var temp in tempparmlist.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries))
                    {
                        t_condition.专家类别.Add((专家类别)(int.Parse(temp)));
                    }
                }

                //专家级别
                tempparmlist = Request.Form["专家级别__" + i];
                if (!string.IsNullOrWhiteSpace(tempparmlist))
                {
                    foreach (var temp in tempparmlist.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries))
                    {
                        t_condition.专家级别.Add((专家级别)(int.Parse(temp)));
                    }
                }

                //专家类型
                tempparmlist = Request.Form["专家类型__" + i];
                if (!string.IsNullOrWhiteSpace(tempparmlist))
                {
                    foreach (var temp in tempparmlist.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries))
                    {
                        t_condition.专家类型.Add((专家类型)(int.Parse(temp)));
                    }
                }
                //最高学历
                tempparmlist = Request.Form["最高学历__" + i];
                if (!string.IsNullOrWhiteSpace(tempparmlist))
                {
                    foreach (var temp in tempparmlist.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries))
                    {
                        t_condition.学历要求.Add((学历)(int.Parse(temp)));
                    }
                }
                //最高学位
                tempparmlist = Request.Form["最高学位__" + i];
                if (!string.IsNullOrWhiteSpace(tempparmlist))
                {
                    foreach (var temp in tempparmlist.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries))
                    {
                        t_condition.学位要求.Add((学位)(int.Parse(temp)));
                    }
                }
                //专业技术职称
                tempparmlist = Request.Form["专业技术职称__" + i];
                if (!string.IsNullOrWhiteSpace(tempparmlist))
                {
                    if (tempparmlist != "-100")
                    {
                        foreach (var temp in tempparmlist.Split(new[] { "|" }, StringSplitOptions.RemoveEmptyEntries))
                        {
                            t_condition.专业技术职称.Add((专业技术职称)(int.Parse(temp)));
                        }
                    }
                }

                //可评标物质类别匹配模式
                tempparmlist = Request.Form["可评标物质类别匹配模式__" + i];
                if (!string.IsNullOrWhiteSpace(tempparmlist) && tempparmlist == "1")
                {
                    t_condition.模糊查询 = Request.Form["可评标物质类别__" + i];
                }
                else
                {
                    //可评标物质类别
                    tempparmlist = Request.Form["可评标物质类别__" + i];
                    if (!string.IsNullOrWhiteSpace(tempparmlist))
                    {
                        var t = new 专家抽选记录._专家抽选条件._评标产品类别();
                        var 可评标物质类别 = tempparmlist.Split(new[] { "#" }, StringSplitOptions.RemoveEmptyEntries);
                        if (可评标物质类别[1] == "1")
                        {
                            t.二级分类可用专家不足返回一级分类 = true;
                        }
                        else
                        {
                            t.二级分类可用专家不足返回一级分类 = false;
                        }

                        var p = 可评标物质类别[0].Split(new[] { "*" }, StringSplitOptions.RemoveEmptyEntries);
                        t.一级分类 = p[0];
                        t.二级分类 = new List<string>();
                        for (var j = 1; j < p.Length; j++)
                        {
                            t.二级分类.Add(p[j]);
                        }

                        t_condition.可评标产品类别.Add(t);
                    }
                }

                //抽选描述
                t_condition.描述 = Request.Form["抽选描述__" + i];
                //所在地域
                t_condition.所在地区.省份 = Request.Form["省份__" + i];
                t_condition.所在地区.城市 = Request.Form["城市__" + i];
                t_condition.所在地区.区县 = Request.Form["区县__" + i];

                condition.Add(t_condition);
            }
            model.专家抽选条件 = condition;
            专家抽选管理.添加专家抽选历史(model);

            //站内消息
            站内消息 Msg = new 站内消息();
            对话消息 Talk = new 对话消息();

            Msg.重要程度 = 重要程度.特别重要;
            Msg.消息类型 = 消息类型.普通;
            var u_id = this.HttpContext.获取当前用户<单位用户>().Id;

            Msg.发起者.用户ID = u_id;
            Talk.发言人.用户ID = u_id;
            站内消息管理.添加站内消息(Msg, u_id, 10002);
            Talk.消息主体.标题 = "待审核抽取评审专家";
            Talk.消息主体.内容 = "有一条待审核的申请抽取评审专家未处理,<a style='color:red;text-decoration:underline;' href='/专家抽选/Expert_ApplayAuditList'>点击这里进行审核</a>";
            对话消息管理.添加对话消息(Talk, Msg);
            if (!string.IsNullOrWhiteSpace(Request.Form["hide"]))
            {
                return Redirect("/专家抽选/Expert_Applay_SApp");
            }
            return RedirectToAction("Expert_Applay_S");
        }
示例#8
0
 public ActionResult Part_Expert_ApplayCancel(int? id)
 {
     专家抽选记录 model = new 专家抽选记录();
     if (id != null)
     {
         model = 专家抽选管理.查找专家抽选记录((long)id);
     }
     return PartialView("Part_Expert/Part_Expert_ApplayCancel", model);
 }
示例#9
0
        public object Part_Expert_Choose()
        {
            var prs = HttpContext.Current.Request.Params;
            var tokenId = prs["tokenId"];

            //先检查是否登录有效
            var userId = 获取登录Id(tokenId);
            if (userId == -1) return null;

            专家抽选记录 model = new 专家抽选记录();
            var str = "";
            try
            {
                var id = long.Parse(prs["id"]);
                model = 专家抽选管理.查找专家抽选记录(id);
                foreach (var m in model.专家抽选条件)
                {
                    str += m.需要专家数量 + ",";
                }
                str = str.Substring(0, str.Length - 1);
            }
            catch
            {

            }
            return new {data = model, str = str};
        }
示例#10
0
        public object Part_Expert_ApplayAudit()
        {
            var prs = HttpContext.Current.Request.Params;
            var tokenId = prs["tokenId"];

            //先检查是否登录有效
            var userId = 获取登录Id(tokenId);
            if (userId == -1) return null;

            专家抽选记录 model = new 专家抽选记录();
            try
            {
                var id = long.Parse(prs["id"]);
                model = 专家抽选管理.查找专家抽选记录(id);
            }
            catch
            {

            }
            return new {data = model};
        }