示例#1
0
        /// <summary>
        /// Creates a new instance of a OpeningAnswer object, and initializes it with the specified property values.
        /// </summary>
        /// <param name="openingQuestion"></param>
        /// <param name="openingParticipant"></param>
        /// <param name="answer"></param>
        public OpeningAnswer(OpeningQuestion openingQuestion, OpeningParticipant openingParticipant, string answer)
        {
            if (String.IsNullOrWhiteSpace(answer))
            {
                throw new ArgumentException("The argument 'answer' cannot be null, empty or whitespace.");
            }

            this.QuestionId         = openingQuestion?.QuestionId ?? throw new ArgumentNullException(nameof(openingQuestion));
            this.Question           = openingQuestion.Question;
            this.OpeningId          = openingQuestion?.OpeningId ?? throw new ArgumentNullException(nameof(openingQuestion));
            this.Opening            = openingQuestion.Opening;
            this.OpeningQuestion    = openingQuestion;
            this.ParticipantId      = openingParticipant?.ParticipantId ?? throw new ArgumentNullException(nameof(openingParticipant));
            this.Participant        = openingParticipant.Participant;
            this.OpeningParticipant = openingParticipant;
            this.Text = answer;
        }
示例#2
0
        /// <summary>
        /// The participant is apply for the opening.
        /// </summary>
        /// <param name="opening"></param>
        /// <param name="participant"></param>
        /// <param name="answers"></param>
        /// <returns></returns>
        private Models.Opening Apply(Entities.Opening opening, Entities.Participant participant, params Models.Answer[] answers)
        {
            var userId           = this.GetUserId();
            var participantCount = opening.Participants.Count(p => p.State == OpeningApplicationState.Accepted);

            if (opening.MaxParticipants <= participantCount)
            {
                throw new InvalidOperationException($"The opening has been filled, {participantCount} of {opening.MaxParticipants} applications have been accepted.");
            }

            if (opening.Participants.Any(p => p.ParticipantId == participant.Id))
            {
                throw new InvalidOperationException($"Cannot apply for the same opening more than once.");
            }

            var openingCriteria  = opening.Criteria.ToArray().Select(c => (Criteria)c.Criteria);
            var activityCriteria = this.Context.ActivityCriteria.Include(ac => ac.Criteria).Where(ac => ac.ActivityId == opening.ActivityId).ToArray().Select(ac => (Criteria)ac.Criteria);
            var eventCriteria    = this.Context.EventCriteria.Include(ec => ec.Criteria).Where(ec => ec.EventId == opening.Activity.EventId).ToArray().Select(ac => (Criteria)ac.Criteria);
            var calendarCriteria = this.Context.CalendarCriteria.Include(cc => cc.Criteria).Where(cc => cc.CalendarId == opening.Activity.Event.CalendarId).ToArray().Select(ac => (Criteria)ac.Criteria);
            var criteria         = openingCriteria.Concat(activityCriteria).Concat(eventCriteria).Concat(calendarCriteria);

            // Validate criteria
            if (!criteria.All(c => c.Validate(participant.Attributes.Select(a => a.Attribute).ToArray())))
            {
                throw new InvalidOperationException($"The participant '{participant.DisplayName}' does not have the required attributes to apply to this opening.");
            }

            // Validate questions
            var answeredQuestionIds  = answers?.Select(a => a.QuestionId).ToArray() ?? new int[0];
            var hasAnsweredQuestions = opening.Questions.All(q => q.Question.IsRequired && answeredQuestionIds.Contains(q.QuestionId));

            if (!hasAnsweredQuestions)
            {
                throw new InvalidOperationException($"The application is missing an answer to a question.");
            }

            var state = opening.ApplicationProcess == ApplicationProcess.Review ? OpeningApplicationState.Applied : OpeningApplicationState.Accepted;
            var op    = new OpeningParticipant(opening, participant, state)
            {
                AddedById = userId
            };
            var eanswers = answers?.Select(a => new OpeningAnswer()
            {
                OpeningId = opening.Id, QuestionId = a.QuestionId, ParticipantId = participant.Id, OpeningParticipant = op, Text = a.Text, AddedById = userId
            }).ToArray() ?? new OpeningAnswer[0];                                                                                                                                                                                                                     // TODO: Save answer options.

            eanswers.ForEach(a => op.Answers.Add(a));
            opening.Participants.Add(op);
            this.Context.OpeningParticipants.Add(op);

            PerformAction(op, ActionTrigger.Apply);

            if (opening.ApplicationProcess == ApplicationProcess.AutoAccept)
            {
                PerformAction(op, ActionTrigger.Accept);
            }

            var result = this.Map(opening);

            Track(opening, result);
            return(result);
        }