EnrolleeAgreementsController.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

using Prime.Configuration.Auth;
using Prime.Models;
using Prime.Services;
using Prime.Models.Api;
using Prime.ViewModels;
using Prime.Services.Razor;
using System.Linq;
using System;

namespace Prime.Controllers
{
    [Produces("application/json")]
    [Route("api/enrollees")]
    [ApiController]
    [Authorize(Roles = Roles.PrimeEnrollee + "," + Roles.ViewEnrollee)]
    public class EnrolleeAgreementsController : PrimeControllerBase
    {
        private readonly IEnrolleeService _enrolleeService;
        private readonly IEnrolleeAgreementService _enrolleeAgreementService;
        private readonly IEnrolleeSubmissionService _enrolleeSubmissionService;
        private readonly IRazorConverterService _razorConverterService;
        private readonly IBusinessEventService _businessEventService;
        private readonly IDocumentService _documentService;

        private readonly IPdfService _pdfService;

        public EnrolleeAgreementsController(
            IEnrolleeService enrolleeService,
            IEnrolleeAgreementService enrolleeAgreementService,
            IEnrolleeSubmissionService enrolleeSubmissionService,
            IRazorConverterService razorConverterService,
            IBusinessEventService businessEventService,
            IDocumentService documentService,
            IPdfService pdfService)
        {
            _enrolleeService = enrolleeService;
            _enrolleeAgreementService = enrolleeAgreementService;
            _enrolleeSubmissionService = enrolleeSubmissionService;
            _razorConverterService = razorConverterService;
            _businessEventService = businessEventService;
            _documentService = documentService;
            _pdfService = pdfService;
        }

        // GET: api/enrollees/5/agreements
        /// <summary>
        /// Get a list of the enrollee's agreements.
        /// </summary>
        /// <param name="enrolleeId"></param>
        /// <param name="filters"></param>
        [HttpGet("{enrolleeId}/agreements", Name = nameof(GetEnrolleeAgreements))]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status403Forbidden)]
        [ProducesResponseType(typeof(ApiMessageResponse), StatusCodes.Status404NotFound)]
        [ProducesResponseType(typeof(ApiResultResponse<IEnumerable<Agreement>>), StatusCodes.Status200OK)]
        public async Task<ActionResult> GetEnrolleeAgreements(int enrolleeId, [FromQuery] AgreementFilters filters)
        {
            var record = await _enrolleeService.GetPermissionsRecordAsync(enrolleeId);
            if (record == null)
            {
                return NotFound($"Enrollee not found with id {enrolleeId}");
            }
            if (!record.AccessableBy(User))
            {
                return Forbid();
            }

            var agreements = await _enrolleeAgreementService.GetEnrolleeAgreementsAsync(enrolleeId, filters);

            if (User.IsAdministrant())
            {
                await _businessEventService.CreateAdminViewEventAsync(enrolleeId, "Admin viewing PRIME History");
            }

            return Ok(agreements);
        }

        // GET: api/enrollees/5/agreement
        /// <summary>
        /// Get the enrollee's current accepted agreement in PDF.
        /// </summary>
        /// <param name="enrolleeId"></param>
        [HttpGet("{enrolleeId}/agreement", Name = nameof(GetEnrolleeAcceptedAgreement))]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status403Forbidden)]
        [ProducesResponseType(typeof(ApiMessageResponse), StatusCodes.Status404NotFound)]
        [ProducesResponseType(typeof(ApiResultResponse<IEnumerable<Agreement>>), StatusCodes.Status200OK)]
        public async Task<ActionResult> GetEnrolleeAcceptedAgreement(int enrolleeId)
        {
            var record = await _enrolleeService.GetPermissionsRecordAsync(enrolleeId);
            if (record == null)
            {
                return NotFound($"Enrollee not found with id {enrolleeId}");
            }
            if (!record.AccessableBy(User))
            {
                return Forbid();
            }

            Agreement agreement = await _enrolleeAgreementService.GetCurrentAgreementAsync(enrolleeId);

            if (agreement == null)
            {
                return NotFound($"Agreement not found on enrollee with id {enrolleeId}");
            }

            var token = await _documentService.GetDownloadTokenForSignedAgreementDocument(agreement.Id);

            return Ok(token);
        }

        // GET: api/enrollees/5/cards
        /// <summary>
        /// Get a list of the enrollee's enrolment card view models.
        /// </summary>
        /// <param name="enrolleeId"></param>
        /// <param name="filters"></param>
        [HttpGet("{enrolleeId}/cards", Name = nameof(GetEnrolleeEnrolmentCards))]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status403Forbidden)]
        [ProducesResponseType(typeof(ApiMessageResponse), StatusCodes.Status404NotFound)]
        [ProducesResponseType(typeof(ApiResultResponse<IEnumerable<EnrolmentCardViewModel>>), StatusCodes.Status200OK)]
        public async Task<ActionResult> GetEnrolleeEnrolmentCards(int enrolleeId, [FromQuery] AgreementFilters filters)
        {
            var record = await _enrolleeService.GetPermissionsRecordAsync(enrolleeId);
            if (record == null)
            {
                return NotFound($"Enrollee not found with id {enrolleeId}");
            }
            if (!record.AccessableBy(User))
            {
                return Forbid();
            }

            var enrolmentCards = new List<EnrolmentCardViewModel>();
            var submissions = await _enrolleeSubmissionService.GetEnrolleeSubmissionsAsync(enrolleeId);
            var agreements = await _enrolleeAgreementService.GetEnrolleeAgreementsAsync(enrolleeId, filters);
            var lastSubmissionDate = null as DateTimeOffset?;

            var currentSubmission = submissions.First();

            foreach (var submission in submissions)
            {
                //filter the submission that within the year selected
                if (submission.CreatedDate.Year == filters.YearAccepted || filters.YearAccepted == null)
                {
                    //find the agreement that created after the submission and before the next submission (if exists)
                    var agreement = agreements.Where(a => submission.CreatedDate <= a.CreatedDate &&
                        (lastSubmissionDate == null || a.CreatedDate < lastSubmissionDate)).FirstOrDefault();
                    var card = new EnrolmentCardViewModel
                    {
                        AgreementId = agreement != null ? agreement.Id : 0,
                        AgreementType = agreement != null ? agreement.AgreementVersion.AccessType : null,
                        AgreementAcceptedDate = agreement != null ? agreement.AcceptedDate : null,
                        EnrolmentApprovedDate = agreement != null ? agreement.CreatedDate : null,
                        Submission = submission,
                        SubmissionId = submission.Id,
                        IsCurrent = currentSubmission.Id == submission.Id
                    };

                    enrolmentCards.Add(card);
                    lastSubmissionDate = submission.CreatedDate;
                }
            }

            if (User.IsAdministrant())
            {
                await _businessEventService.CreateAdminViewEventAsync(enrolleeId, "Admin viewing PRIME History");
            }

            return Ok(enrolmentCards);
        }

        // GET: api/enrollees/5/agreements/2
        /// <summary>
        /// Get a specific agreement for an enrollee.
        /// </summary>
        /// <param name="enrolleeId"></param>
        /// <param name="agreementId"></param>
        [HttpGet("{enrolleeId}/agreements/{agreementId}", Name = nameof(GetAgreement))]
        [ProducesResponseType(typeof(ApiMessageResponse), StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status403Forbidden)]
        [ProducesResponseType(typeof(ApiMessageResponse), StatusCodes.Status404NotFound)]
        [ProducesResponseType(typeof(ApiResultResponse<Agreement>), StatusCodes.Status200OK)]
        public async Task<ActionResult> GetAgreement(int enrolleeId, int agreementId)
        {
            var record = await _enrolleeService.GetPermissionsRecordAsync(enrolleeId);
            if (record == null)
            {
                return NotFound($"Enrollee not found with id {enrolleeId}");
            }
            if (!record.AccessableBy(User))
            {
                return Forbid();
            }

            var agreement = await _enrolleeAgreementService.GetEnrolleeAgreementAsync(enrolleeId, agreementId, true);
            if (agreement == null)
            {
                return NotFound($"Agreement not found with id {agreementId} on enrollee with id {enrolleeId}");
            }

            if (User.IsAdministrant())
            {
                await _businessEventService.CreateAdminViewEventAsync(enrolleeId, "Admin viewing Agreement");
            }

            return Ok(agreement);
        }

        // GET: api/enrollees/5/agreements/3/submission
        /// <summary>
        /// Get the submission for a given agreement.
        /// </summary>
        /// <param name="enrolleeId"></param>
        /// <param name="agreementId"></param>
        [HttpGet("{enrolleeId}/agreements/{submissionId}/submission", Name = nameof(GetSubmissionForAgreement))]
        [ProducesResponseType(typeof(ApiMessageResponse), StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status403Forbidden)]
        [ProducesResponseType(typeof(ApiMessageResponse), StatusCodes.Status404NotFound)]
        [ProducesResponseType(typeof(ApiResultResponse<Submission>), StatusCodes.Status200OK)]
        public async Task<ActionResult> GetSubmissionForAgreement(int enrolleeId, int submissionId)
        {
            var record = await _enrolleeService.GetPermissionsRecordAsync(enrolleeId);
            if (record == null)
            {
                return NotFound($"Enrollee not found with id {enrolleeId}");
            }
            if (!record.AccessableBy(User))
            {
                return Forbid();
            }

            var enrolleeSubmission = await _enrolleeSubmissionService.GetEnrolleeSubmissionAsync(submissionId);
            if (enrolleeSubmission == null)
            {
                return NotFound($"No enrolment submissions were found for Submission with id {submissionId} for enrollee with id {enrolleeId}.");
            }

            if (User.IsAdministrant())
            {
                await _businessEventService.CreateAdminViewEventAsync(enrolleeId, "Admin viewing Enrolment in PRIME History");
            }

            return Ok(enrolleeSubmission);
        }

        // GET: api/enrollees/5/agreements/2/signable
        /// <summary>
        /// Downloads a specific unsigned access term for an enrollee.
        /// </summary>
        /// <param name="enrolleeId"></param>
        /// <param name="agreementId"></param>
        [HttpGet("{enrolleeId}/agreements/{agreementId}/signable", Name = nameof(GetAccessTermSignable))]
        [ProducesResponseType(typeof(ApiMessageResponse), StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status403Forbidden)]
        [ProducesResponseType(typeof(ApiMessageResponse), StatusCodes.Status404NotFound)]
        [ProducesResponseType(typeof(ApiResultResponse<byte[]>), StatusCodes.Status200OK)]
        public async Task<ActionResult> GetAccessTermSignable(int enrolleeId, int agreementId)
        {
            var record = await _enrolleeService.GetPermissionsRecordAsync(enrolleeId);
            if (record == null)
            {
                return NotFound($"Enrollee not found with id {enrolleeId}");
            }
            if (!record.AccessableBy(User))
            {
                return Forbid();
            }

            Agreement agreement = await _enrolleeAgreementService.GetEnrolleeAgreementAsync(enrolleeId, agreementId, true);

            if (agreement == null)
            {
                return NotFound($"Agreement not found with id {agreementId} on enrollee with id {enrolleeId}");
            }

            var html = await _razorConverterService.RenderTemplateToStringAsync(RazorTemplates.Agreements.Pdf, agreement);
            var download = _pdfService.Generate(html);

            return Ok(download);
        }

        // GET: api/enrollees/5/agreements/current/obo-to-ru
        /// <summary>
        /// Gets boolean re: whether enrollee's current agreement type is OBO and the agreement type
        /// they would be assigned is RU, if automatic assignment occurred today
        /// </summary>
        /// <param name="enrolleeId"></param>
        [HttpGet("{enrolleeId}/agreements/current/obo-to-ru", Name = nameof(IsOboToRuAgreementTypeChange))]
        [ProducesResponseType(StatusCodes.Status403Forbidden)]
        [ProducesResponseType(typeof(ApiMessageResponse), StatusCodes.Status404NotFound)]
        [ProducesResponseType(typeof(ApiResultResponse<bool>), StatusCodes.Status200OK)]
        public async Task<ActionResult> IsOboToRuAgreementTypeChange(int enrolleeId)
        {
            var record = await _enrolleeService.GetPermissionsRecordAsync(enrolleeId);
            if (record == null)
            {
                return NotFound($"Enrollee not found with id {enrolleeId}");
            }
            if (!record.AccessableBy(User))
            {
                return Forbid();
            }

            var isOboToRuChange = await _enrolleeAgreementService.IsOboToRuAgreementTypeChangeAsync(enrolleeId);

            return Ok(isOboToRuChange);
        }

        // GET: api/enrollees/5/agreements/current/agreement-group
        /// <summary>
        ///     Gets the agreement group for enrollees current agreement, null if no current agreement
        /// </summary>
        /// <param name="enrolleeId"></param>
        [HttpGet("{enrolleeId}/agreements/current/agreement-group", Name = nameof(GetCurrentAgreementGroupForAnEnrollee))]
        [ProducesResponseType(StatusCodes.Status403Forbidden)]
        [ProducesResponseType(typeof(ApiMessageResponse), StatusCodes.Status404NotFound)]
        [ProducesResponseType(typeof(ApiResultResponse<AgreementGroup?>), StatusCodes.Status200OK)]
        public async Task<ActionResult> GetCurrentAgreementGroupForAnEnrollee(int enrolleeId)
        {
            var record = await _enrolleeService.GetPermissionsRecordAsync(enrolleeId);
            if (record == null)
            {
                return NotFound($"Enrollee not found with id {enrolleeId}");
            }
            if (!record.AccessableBy(User))
            {
                return Forbid();
            }

            var agreementGroup = await _enrolleeAgreementService.GetCurrentAgreementGroupForAnEnrolleeAsync(enrolleeId);

            return Ok(agreementGroup);
        }
    }
}