public async Task <IActionResult> Send(AddClarificationModel model)
        {
            // validate the model
            if (string.IsNullOrWhiteSpace(model.Body))
            {
                ModelState.AddModelError("xys::clar_empty", "Clarification body cannot be empty.");
            }

            // reply clar
            Clarification replyTo = null;

            if (model.ReplyTo.HasValue)
            {
                replyTo = await Context.FindClarificationAsync(model.ReplyTo.Value);

                if (replyTo == null)
                {
                    ModelState.AddModelError("xys::clar_not_found", "The clarification replied to not found.");
                }
            }

            // determine category
            var probs = await Context.ListProblemsAsync();

            var usage = probs.ClarificationCategories.FirstOrDefault(cp => model.Type == cp.Item1);

            if (usage.Item1 == null)
            {
                ModelState.AddModelError("xys::error_cate", "The category specified is wrong.");
            }

            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            var clar = await Context.ClarifyAsync(
                replyTo : replyTo,
                clar : new Clarification
            {
                Body         = model.Body,
                SubmitTime   = DateTimeOffset.Now,
                ContestId    = Contest.Id,
                JuryMember   = User.GetUserName(),
                Sender       = null,
                ResponseToId = model.ReplyTo,
                Recipient    = model.TeamTo == 0 ? default(int?) : model.TeamTo,
                ProblemId    = usage.Item3,
                Answered     = true,
                Category     = usage.Item2,
            });

            await HttpContext.AuditAsync("added", $"{clar.Id}");

            StatusMessage = $"Clarification {clar.Id} has been sent.";
            return(RedirectToAction(nameof(Detail), new { clarid = clar.Id }));
        }
        public ActionResult CreateClarification(int id, string subject, string text)
        {
            var contest       = session.Get <Contest>(id);
            var clarification = new Clarification
            {
                SentAt  = clock.CurrentTime,
                Author  = userSession.CurrentUser,
                Contest = contest,
                Text    = text,
                Subject = subject
            };

            session.Save(clarification);
            return(MessageSentSuccessfully());
        }
Example #3
0
        public virtual async Task <Clarification> ClarifyAsync(Clarification clar, Clarification?replyTo)
        {
            var cl = Db.Clarifications.Add(clar);

            if (replyTo != null)
            {
                replyTo.Answered = true;
                Db.Clarifications.Update(replyTo);
            }

            await Db.SaveChangesAsync();

            await Mediator.Publish(new Events.ClarificationCreateEvent(this, clar));

            return(cl.Entity);
        }
Example #4
0
        public int SendClarification(Clarification clar)
        {
            var entity = DbContext.Clarifications.Add(clar);

            DbContext.SaveChanges();

            DbContext.AuditLogs.Add(new AuditLog
            {
                ContestId = ContestId,
                Resolved  = true,
                Time      = clar.SubmitTime,
                UserName  = GetUserName(),
                Comment   = "added",
                EntityId  = entity.Entity.ClarificationId,
            });

            DbContext.SaveChanges();
            return(entity.Entity.ClarificationId);
        }
        public ActionResult Edit(int id, FormCollection collection)
        {
            try
            {
                string        name          = collection.Get("Name");
                Clarification clarification = new Clarification()
                {
                    ID = id, Name = name
                };

                IRepository <Clarification> repo = new ClarificationRepository();
                repo.Update(clarification);

                return(RedirectToAction("Index"));
            }
            catch
            {
                return(View());
            }
        }
        public ActionResult Create(FormCollection collection)
        {
            try
            {
                // TODO: Add insert logic here
                string        name          = collection.Get("Name");
                Clarification clarification = new Clarification()
                {
                    Name = name
                };

                IRepository <Clarification> repo = new ClarificationRepository();
                repo.Save(clarification);

                return(RedirectToAction("Index"));
            }
            catch
            {
                return(View());
            }
        }
        public MessagesQueriesTests()
        {
            factory = new TestDatabaseConfiguration().DatabaseConfiguration.BuildSessionFactory();

            isenbaev = new User
            {
                UserName = "******"
            };

            contest = new Contest
            {
                Beginning = new DateTime(1990, 7, 7),
                Ending    = new DateTime(1990, 7, 8)
            };
            var kapun = new User
            {
                UserName = "******",
            };

            var announcement = new Announcement
            {
                SentAt  = new DateTime(1990, 7, 7),
                Contest = contest
            };

            var clarification = new Clarification
            {
                SentAt  = new DateTime(1990, 7, 7),
                Contest = contest
            };

            var myQuestion = new Question
            {
                Author  = isenbaev,
                SentAt  = new DateTime(1990, 7, 7),
                Contest = contest
            };

            var myAnswer = new Answer
            {
                Recipient = isenbaev,
                SentAt    = new DateTime(1990, 7, 7),
                Contest   = contest
            };
            var hisQuestion = new Question
            {
                Author  = kapun,
                SentAt  = new DateTime(1990, 7, 7),
                Contest = contest
            };

            var hisAnswer = new Answer
            {
                Recipient = kapun,
                SentAt    = new DateTime(1990, 7, 7),
                Contest   = contest
            };

            using (var scope = new SessionScope(factory))
            {
                scope.Session.Save(isenbaev);
                scope.Session.Save(kapun);
                scope.Session.Save(contest);
                scope.Session.Save(announcement);
                scope.Session.Save(clarification);
                scope.Session.Save(myQuestion);
                scope.Session.Save(hisQuestion);
                scope.Session.Save(myAnswer);
                scope.Session.Save(hisAnswer);
            }
        }
Example #8
0
        public IActionResult Clarification(string op, AddClarificationModel model)
        {
            var(cid, teamid) = (Contest.ContestId, Team.TeamId);
            var probs = Service.Problems;
            int repl  = 0;

            if (op != "add" && !int.TryParse(op, out repl))
            {
                return(BadRequest());
            }
            if (Service.GetClarification(repl, false) == null)
            {
                return(NotFound());
            }

            string SolveAndAdd()
            {
                if (string.IsNullOrWhiteSpace(model.Body))
                {
                    return("Error sending empty clarification.");
                }

                var newClar = new Clarification
                {
                    Body         = model.Body,
                    SubmitTime   = DateTimeOffset.Now,
                    ContestId    = cid,
                    JuryMember   = null,
                    Sender       = teamid,
                    ResponseToId = op == "add" ? default(int?) : repl,
                    Recipient    = null,
                    ProblemId    = null,
                };

                if (model.Type == "general")
                {
                    newClar.Category = ClarificationCategory.General;
                }
                else if (model.Type == "tech")
                {
                    newClar.Category = ClarificationCategory.Technical;
                }
                else if (!model.Type.StartsWith("prob-"))
                {
                    return("Error detecting category.");
                }
                else
                {
                    var prob = probs.FirstOrDefault(p => "prob-" + p.ShortName == model.Type);
                    if (prob is null)
                    {
                        return("Error detecting problem.");
                    }
                    newClar.ProblemId = prob.ProblemId;
                    newClar.Category  = ClarificationCategory.Problem;
                }

                Service.SendClarification(newClar);
                return("Clarification sent to the jury");
            }

            DisplayMessage = SolveAndAdd();
            return(RedirectToAction(nameof(Home), new { cid }));
        }
Example #9
0
 public ClarificationCreateEvent(IContestContext contest, Clarification entity)
 {
     Clarification = entity;
     Context       = contest;
 }
Example #10
0
 public void UpdateClarificationBeforeInsertOne(Clarification clar)
 {
     DbContext.Clarifications.Update(clar);
 }
Example #11
0
        public IActionResult Send(AddClarificationModel model)
        {
            var cid   = Contest.ContestId;
            var probs = Service.Problems;

            string SolveAndAdd()
            {
                if (string.IsNullOrWhiteSpace(model.Body))
                {
                    return("Error sending empty clarification.");
                }

                var newClar = new Clarification
                {
                    Body         = model.Body,
                    SubmitTime   = DateTimeOffset.Now,
                    ContestId    = cid,
                    JuryMember   = UserManager.GetUserName(User),
                    Sender       = null,
                    ResponseToId = model.ReplyTo,
                    Recipient    = model.TeamTo == 0 ? default(int?) : model.TeamTo,
                    ProblemId    = null,
                    Answered     = true
                };

                if (model.ReplyTo.HasValue)
                {
                    var respTo = Service.GetClarification(model.ReplyTo.Value, true);
                    if (respTo == null)
                    {
                        return("Error finding clarification replying to");
                    }
                    respTo.Answered = true;
                    Service.UpdateClarificationBeforeInsertOne(respTo);
                }

                if (model.Type == "general")
                {
                    newClar.Category = ClarificationCategory.General;
                }
                else if (model.Type == "tech")
                {
                    newClar.Category = ClarificationCategory.Technical;
                }
                else if (!model.Type.StartsWith("prob-"))
                {
                    return("Error detecting category.");
                }
                else
                {
                    var prob = probs.FirstOrDefault(p => "prob-" + p.ShortName == model.Type);
                    if (prob is null)
                    {
                        return("Error detecting problem.");
                    }
                    newClar.ProblemId = prob.ProblemId;
                    newClar.Category  = ClarificationCategory.Problem;
                }

                Service.SendClarification(newClar);
                return("Clarification sent to common");
            }

            DisplayMessage = SolveAndAdd();
            return(RedirectToAction(nameof(Clarifications), new { cid }));
        }
Example #12
0
        public static async Task <IActionResult> ClarificationReply <T>(
            this ContestControllerBase <T> that,
            int?clarid,
            Models.AddClarificationModel model,
            string HomePage)
            where T : class, ICompeteContext
        {
            var(cid, teamid) = (that.Contest.Id, that.Contest.Team.TeamId);

            Clarification replit = null;

            if (clarid.HasValue)
            {
                replit = await that.Context.FindClarificationAsync(clarid.Value);

                if (replit == null)
                {
                    that.ModelState.AddModelError(
                        "xys::replyto",
                        "The clarification replied to is not found.");
                }
            }

            if (string.IsNullOrWhiteSpace(model.Body))
            {
                that.ModelState.AddModelError(
                    "xys::empty",
                    "No empty clarification");
            }

            var probs = await that.Context.ListProblemsAsync();

            var usage = probs.ClarificationCategories.SingleOrDefault(cp => model.Type == cp.Item1);

            if (usage.Item1 == null)
            {
                that.ModelState.AddModelError(
                    "xys::error_cate",
                    "The category specified is wrong.");
            }

            if (!that.ModelState.IsValid)
            {
                that.StatusMessage = string.Join('\n',
                                                 that.ModelState.Values
                                                 .SelectMany(m => m.Errors)
                                                 .Select(e => e.ErrorMessage));
            }
            else
            {
                var clar = await that.Context.ClarifyAsync(
                    new Clarification
                {
                    Body         = model.Body,
                    SubmitTime   = DateTimeOffset.Now,
                    ContestId    = cid,
                    Sender       = teamid,
                    ResponseToId = model.ReplyTo,
                    ProblemId    = usage.Item3,
                    Category     = usage.Item2,
                });

                await that.HttpContext.AuditAsync("added", $"{clar.Id}");

                that.StatusMessage = "Clarification sent to the jury.";
            }

            return(that.RedirectToAction(HomePage));
        }