radgrad/radgrad2

import { Meteor } from 'meteor/meteor';
import { ValidatedMethod } from 'meteor/mdg:validated-method';
import { CallPromiseMixin } from 'meteor/didericis:callpromise-mixin';
import { VerificationRequests } from './VerificationRequestCollection';
import { OpportunityInstances } from '../opportunity/OpportunityInstanceCollection';
import { Opportunities } from '../opportunity/OpportunityCollection';
import { AcademicTerms } from '../academic-term/AcademicTermCollection';
import { Users } from '../user/UserCollection';
import { ROLE } from '../role/Role';

/**
 * The ValidatedMethod for updating the status of VerificationRequests.
 * Passed an object with fields:
 * id: the verificationRequestID
 * status: boolean
 * processed: a project object.
 * @memberOf api/verification
 */
export const verificationRequestsUpdateStatusMethod = new ValidatedMethod({
  name: 'VerificationRequests.updateStatus',
  validate: null,
  mixins: [CallPromiseMixin],
  run(update) {
    if (Meteor.isServer) {
      // Verify that currently logged in user is an admin, advisor, or faculty. otherwise no update can occur.
      VerificationRequests.assertRole(Meteor.userId(), [ROLE.ADMIN, ROLE.ADVISOR, ROLE.FACULTY]);
      return VerificationRequests.updateStatus(update.id, update.status, update.processed);
    }
    return null;
  },
});

/**
 * Returns the opportunityInstanceID associated with the student and opportunity, or null if not found.
 * @param student The student.
 * @param opportunity The opportunity.
 * @param academicTerm The academicTerm
 * @returns The opportunityInstanceID, or null if it wasn't found.
 * @memberOf api/verification
 */
const getOpportunityInstanceID = (student, opportunity, academicTerm) => {
  const studentID = Users.getID(student);
  const opportunityID = Opportunities.getID(opportunity);
  const termID = AcademicTerms.getID(academicTerm);
  const opportunityInstances = OpportunityInstances.findNonRetired({ opportunityID, studentID, termID });
  return (opportunityInstances.length > 0) ? opportunityInstances[0]._id : null;
};

/**
 * This Meteor Method processes a request to verify an opportunity for a given user from the VerificationEvent page.
 * The method is passed a student, opportunity, and academicTerm, which should normally be valid.
 * Processing this request involves the following:
 *   * If the student does not have an Opportunity Instance for this opportunity and academicTerm, then one is created
 *     for them.
 *   * If the student has not already submitted a Verification Request for their Opportunity Instance, then one is
 *     created for them.
 *   * If the student has already been verified for this Opportunity, then nothing more is done.
 *   * Once the OpportunityInstance and VerificationRequest exist, then they are updated to indicate that they have
 *     been verified if they are not already verified.
 *   * A status string is returned to the caller to indicate the result of processing.
 * Only faculty, advisors, and admins can invoke this method.
 * @memberOf api/verification
 */
export const processVerificationEventMethod = new ValidatedMethod({
  name: 'VerificationRequests.processVerificationEvent',
  validate: null,
  mixins: [CallPromiseMixin],
  run({ student, opportunity, academicTerm, verified = false }: { student: string; opportunity: string; academicTerm: string; verified?: boolean; }) {
    if (Meteor.isServer) {
      // Define a string to hold the result of this process.
      let resultMessage = '';

      // Verify that currently logged in user is an admin, advisor, or faculty. otherwise no verification can occur.
      VerificationRequests.assertRole(Meteor.userId(), [ROLE.ADMIN, ROLE.ADVISOR, ROLE.FACULTY]);

      // Make sure there's an opportunity instance for this student.
      let opportunityInstanceID = getOpportunityInstanceID(student, opportunity, academicTerm);
      if (!opportunityInstanceID) {
        resultMessage += `  No opportunity instance found for ${student}. Defining a new one.\n`;
        opportunityInstanceID = OpportunityInstances.define({ academicTerm, opportunity, student, verified });
      }

      // Make sure there's a verification request for this opportunity instance.
      let verificationRequestID = VerificationRequests.findOne({ opportunityInstanceID });
      if (!verificationRequestID) {
        resultMessage += '  No verification request found. Defining a new one.\n';
        verificationRequestID = VerificationRequests.define({ student, opportunityInstance: opportunityInstanceID, documentation: 'documentation' });
      }

      // If this event has already been verified, then return now.
      if (OpportunityInstances.findDoc(opportunityInstanceID).verified) {
        const opp = Opportunities.findDoc(opportunity);
        return `  Event ${opp.name} is already verified for ${student}\n`;
      }

      // Otherwise verify the opportunity instance and the VerificationRequestID.
      resultMessage += '  Setting the opportunity instance and verification request to verified.\n';
      OpportunityInstances.update(opportunityInstanceID, { verified: true });
      VerificationRequests.setVerified(verificationRequestID, Meteor.userId());

      return resultMessage;
    }
    return null;
  },
});

/**
 * This Meteor Method processes a command from the Pending Verification Request widget.
 * The method is passed a verificationRequestID, a command (ACCEPTED or REJECTED), and an optional feedback string.
 * The method returns a string indicating what happened.
 * Processing this request involves the following:
 *
 *   * Make sure user is a faculty, advisor, or admin. Otherwise throw error.
 *   * If verificationRequestID is not a valid ID, then throw error.
 *   * If command is not VerificationRequests.ACCEPTED or VerificationRequests.REJECTED, then returns an error string.
 *   * Creates a process object to record this command.
 *   * Updates the VerificationRequest with the new process object and the new status.
 *
 * Only faculty, advisors, and admins can invoke this method.
 * @memberOf api/verification
 */
export const processPendingVerificationMethod = new ValidatedMethod({
  name: 'VerificationRequests.processPendingVerification',
  validate: null,
  mixins: [CallPromiseMixin],
  run({ verificationRequestID, command, feedback }) {
    if (Meteor.isServer) {
      // Verify that currently logged in user is an admin, advisor, or faculty. otherwise no verification can occur.
      VerificationRequests.assertRole(Meteor.userId(), [ROLE.ADMIN, ROLE.ADVISOR, ROLE.FACULTY]);

      // Verify that the ID is valid.
      const requestDoc = VerificationRequests.findDoc(verificationRequestID);

      // Verify that the command is VerificationRequests.ACCEPTED or REJECTED.
      if ((command !== VerificationRequests.ACCEPTED) && (command !== VerificationRequests.REJECTED)) {
        throw new Meteor.Error(`VerificationRequest command is invalid: ${command}`);
      }

      // Update the opportunityInstance corresponding to this verification request.
      const verified = (command === VerificationRequests.ACCEPTED);
      OpportunityInstances.update(requestDoc.opportunityInstanceID, { verified });

      // Update the verification request.
      VerificationRequests.setVerificationStatus(verificationRequestID, Meteor.userId(), command, feedback);

      const student = Users.getProfile(requestDoc.studentID).username;
      return `Verification request for ${student} was processed`;
    }
    return null;
  },
});