示例#1
0
 public _审核数据()
 {
     审核状态 = 审核状态.未审核;
     审核者 = new 用户链接<用户基本数据>();
     审核时间 = DateTime.MinValue;
     未通过审批物资列表 = new List<需求计划物资链接>();
 }
示例#2
0
 public 项目服务记录()
 {
     供应商链接 = new 用户链接<供应商>();
     验收单位链接 = new 用户链接<单位用户>();
     所属项目 = new 招标采购项目链接();
     服务信息 = new _服务信息();
     服务评价 = new _服务评价();
 }
示例#3
0
 public 机票验收单()
 {
     var d = DateTime.Now;
     验收单号 = string.Format("{0:D4}{1:D3}{2:D6}", d.Year, d.DayOfYear, Mongo.NextId<验收单>(d.Year.ToString("D:4")));
     Id = long.Parse(验收单号);
     供应商链接 = new 用户链接<供应商>();
     服务列表 = new List<_机票服务条目>();
     打印信息 = new List<_打印信息>();
 }
示例#4
0
 public 需求计划()
 {
     当前处理单位链接 = new 用户链接<单位用户>();
     审批流程单位列表 = new List<用户链接<单位用户>>();
     需求发起单位链接 = new 用户链接<单位用户>();
     并入需求计划链接 = new 需求计划链接();
     来源需求计划列表 = new List<需求计划链接>();
     物资列表 = new List<需求计划物资链接>();
     分发列表 = new List<需求计划分发链接>();
     审核历史列表 = new List<_审核数据>();
 }
示例#5
0
 public 招标采购项目()
 {
     需求提报单位 = new 用户链接<单位用户>();
     需求申请来源 = new 需求申请链接();
     项目管理单位 = new 用户链接<单位用户>();
     审核数据 = new _审核数据();
     技术公告链接 = new 公告链接();
     招标公告链接 = new 公告链接();
     中标公告链接 = new 公告链接();
     废标公告链接 = new 公告链接();
     流标公告链接 = new 公告链接();
     修正公告链接 = new List<公告链接>();
     中标结果 = new List<_中标结果>();
 }
示例#6
0
 public 验收单()
 {
     var d = DateTime.Now;
     验收单号 = string.Format("{0:D4}{1:D3}{2:D6}", d.Year, d.DayOfYear, Mongo.NextId<验收单>(d.Year.ToString("D:4")));
     Id = long.Parse(验收单号);
     供应商链接 = new 用户链接<供应商>();
     管理单位审核人 = new 用户链接<单位用户>();
     物资服务列表 = new List<_物资或服务条目>();
     审核数据 = new _审核数据();
     验收单附件 = new List<_验收单附件>();
     其他费用 = new List<_其他费用>();
     打印信息 = new List<_打印信息>();
     验收单扫描件 = new List<_回传信息>();
 }
 public _专家抽选条目() { this.专家 = new 用户链接<专家>(); this.专家评分 = new 专家评分(); }
示例#8
0
 public _推荐审核数据() { this.审核者 = new 用户链接<用户基本数据>(); }
示例#9
0
 public _审核数据() { this.审核者 = new 用户链接<运营团队>(); }
示例#10
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");
        }
 public ActionResult Task_addChecker(需求采购任务 m)//提交道审核单位
 {
     try
     {
         string strid = Request.Form["uid"];
         string topuser = Request.Form["topuser"];
         需求采购任务 model = 需求采购任务管理.查找需求采购任务(m.Id);
         model.联系电话 = m.联系电话;
         model.联系人 = m.联系人;
         model.建议完成时间 = m.建议完成时间;
         model.受理单位.用户ID = m.受理单位.用户ID;
         model.采购方式 = m.采购方式;
         List<用户链接<单位用户>> ulist = new List<用户链接<单位用户>>();
         if (model.审核历史列表.Any() && model.审核历史列表.Last().审核状态 == 审核状态.审核未通过)
         {
             model.审核历史列表 = new List<需求计划._审核数据>();
         }
         if (!string.IsNullOrWhiteSpace(strid))
         {
             for (int i = 0; i < strid.Split(',').Length - 1; i++)
             {
                 用户链接<单位用户> a = new 用户链接<单位用户>();
                 a.用户ID = long.Parse(strid.Split(',')[i]);
                 ulist.Add(a);
             }
             if (!string.IsNullOrWhiteSpace(topuser) && topuser != "-1")
             {
                 用户链接<单位用户> a = new 用户链接<单位用户>();
                 a.用户ID = long.Parse(topuser);
                 ulist.Add(a);
             }
             model.审批流程单位列表 = ulist;
             model.当前处理单位链接.用户ID = ulist.First().用户ID;
             需求采购任务管理.更新需求采购任务(model);
             return Redirect("/单位用户后台/AssignmentTaskAuditList");
         }
         else
         {
             return Content("<script>alert('请选择审核单位!');window.location='/单位用户后台/demandlist?page=1';</script>");
         }
     }
     catch
     {
         return Redirect("/单位用户后台/Demandlist?page=1");
     }
 }
示例#12
0
 public 网上竞标()
 {
     报价供应商列表 = new List<_报价供应商>();
     中标供应商链接 = new 用户链接<供应商>();
 }
示例#13
0
 public _内容基本信息() { this.重要程度 = 0; this.允许评论 = false; this.所有者 = new 用户链接<用户基本数据>(); }
示例#14
0
 public 需求采购任务()
 {
     this.受理单位 = new 用户链接<单位用户>();
 }
示例#15
0
 public _供应商抽选条目() { this.供应商 = new 用户链接<供应商>(); }
示例#16
0
 public 用户组()
 {
     权限列表 = new List<string>();
     所属单位 = new 用户链接<单位用户>();
 }
示例#17
0
 public 操作数据() { this.操作人员 = new 用户链接<用户基本数据>(); }
示例#18
0
        public ActionResult GysChoose_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))
                {
                    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];
                //所在地域
                var place = new _地域
                {
                    省份 = Request.Form["省份__" + i],
                    城市 = Request.Form["城市__" + i],
                    区县 = Request.Form["区县__" + i]
                };

                t_condition.所在地区.Add(place);

                condition.Add(t_condition);
            }
            model.供应商抽选条件 = condition;
            供应商抽选管理.添加供应商抽选历史(model);
            if (!string.IsNullOrWhiteSpace(Request.Form["app"]))
            {
                return RedirectToAction("GysChoose_Applay_SApp");
            }
            return RedirectToAction("GysChoose_Applay_S");
        }
示例#19
0
        private void btn_commit_Click(object sender, EventArgs e)
        {
            #region 验证填写信息是否完善
            if (string.IsNullOrWhiteSpace(text_project_name.Text))
            {
                MessageBox.Show("请填写项目名称!");
                text_project_name.Focus();
                return;
            }
            if (string.IsNullOrWhiteSpace(text_project_number.Text))
            {
                MessageBox.Show("请填写项目编号!");
                text_project_number.Focus();
                return;
            }
            if (string.IsNullOrWhiteSpace(date_bid_time.Text))
            {
                MessageBox.Show("请填写评标时间!");
                date_bid_time.Focus();
                return;
            }

            Regex reg = new Regex(@"^[0-9]\d*$");
            if (string.IsNullOrWhiteSpace(text_totalnum_extract.Text))
            {
                MessageBox.Show("预定抽选个数必须填写!");
                text_totalnum_extract.Focus();
                return;
            }
            else if (!reg.IsMatch(text_totalnum_extract.Text))
            {
                MessageBox.Show("请输入正确的抽选个数!");
                text_totalnum_extract.Focus();
                return;
            }
            else if (text_totalnum_extract.Text == "0")
            {
                MessageBox.Show("预定抽选个数必须大于0!");
                text_totalnum_extract.Focus();
                return;
            }
            if (string.IsNullOrWhiteSpace(text_operator_name.Text))
            {
                MessageBox.Show("请填写操作人姓名!");
                text_operator_name.Focus();
                return;
            }
            if (string.IsNullOrWhiteSpace(text_operator_tel.Text))
            {
                MessageBox.Show("请填写操作人电话!");
                text_operator_tel.Focus();
                return;
            }
            if (dtg_condition_confirm.RowCount <= 0)
            {
                MessageBox.Show("请至少选择一个条件后再提交!");
                return;
            }

            var row_count = dtg_condition_confirm.RowCount;
            var temp_count = 0;
            for (int i = 0; i < row_count; i++)
            {
                var d = int.Parse(dtg_condition_confirm.Rows[i].Cells[2].Value.ToString());
                temp_count += d;
            }
            if (int.Parse(text_totalnum_extract.Text) != temp_count)
            {
                MessageBox.Show("各条件抽取个数总和与预定抽选总数不一致,请检查后再提交数据!");
                return;
            }
            #endregion

            DialogResult dr = MessageBox.Show("确定提交本次抽选申请?", "提示", MessageBoxButtons.YesNo);
            if (dr == DialogResult.Yes)
            {
                #region 添加抽选申请
                供应商抽选记录 model = new 供应商抽选记录
                {
                    申请时间 = DateTime.Now,
                    项目编号 = text_project_name.Text,
                    项目名称 = text_project_number.Text,
                    评标时间 = Convert.ToDateTime(date_bid_time.Text),
                    总计预定抽选供应商数 = int.Parse(text_totalnum_extract.Text),
                    操作人姓名 = text_operator_name.Text,
                    操作人电话 = text_operator_tel.Text
                };
                model.经办人.用户ID = CommonHelper.currentUser.Id;
                model.申请抽选状态 = 申请抽选状态.已提交待批准;

                //屏蔽列表
                var outlist = dtg_avoid_expert.Tag;
                var l = new List<用户链接<供应商>>();
                if (outlist!=null)
                {
                    var pk = outlist.ToString();
                    foreach (var item in pk.Split(new[] { "|" }, StringSplitOptions.RemoveEmptyEntries))
                    {
                        var z = new 用户链接<供应商>
                        {
                            用户ID = long.Parse(item)
                        };
                        l.Add(z);
                    }
                }
                model.回避供应商列表 = l;

                int count = dtg_condition_confirm.RowCount;
                var condition = new List<供应商抽选记录._供应商抽选条件>();
                for (int i = 0; i < count; i++)
                {
                    var t_condition = new 供应商抽选记录._供应商抽选条件();
                    t_condition.需要供应商数量 = int.Parse(dtg_condition_confirm.Rows[i].Cells[2].Value.ToString());

                    //可提供物质类别
                    var tempparmlist = dtg_condition_confirm.Rows[i].Cells[0].Tag.ToString();
                    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.描述 = dtg_condition_confirm.Rows[i].Cells[4].Value.ToString();
                    //所在地域
                    var place = new _地域
                    {
                        省份 = dtg_condition_confirm.Rows[i].Cells[5].Value.ToString(),
                        城市 = dtg_condition_confirm.Rows[i].Cells[6].Value.ToString(),
                        区县 = dtg_condition_confirm.Rows[i].Cells[7].Value.ToString()
                    };
                    t_condition.所在地区.Add(place);
                    condition.Add(t_condition);
                }
                model.供应商抽选条件 = condition;
                供应商抽选管理.添加供应商抽选历史(model);
                
                //站内消息
                //站内消息 Msg = new 站内消息();
                //对话消息 Talk = new 对话消息();

                //Msg.重要程度 = 重要程度.特别重要;
                //Msg.消息类型 = 消息类型.普通;
                //var u_id = CommonHelper.currentUser.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);
                MessageBox.Show("提交成功!");
                #endregion

                Program.PendApprovalGysform = new PendApprovalGys();
                FormHelper.changeFormToIndex(this, Program.PendApprovalGysform);
            }
        }
示例#20
0
 public _报价供应商()
 {
     报价供应商 = new 用户链接<供应商>();
 }
示例#21
0
 public 登录记录()
 {
     用户链接 = new 用户链接<用户基本数据>();
 }
 public ActionResult addChecker(需求计划 m)
 {
     try
     {
         string strid = Request.Form["uid"];
         string topuser = Request.Form["topuser"];
         需求计划 model = 需求计划管理.查找需求计划(m.Id);
         model.编制单位 = m.编制单位;
         model.采购年度 = m.采购年度;
         model.承办部门 = m.承办部门;
         model.建议完成时间 = m.建议完成时间;
         model.联系电话 = m.联系电话;
         model.联系人 = m.联系人;
         model.秘密等级 = m.秘密等级;
         model.需求计划标题 = m.需求计划标题;
         if (model.来源需求计划列表.Any())
         {
             return Content("<script>alert('合并需求不能再次提交,您可以提交新合并的需求!');window.location='/单位用户后台/demandlist?page=1';</script>");
         }
         else
         {
             model.审批流程单位列表 = new List<用户链接<单位用户>>();
             model.审核历史列表 = new List<需求计划._审核数据>();
             if (!string.IsNullOrWhiteSpace(strid))
             {
                 for (int i = 0; i < strid.Split(',').Length - 1; i++)
                 {
                     用户链接<单位用户> a = new 用户链接<单位用户>();
                     a.用户ID = long.Parse(strid.Split(',')[i]);
                     model.审批流程单位列表.Add(a);
                 }
                 if (!string.IsNullOrWhiteSpace(topuser) && topuser != "-1")
                 {
                     用户链接<单位用户> a = new 用户链接<单位用户>();
                     a.用户ID = long.Parse(topuser);
                     model.审批流程单位列表.Add(a);
                 }
                 model.当前处理单位链接.用户ID = model.审批流程单位列表.First().用户ID;
                 需求计划管理.更新需求计划(model);
                 return Redirect("/单位用户后台/Demandlist?page=1");
             }
             else
             {
                 return Content("<script>alert('请选择审核单位!');window.location='/单位用户后台/demandlist?page=1';</script>");
             }
         }
     }
     catch
     {
         return Redirect("/单位用户后台/Demandlist?page=1");
     }
 }
示例#23
0
 public _中标结果() { 供应商 = new 用户链接<供应商>(); 标的物 = new List<string>(); }
 public bool ExistChecker()
 {
     long tid = long.Parse(Request.QueryString["tid"]);
     long uid = long.Parse(Request.QueryString["id"]);
     需求采购任务 model = 需求采购任务管理.查找需求采购任务(tid);
     用户链接<单位用户> u = new 用户链接<单位用户>();
     u.用户ID = uid;
     if (model.审批流程单位列表.Contains(u))
     {
         return true;
     }
     else
     {
         return false;
     }
 }
示例#25
0
 //public List<string> 需求物资列表 { get; set; }
 public 需求申请()
 {
     需求提报单位 = new 用户链接<单位用户>();
     //需求物资列表 = new List<string>();
 }