resole conflicts

Author: ThomasKranitsas

config/default.js

@@ -68,12 +68,18 @@ module.exports = {
   SUBMISSION_PHASE_ID: process.env.SUBMISSION_PHASE_ID || '6950164f-3c5e-4bdc-abc8-22aaf5a1bd49',
   CHECKPOINT_SUBMISSION_PHASE_ID: process.env.CHECKPOINT_SUBMISSION_PHASE_ID || 'd8a2cdbe-84d1-4687-ab75-78a6a7efdcc8',
 
-  V5_TERMS_NDA_ID: process.env.V5_TERMS_NDA_ID || '77f558c1-56fb-427c-b974-61ea0a060ca7',
-  LEGACY_TERMS_NDA_ID: process.env.LEGACY_TERMS_NDA_ID || 21343,
+  V5_TERMS_NDA_ID: process.env.V5_TERMS_NDA_ID || 'e5811a7b-43d1-407a-a064-69e5015b4900',
+  LEGACY_TERMS_NDA_ID: process.env.LEGACY_TERMS_NDA_ID || 21233,
+
+  V5_TERMS_STANDARD_ID: process.env.V5_TERMS_STANDARD_ID || '317cd8f9-d66c-4f2a-8774-63c612d99cd4',
+  LEGACY_TERMS_STANDARD_ID: process.env.LEGACY_TERMS_STANDARD_ID || 21305,
+
   LEGACY_SUBMITTER_ROLE_ID: process.env.LEGACY_SUBMITTER_ROLE_ID || 1,
 
   COPILOT_PAYMENT_TYPE: process.env.COPILOT_PAYMENT_TYPE || 'copilot',
 
+  COPILOT_ROLE_ID: process.env.COPILOT_ROLE_ID || 'cfe12b3f-2a24-4639-9d8b-ec86726f76bd',
+
   // V5 Term UUID
   SYNC_V5_TERM_UUID: process.env.SYNC_V5_TERM_UUID || '317cd8f9-d66c-4f2a-8774-63c612d99cd4',
   SYNC_V5_WRITE_ENABLED: process.env.SYNC_V5_WRITE_ENABLED === 'true' || false

src/app.js

@@ -64,8 +64,7 @@ const dataHandler = (messageSet, topic, partition) => Promise.each(messageSet, a
 
   try {
     if (topic === config.CREATE_CHALLENGE_TOPIC) {
-      // create shut off. Only works with challenges of status draft, which happens on update
-      // await ProcessorService.processCreate(messageJSON)
+      await ProcessorService.processCreate(messageJSON)
     } else {
       await ProcessorService.processUpdate(messageJSON)
     }

src/constants.js

@@ -55,12 +55,22 @@ const prizeTypesIds = {
   Checkpoint: 14
 }
 
+const supportedMetadata = {
+  allowStockArt: 52,
+  drPoints: 30,
+  submissionViewable: 53,
+  submissionLimit: 51,
+  codeRepo: 85,
+  environment: 84
+}
+
 module.exports = {
   prizeSetTypes,
   EVENT_ORIGINATOR,
   EVENT_MIME_TYPE,
   createChallengeStatusesMap,
   challengeStatuses,
   PhaseStatusTypes,
-  prizeTypesIds
+  prizeTypesIds,
+  supportedMetadata
 }

src/services/ProcessorService.js

@@ -5,6 +5,7 @@ const helper = require('../common/helper')
 
 const COPILOT_PAYMENT_PROJECT_INFO_ID = 49
 const COPILOT_PAYMENT_RESOURCE_INFO_ID = 7
+const COPILOT_PAYMENT_TYPE_ID = 15
 const COPILOT_RESOURCE_ROLE_ID = 14
 
 const QUERY_GET_COPILOT_RESOURCE_FOR_CHALLENGE = `SELECT limit 1 resource_id as resourceid FROM resource WHERE project_id = %d AND resource_role_id = ${COPILOT_RESOURCE_ROLE_ID}`
@@ -32,6 +33,10 @@ const QUERY_DELETE_COPILOT_PAYMENT = `DELETE FROM project_info WHERE project_inf
 const QUERY_UPDATE_COPILOT_RESOURCE_PAYMENT = `UPDATE resource_info SET value = ?, modify_user = ?, modify_date = CURRENT WHERE resource_id = ? AND resource_info_type_id = ${COPILOT_PAYMENT_RESOURCE_INFO_ID}`
 // const QUERY_DELETE_COPILOT_RESOURCE_PAYMENT = `DELETE FROM resource_info WHERE resource_id = ? AND resource_info_type_id = ${COPILOT_PAYMENT_RESOURCE_INFO_ID}`
 
+const QUERY_SELECT_PAYMENT_TYPE = `SELECT value FROM resource_info WHERE resource_info_type_id = ${COPILOT_PAYMENT_TYPE_ID} AND resource_id = %d`
+const QUERY_INSERT_PAYMENT_TYPE = `INSERT INTO resource_info (resource_id, resource_info_type_id, value, create_user, create_date, modify_user, modify_date) VALUES (?, "${COPILOT_PAYMENT_TYPE_ID}", ?, ?, CURRENT, ?, CURRENT)`
+const QUERY_UPDATE_PAYMENT_TYPE = `UPDATE resource_info SET value = ?, modify_user = ?, modify_date = CURRENT WHERE resource_id = ? AND resource_info_type_id = ${COPILOT_PAYMENT_TYPE_ID}`
+
 /**
  * Prepare Informix statement
  * @param {Object} connection the Informix connection
@@ -58,6 +63,14 @@ async function setCopilotPayment (challengeLegacyId, amount, createdBy, updatedB
     const copilotResourceId = await getCopilotResourceId(connection, challengeLegacyId)
     const copilotPayment = await getCopilotPayment(connection, challengeLegacyId)
     if (amount != null && amount >= 0) {
+      // Make sure the payment type is set to manual
+      // TODO: Figure out why data is not saved in IFX even when there are no errors
+      // const paymentType = await getCopilotPaymentType(connection, copilotResourceId)
+      // if (!paymentType) {
+      //   await createCopilotPaymentType(connection, copilotResourceId, 'TRUE', updatedBy || createdBy)
+      // } else if (_.toLower(_.toString(paymentType.value)) !== 'true') {
+      //   await updateCopilotPaymentType(connection, copilotResourceId, 'TRUE', updatedBy || createdBy)
+      // }
       if (copilotPayment) {
         logger.debug(`Copilot payment exists, updating: ${challengeLegacyId}`)
         return updateCopilotPayment(connection, copilotResourceId, challengeLegacyId, amount, updatedBy)
@@ -78,6 +91,43 @@ async function setCopilotPayment (challengeLegacyId, amount, createdBy, updatedB
   }
 }
 
+/**
+ * Gets the copilot payment type for a legacyId
+ * @param {Object} connection the connection
+ * @param {Number} resourceId the resource ID
+ */
+async function getCopilotPaymentType (connection, resourceId) {
+  const result = await connection.queryAsync(util.format(QUERY_SELECT_PAYMENT_TYPE, resourceId))
+  logger.debug(`Result: ${JSON.stringify(result, null, 2)}`)
+  return _.get(result, '[0]', null)
+}
+
+/**
+ * Create the copilot payment type record
+ * @param {Object} connection the connection
+ * @param {Number} resourceId the resource ID
+ * @param {Boolean} value the value
+ * @param {String} createdBy the create user handle
+ */
+async function createCopilotPaymentType (connection, resourceId, value, createdBy) {
+  const query = await prepare(connection, QUERY_INSERT_PAYMENT_TYPE)
+  logger.debug(`Create Copilot Payment Type Values: ${[resourceId, value, createdBy, createdBy]}`)
+  await query.executeAsync([resourceId, value, createdBy, createdBy])
+}
+
+/**
+ * Update the copilot payment type record
+ * @param {Object} connection the connection
+ * @param {Number} resourceId the resource ID
+ * @param {Boolean} value the value
+ * @param {String} createdBy the create user handle
+ */
+async function updateCopilotPaymentType (connection, resourceId, value, createdBy) {
+  const query = await prepare(connection, QUERY_UPDATE_PAYMENT_TYPE)
+  logger.debug(`Update Copilot Payment Type Values: ${[value, createdBy, resourceId]}`)
+  await query.executeAsync([value, createdBy, resourceId])
+}
+
 /**
  * Gets the copilot payment for a legacyId
  * @param {Object} connection

src/services/copilotPaymentService.js

@@ -3,13 +3,12 @@ const _ = require('lodash')
 const util = require('util')
 const helper = require('../common/helper')
 
-const QUERY_GET_ELIGIBILITY_ID = 'SELECT limit 1 * FROM contest_eligibility WHERE contest_id = %d'
-const QUERY_GET_GROUP_ELIGIBILITY_ID = 'SELECT limit 1 * FROM group_contest_eligibility WHERE contest_eligibility_id = %d AND group_id = %d'
-const QUERY_GET_GROUPS = 'SELECT group_id FROM group_contest_eligibility WHERE contest_eligibility_id = %d'
-const QUERY_GET_GROUPS_COUNT = 'SELECT count(*) as cnt FROM group_contest_eligibility WHERE contest_eligibility_id = %d'
-
+const QUERY_GET_CONTEST_ELIGIBILITIES_IDS = 'SELECT contest_eligibility_id FROM contest_eligibility WHERE contest_id = %d'
 const QUERY_INSERT_CONTEST_ELIGIBILITY = 'INSERT INTO contest_eligibility (contest_eligibility_id, contest_id, is_studio) VALUES(contest_eligibility_seq.NEXTVAL, ?, 0)'
+
+const QUERY_GET_GROUPS = 'SELECT contest_eligibility_id, group_id FROM group_contest_eligibility WHERE contest_eligibility_id in'
 const QUERY_INSERT_GROUP_CONTEST_ELIGIBILITY = 'INSERT INTO group_contest_eligibility (contest_eligibility_id, group_id) VALUES(?, ?)'
+
 const QUERY_DELETE_GROUP_CONTEST_ELIGIBILITY = 'DELETE FROM group_contest_eligibility WHERE contest_eligibility_id = ? AND group_id = ?'
 const QUERY_DELETE_CONTEST_ELIGIBILITY = 'DELETE FROM contest_eligibility WHERE contest_eligibility_id = ?'
 
@@ -25,15 +24,20 @@ async function prepare (connection, sql) {
   return Promise.promisifyAll(stmt)
 }
 
+/**
+ * Get groups for a challenge
+ * @param {Number} challengeLegacyId the legacy challenge ID
+ */
 async function getGroupsForChallenge (challengeLegacyId) {
   // logger.debug(`Getting Groups for Challenge ${challengeLegacyId}`)
   const connection = await helper.getInformixConnection()
   let groupIds = []
   try {
     // await connection.beginTransactionAsync()
-    const eligibilityId = await getChallengeEligibilityId(connection, challengeLegacyId)
-    if (eligibilityId) {
-      groupIds = await getGroupIdsForEligibilityId(connection, eligibilityId)
+    const eligibilityIds = await getChallengeEligibilityIds(connection, challengeLegacyId)
+    if (eligibilityIds && eligibilityIds.length > 0) {
+      const groups = await getGroupsForEligibilityIds(connection, eligibilityIds)
+      groupIds = _.map(groups, g => g.group_id)
       // logger.debug(`Groups Found for ${challengeLegacyId} - ${JSON.stringify(groupIds)}`)
     }
     // logger.debug(`No groups Found for ${challengeLegacyId}`)
@@ -48,23 +52,25 @@ async function getGroupsForChallenge (challengeLegacyId) {
   return groupIds
 }
 
+/**
+ * Add a group to a challenge
+ * @param {Number} challengeLegacyId the legacy challenge ID
+ * @param {Number} groupLegacyId the legacy group ID
+ */
 async function addGroupToChallenge (challengeLegacyId, groupLegacyId) {
+  const existingGroups = await getGroupsForChallenge(challengeLegacyId)
+  if (existingGroups.indexOf(groupLegacyId) > -1) {
+    logger.info(`Group ${groupLegacyId} is already assigned to challenge ${challengeLegacyId}. Skipping...`)
+    return
+  }
   const connection = await helper.getInformixConnection()
 
   try {
     await connection.beginTransactionAsync()
-    let eligibilityId = await getChallengeEligibilityId(connection, challengeLegacyId)
-    if (!eligibilityId) {
-      eligibilityId = await createChallengeEligibilityRecord(connection, challengeLegacyId)
-    }
-
-    const groupMappingExists = await groupEligbilityExists(connection, eligibilityId, groupLegacyId)
-    if (groupMappingExists) {
-      logger.warn(`Group Relation Already Exists for ${groupMappingExists} - ${eligibilityId} ${groupLegacyId}`)
-    } else {
-      await createGroupEligibilityRecord(connection, eligibilityId, groupLegacyId)
-    }
-
+    // create eligibility entry
+    const eligibilityId = await createContestEligibility(connection, challengeLegacyId)
+    // create group association
+    await createGroupContestEligibility(connection, eligibilityId, groupLegacyId)
     await connection.commitTransactionAsync()
   } catch (e) {
     logger.error(`Error in 'addGroupToChallenge' ${e}, rolling back transaction`)
@@ -76,114 +82,96 @@ async function addGroupToChallenge (challengeLegacyId, groupLegacyId) {
   }
 }
 
+/**
+ * Remove group from a challenge
+ * @param {Number} challengeLegacyId the legacy challenge ID
+ * @param {Number} groupLegacyId the group ID
+ */
 async function removeGroupFromChallenge (challengeLegacyId, groupLegacyId) {
   const connection = await helper.getInformixConnection()
 
   try {
     await connection.beginTransactionAsync()
-    const eligibilityId = await getChallengeEligibilityId(connection, challengeLegacyId)
-    if (!eligibilityId) {
-      throw new Error(`Eligibility not found for legacyId ${challengeLegacyId}`)
-    }
-    const groupEligibilityRecord = await groupEligbilityExists(connection, eligibilityId, groupLegacyId)
-
-    if (groupEligibilityRecord) {
-      await deleteGroupEligibilityRecord(connection, eligibilityId, groupLegacyId)
-      // logger.debug('Getting Groups Count')
-      const { groupsCount } = await getCountOfGroupsInEligibilityRecord(connection, eligibilityId)
-      // logger.debug(`${groupsCount} groups exist`)
-      if (groupsCount <= 0) {
-        logger.debug('No groups exist, deleting eligibility group')
-        await deleteEligibilityRecord(connection, eligibilityId)
+    const eligibilityIds = await getChallengeEligibilityIds(connection, challengeLegacyId)
+    if (eligibilityIds && eligibilityIds.length > 0) {
+      const groups = await getGroupsForEligibilityIds(connection, eligibilityIds)
+      const groupToRemove = _.find(groups, g => g.group_id === groupLegacyId)
+      if (groupToRemove) {
+        await clearData(connection, groupToRemove.contest_eligibility_id, groupToRemove.group_id)
       }
     }
-
     await connection.commitTransactionAsync()
   } catch (e) {
     logger.error(`Error in 'removeGroupFromChallenge' ${e}, rolling back transaction`)
     await connection.rollbackTransactionAsync()
     throw e
   } finally {
-    logger.info(`Group ${groupLegacyId} removed to challenge ${challengeLegacyId}`)
+    logger.info(`Group ${groupLegacyId} removed from challenge ${challengeLegacyId}`)
     await connection.closeAsync()
   }
 }
 
 /**
- * Gets the eligibility ID of a legacyId
- * @param {Object} connection
- * @param {Number} challengeLegacyId
- * @returns {Object} { eligibilityId }
+ * Get group IDs
+ * @param {Object} connection the connection
+ * @param {Array} eligibilityIds the eligibility IDs
  */
-async function getChallengeEligibilityId (connection, challengeLegacyId) {
-  // get the challenge eligibility record, if one doesn't exist, create it and return the id
-  // logger.info(`getChallengeEligibilityId Query: ${util.format(QUERY_GET_ELIGIBILITY_ID, challengeLegacyId)}`)
-  const result = await connection.queryAsync(util.format(QUERY_GET_ELIGIBILITY_ID, challengeLegacyId))
-  // logger.info(`getChallengeEligibilityId Result: ${JSON.stringify(result)}`)
-  return (result && result[0]) ? result[0].contest_eligibility_id : false
+async function getGroupsForEligibilityIds (connection, eligibilityIds) {
+  const query = `${QUERY_GET_GROUPS} (${eligibilityIds.join(', ')})`
+  // logger.debug(`getGroupIdsForEligibilityId ${query}`)
+  const result = await connection.queryAsync(query)
+  return result
 }
 
 /**
- * @param {Object} connection
- * @param {Number} eligibilityId
- * @param {Number} groupLegacyId
- * @returns {Object} DB Result
+ * Gets the eligibility IDs
+ * @param {Object} connection the connection
+ * @param {Number} challengeLegacyId the legacy challenge ID
  */
-async function groupEligbilityExists (connection, eligibilityId, groupLegacyId) {
-  // logger.debug(`groupEligibiltyExists query ${util.format(QUERY_GET_GROUP_ELIGIBILITY_ID, eligibilityId, groupLegacyId)}`)
-  const result = await connection.queryAsync(util.format(QUERY_GET_GROUP_ELIGIBILITY_ID, eligibilityId, groupLegacyId))
-  // logger.debug(`groupEligibiltyExists result ${JSON.stringify(result)} ${JSON.stringify(result[0])}`)
-  return (result && result[0]) || false
+async function getChallengeEligibilityIds (connection, challengeLegacyId) {
+  const query = util.format(QUERY_GET_CONTEST_ELIGIBILITIES_IDS, challengeLegacyId)
+  // logger.debug(`getGroupIdsForEligibilityId ${query}`)
+  const result = await connection.queryAsync(query)
+  return _.map(result, r => r.contest_eligibility_id)
 }
 
-async function createChallengeEligibilityRecord (connection, challengeLegacyId) {
+/**
+ * Create a contest eligibility
+ * @param {Object} connection the connection
+ * @param {Number} legacyChallengeId the legacy challenge ID
+ */
+async function createContestEligibility (connection, legacyChallengeId) {
   const query = await prepare(connection, QUERY_INSERT_CONTEST_ELIGIBILITY)
-  const result = await query.executeAsync([challengeLegacyId])
-  if (result) {
-    const idResult = await connection.queryAsync(util.format(QUERY_GET_ELIGIBILITY_ID, challengeLegacyId))
-    return idResult[0].contest_eligibility_id
-  }
-  return false
+  await query.executeAsync([legacyChallengeId])
+  const ids = await getChallengeEligibilityIds(connection, legacyChallengeId)
+  const groups = await getGroupsForEligibilityIds(connection, ids)
+  return _.get(_.filter(ids, id => !_.find(groups, g => g.contest_eligibility_id === id)), '[0]')
 }
 
-async function createGroupEligibilityRecord (connection, eligibilityId, groupLegacyId) {
+/**
+ * Create group contest eligibility
+ * @param {Object} connection the connection
+ * @param {Number} eligibilityId the eligibility ID
+ * @param {Number} groupId the group ID
+ */
+async function createGroupContestEligibility (connection, eligibilityId, groupId) {
   const query = await prepare(connection, QUERY_INSERT_GROUP_CONTEST_ELIGIBILITY)
-  const result = await query.executeAsync([eligibilityId, groupLegacyId])
-  if (result) {
-    const idResult = await connection.queryAsync(util.format(QUERY_GET_GROUP_ELIGIBILITY_ID, eligibilityId, groupLegacyId))
-    return idResult[0]
-  }
-  return result
-}
-
-async function deleteGroupEligibilityRecord (connection, eligibilityId, groupLegacyId) {
-  const query = await prepare(connection, QUERY_DELETE_GROUP_CONTEST_ELIGIBILITY)
-  const result = await query.executeAsync([eligibilityId, groupLegacyId])
-  // logger.debug(`deleteGroupEligibilityRecord ${JSON.stringify(result)}`)
-  return result
+  return await query.executeAsync([eligibilityId, groupId])
 }
 
-async function deleteEligibilityRecord (connection, eligibilityId) {
-  const query = await prepare(connection, QUERY_DELETE_CONTEST_ELIGIBILITY)
-  // logger.debug(`deleteEligibilityRecord Query ${JSON.stringify(query)}`)
-  const result = await query.executeAsync([eligibilityId])
-  // logger.debug(`deleteEligibilityRecord ${JSON.stringify(result)}`)
-  return result
-}
-
-async function getCountOfGroupsInEligibilityRecord (connection, eligibilityId) {
-  const query = util.format(QUERY_GET_GROUPS_COUNT, eligibilityId)
-  // logger.debug(`Query! ${query}`)
-  const result = await connection.queryAsync(query)
-  // logger.debug(`getCountOfGroupsInEligibilityRecord ${JSON.stringify(result)}`)
-  return { groupsCount: result[0].cnt || 0 }
-}
+/**
+ * Removes entries from group_contest_eligibility and contest_eligibility
+ * @param {Object} connection the connection
+ * @param {Number} eligibilityId the eligibility ID
+ * @param {Number} groupId the group ID
+ */
+async function clearData (connection, eligibilityId, groupId) {
+  let query
+  query = await prepare(connection, QUERY_DELETE_GROUP_CONTEST_ELIGIBILITY)
+  await query.executeAsync([eligibilityId, groupId])
 
-async function getGroupIdsForEligibilityId (connection, eligibilityId) {
-  const query = util.format(QUERY_GET_GROUPS, eligibilityId)
-  // logger.debug(`getGroupIdsForEligibilityId ${query}`)
-  const result = await connection.queryAsync(query)
-  return _.map(result, r => r.group_id)
+  query = await prepare(connection, QUERY_DELETE_CONTEST_ELIGIBILITY)
+  await query.executeAsync([eligibilityId])
 }
 
 module.exports = {