Skip to content
This repository has been archived by the owner on Jan 23, 2025. It is now read-only.

Commit

Permalink
Merge branch 'develop'
Browse files Browse the repository at this point in the history
  • Loading branch information
James Cori committed Jan 6, 2021
2 parents 7c75639 + ad03fb4 commit 674b430
Show file tree
Hide file tree
Showing 3 changed files with 86 additions and 98 deletions.
3 changes: 2 additions & 1 deletion src/services/ProcessorService.js
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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) {
Expand Down
180 changes: 84 additions & 96 deletions src/services/groupsService.js
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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 = ?'

Expand All @@ -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}`)
Expand All @@ -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`)
Expand All @@ -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 = {
Expand Down
1 change: 0 additions & 1 deletion src/services/termsService.js
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down

0 comments on commit 674b430

Please sign in to comment.