public void GetRevoteResult(HttpContext context, OleDbConnection conn)
        {
            int iPrizeID = 0;

            int.TryParse(context.Request["PrizeID"], out iPrizeID);
            Dal.Models.Prize prize = BLL.Prize.GetPrize(iPrizeID, conn);

            BLL.Revote revote = new Revote();

            List <RevoteResultView> views = revote.GenerateRevoteResultViews(prize.PrizeID ?? 0, conn);
            bool    isIndividual          = prize.PrizeTypeCode == "0302" || prize.PrizeTypeCode == "0303";
            dynamic response = new
            {
                Views  = views,
                Awards = isIndividual
                    ? (dynamic) new { Recommended = prize.AwardCount ?? 0 }
                    : (dynamic) new
                {
                    FirstPrize  = prize.FirstPrize ?? 0,
                    SecondPrize = prize.SecondPrize ?? 0,
                    ThirdPrize  = prize.ThirdPrize ?? 0
                },
                IsIndividual = isIndividual
            };

            context.Response.Write(JsonConvert.SerializeObject(response));

            // 获取复投结果表数据, RevoteResult
        }
        private void RevotingVote(HttpContext context, OleDbConnection conn)
        {
            Dal.Models.UserInfo user   = (Dal.Models.UserInfo)context.Session["UserInfo"];
            Dal.Models.Expert   expert = BLL.Expert.GetExpertByUserID(user.UserID.Value, conn);
            OleDbTransaction    tran   = conn.BeginTransaction();

            try
            {
                int declarationId = 0;
                int revoteGroupId = 0;
                int recommended   = 0;
                int notRecommened = 0;
                int prizeId       = 0;
                if (!int.TryParse(context.Request["DeclarationID"], out declarationId) ||
                    !int.TryParse(context.Request["RevoteGroupId"], out revoteGroupId) ||
                    !int.TryParse(context.Request["RevoteRecommended"], out recommended) ||
                    !int.TryParse(context.Request["NotRevoteRecommended"], out notRecommened) ||
                    !int.TryParse(context.Request["PrizeId"], out prizeId))
                {
                    throw new Exception("参数错误!");
                }

                Dal.Models.Prize prize = BLL.Prize.GetPrize(prizeId, conn, tran);
                if (prize == null || prize.IsStopVote)
                {
                    throw new Exception("当前奖项及轮次已结束投票。");
                }

                Revote revote = new Revote();
                bool   saved  = revote.SaveRevotingVote(revoteGroupId, declarationId, recommended, notRecommened, expert.UserID.Value,
                                                        conn, tran);

                if (saved)
                {
                    tran.Commit();

                    var    revoteGroups = this.BuildRevoteGroupViews(prize, expert, conn);
                    string message      = "投票成功!";

                    var result = new { Views = revoteGroups, Message = message };

                    context.Response.Write(JsonConvert.SerializeObject(result));
                }
                else
                {
                    tran.Rollback();
                    context.Response.Write(JsonConvert.SerializeObject(new { Message = "投票错误" }));
                }
            }
            catch (Exception ex)
            {
                tran.Rollback();
                context.Response.Write(JsonConvert.SerializeObject(new { Message = ex.Message }));
            }
        }
        /// <summary>
        /// 继续复投
        /// </summary>
        /// <param name="context"></param>
        /// <param name="conn"></param>
        private void RevoteMore(HttpContext context, OleDbConnection conn)
        {
            // 解析回传变量
            int iPrizeID = 0;

            int.TryParse(context.Request["PrizeID"], out iPrizeID);

            // 获取所有复投分组
            Revote revote = new Revote();

            // 计算新复投分组
            string result = revote.GenerateRevoting(iPrizeID, conn);

            context.Response.Write(result);
        }
        private List <dynamic> BuildRevoteGroupViews(Dal.Models.Prize prize, Dal.Models.Expert expert, OleDbConnection conn)
        {
            BLL.Revote revote = new Revote();

            List <RevoteGroup> groups     = revote.GetRevoteGroups(prize, conn);
            List <dynamic>     groupViews = new List <dynamic>();

            foreach (var revoteGroup in groups)
            {
                int revoteGroupId = revoteGroup.RevoteGroupId;
                List <RevotePrizeLevel> awards      = revote.GetRevotePrizeLevelsByGroupId(revoteGroupId, conn);
                List <RevotingVoteView> votingViews = revote.GetRevotingVoteViews(revoteGroupId, expert.UserID.Value, conn);

                // 推荐票数 = 评选奖项总数-最低奖项数量
                // 举例,若评选2个一等奖,1个二等奖,则推荐票数为(2+1)-1=2
                // 若仅有一种奖项,则取该奖项的评选数量
                int recommended = awards.Count == 1
                    ? awards.Sum(a => a.LevelLimitNumber)
                    : awards.Sum(a => a.LevelLimitNumber) - awards.LastOrDefault().LevelLimitNumber;

                // 是否已提交, 当且仅当全部投票IsSubmit=true则视为该专家已经提交
                bool isSubmit = votingViews.TrueForAll(v => v.IsSubmit.HasValue && v.IsSubmit.Value);

                // 已投票
                int voted = votingViews.Count(v => v.RevoteRecommended.HasValue && v.RevoteRecommended.Value == 1);

                dynamic groupView = new
                {
                    RevoteGroupId = revoteGroupId,
                    VotingViews   = votingViews.ToArray(),
                    Info          = new
                    {
                        Awards      = awards.Select(a => a.ToAwardView()).ToArray <AwardView>(),
                        Recommended = recommended,
                        Voted       = voted,
                        IsSubmit    = isSubmit
                    }
                };

                groupViews.Add(groupView);
            }

            return(groupViews);
        }
        /// <summary>
        /// 提交复投分组结果
        /// </summary>
        /// <param name="context"></param>
        /// <param name="conn"></param>
        private void SubmitRevoteResult(HttpContext context, OleDbConnection conn)
        {
            // inital variables from request context
            int iPrizeID = 0;

            int.TryParse(context.Request["PrizeID"], out iPrizeID);
            string strViews = context.Request["Views"];

            // 生成复投分组
            Revote revote = new Revote();

            revote.SubmitRevoteResults(strViews, iPrizeID, conn);

            /* 5.
             * 返回响应
             *
             */
            context.Response.Write("复投结果已提交!");
        }
        public void SubmitRevotingVote(HttpContext context, OleDbConnection conn)
        {
            int iPrizeID = 0;

            Int32.TryParse(context.Request["PrizeID"], out iPrizeID);
            Dal.Models.Prize    prize  = BLL.Prize.GetPrize(iPrizeID, conn);
            Dal.Models.UserInfo user   = (Dal.Models.UserInfo)context.Session["UserInfo"];
            Dal.Models.Expert   expert = BLL.Expert.GetExpertByUserID(user.UserID.Value, conn);

            if (prize == null || prize.IsStopVote)
            {
                context.Response.Write("当前奖项及轮次已结束投票。");
                return;
            }

            OleDbTransaction tran = conn.BeginTransaction();

            try
            {
                BLL.Revote revote = new Revote();

                RevotePrize last = revote.GetLastRevotePrize(prize, conn, tran);

                bool saved = revote.SubmitRevotingVote(expert.UserID.Value, last.RevotePrizeId, conn, tran);

                if (saved)
                {
                    tran.Commit();
                    context.Response.Write("提交成功!");
                }
                else
                {
                    tran.Commit();
                    context.Response.Write("提交错误!");
                }
            }
            catch (Exception ex)
            {
                tran.Rollback();
                context.Response.Write(ex.Message);
            }
        }
        /// <summary>
        /// 计算复投分组
        /// </summary>
        /// <param name="context"></param>
        /// <param name="conn"></param>
        private void Revote(HttpContext context, OleDbConnection conn)
        {
            // inital variables from request context
            int iPrizeID = 0;

            int.TryParse(context.Request["PrizeID"], out iPrizeID);
            string strData = context.Request["data"];

            Dal.Models.Prize prize = BLL.Prize.GetPrize(iPrizeID, conn);


            // 生成复投分组
            Revote revote = new Revote();
            string result = revote.GenerateRevoting(strData, prize, conn);

            /* 5.
             * 返回响应
             *
             */
            context.Response.Write(result);
        }
        private void BatchRevotingVote(HttpContext context, OleDbConnection conn)
        {
            Dal.Models.UserInfo user   = (Dal.Models.UserInfo)context.Session["UserInfo"];
            Dal.Models.Expert   expert = BLL.Expert.GetExpertByUserID(user.UserID.Value, conn);

            int prizeId = 0;
            int recommended, notRecommended;

            int.TryParse(context.Request["PrizeID"], out prizeId);
            int.TryParse(context.Request["Recommended"], out recommended);
            int.TryParse(context.Request["NotRecommended"], out notRecommended);

            Dal.Models.Prize prize = BLL.Prize.GetPrize(prizeId, conn);

            if (prize == null || prize.IsStopVote)
            {
                context.Response.Write("当前奖项及轮次已结束投票。");
                return;
            }
            BLL.Revote  revote      = new Revote();
            RevotePrize revotePrize = revote.GetLastRevotePrize(prize, conn);

            OleDbTransaction tran = conn.BeginTransaction();

            try
            {
                bool saved = revote.SaveBatchRevotingVotes(revotePrize.RevotePrizeId, expert.UserID.Value, recommended, notRecommended, conn, tran);

                tran.Commit();
                context.Response.Write(JsonConvert.SerializeObject("投票成功!"));
            }
            catch (Exception ex)
            {
                tran.Rollback();
                context.Response.Write(JsonConvert.SerializeObject(ex.Message));
            }
        }