Merge branch 'develop'

Author: James Cori

src/services/ProcessorService.js

@@ -402,7 +402,8 @@ async function processCreate (message) {
 
   logger.debug('processCreate :: beforeTry')
   try {
-    const newChallenge = await helper.postRequest(`${config.V4_CHALLENGE_API_URL}`, { param: _.omit(saveDraftContestDTO, ['groupsToBeAdded', 'groupsToBeDeleted']) }, m2mToken)
+    logger.info(`processCreate :: Skip Forums - ${config.V4_CHALLENGE_API_URL}?filter=skipForum=true body: ${JSON.stringify({ param: _.omit(saveDraftContestDTO, ['groupsToBeAdded', 'groupsToBeDeleted']) })}`)
+    const newChallenge = await helper.postRequest(`${config.V4_CHALLENGE_API_URL}?filter=skipForum=true`, { param: _.omit(saveDraftContestDTO, ['groupsToBeAdded', 'groupsToBeDeleted']) }, m2mToken)
 
     let forumId = 0
     if (message.payload.legacy && message.payload.legacy.forumId) {

src/services/groupsService.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 = {

src/services/termsService.js

@@ -4,7 +4,6 @@ const util = require('util')
 const config = require('config')
 const helper = require('../common/helper')
 
-
 const QUERY_GET_CHALLENGE_TERMS = 'SELECT resource_role_id, terms_of_use_id FROM project_role_terms_of_use_xref WHERE project_id = %d'
 const QUERY_INSERT_CHALLENGE_TERMS = `INSERT INTO project_role_terms_of_use_xref
   (project_id, resource_role_id, terms_of_use_id, create_date, modify_date, sort_order, group_ind)