handling of adding/removing prizes

Author: ThomasKranitsas

src/common/idGenerator.js

@@ -0,0 +1,102 @@
+/**
+ * The ID generator service
+ */
+const util = require('util')
+const Mutex = require('async-mutex').Mutex
+const logger = require('./logger')
+const helper = require('./helper')
+
+/**
+ * Main class of IDGenerator
+ */
+class IDGenerator {
+  /**
+   * Constructor
+   * @param {Informix} db database
+   * @param {String} seqName sequence name
+   */
+  constructor (seqName) {
+    this.seqName = seqName
+    this._availableId = 0
+    this.mutex = new Mutex()
+  }
+
+  /**
+   * Get next id
+   * @returns {Number} next id
+   */
+  async getNextId () {
+    const release = await this.mutex.acquire()
+    try {
+      logger.debug('Getting nextId')
+      --this._availableId
+      logger.debug(`this._availableId = ${this._availableId}`)
+
+      if (this._availableId <= 0) {
+        const connection = await helper.getInformixConnection()
+        try {
+          // begin transaction
+          await connection.beginTransactionAsync()
+
+          const [nextId, availableId] = await this.getNextBlock(connection)
+          await this.updateNextBlock(connection, nextId + availableId + 1)
+
+          // commit the transaction
+          await connection.commitTransactionAsync()
+
+          // Only set to this's properties after successful commit
+          this._nextId = nextId
+          this._availableId = availableId
+        } catch (e) {
+          await connection.rollbackTransactionAsync()
+          throw e
+        } finally {
+          await connection.closeAsync()
+        }
+      }
+
+      logger.debug(`this._availableId = ${this._availableId}`)
+      return ++this._nextId
+    } finally {
+      release()
+    }
+  }
+
+  /**
+   * Fetch next block from id_sequence
+   * @param {Object} connection the Informix connection
+   * @returns {Array} [nextId, availableId]
+   * @private
+   */
+  async getNextBlock (connection) {
+    try {
+      const result = await connection.queryAsync(`select next_block_start, block_size from id_sequences where name = '${this.seqName}'`)
+      if (result.length > 0) {
+        return [Number(result[0].next_block_start) - 1, Number(result[0].block_size)]
+      } else {
+        throw new Error(`null or empty result for ${this.seqName}`)
+      }
+    } catch (e) {
+      logger.error(util.inspect(e))
+      throw e
+    }
+  }
+
+  /**
+   * Update id_sequence
+   * @param {Object} connection the Informix connection
+   * @param {Number} nextStart next start id
+   * @private
+   */
+  async updateNextBlock (connection, nextStart) {
+    try {
+      await connection.queryAsync(`update id_sequences set next_block_start = ${nextStart} where name = '${this.seqName}'`)
+    } catch (e) {
+      logger.error('Failed to update id sequence: ' + this.seqName)
+      logger.error(util.inspect(e))
+      throw e
+    }
+  }
+}
+
+module.exports = IDGenerator

src/services/ProcessorService.js

@@ -44,16 +44,17 @@ async function syncChallengePhases (legacyId, v5Phases) {
       }
     }
   }
+  // TODO: What about iterative reviews? There can be many for the same challenge.
+  // TODO: handle timeline template updates
 }
 
 /**
  * Update the payments from v5 prize sets into legacy
- * @param {Array} v4Prizes the v4 prizes
- * @param {Number} v4NumOfCheckpointPrizes the number of checkpoints (v4)
- * @param {Number} v4CheckpointPrize the dollar ammount of each checkpoint prize (v4)
+ * @param {Number} legacyId the legacy challenge ID
  * @param {Array} v5PrizeSets the v5 prize sets
+ * @param {String} createdBy the created by
  */
-async function updateMemberPayments (legacyId, v5PrizeSets) {
+async function updateMemberPayments (legacyId, v5PrizeSets, createdBy) {
   const prizesFromIfx = await paymentService.getChallengePrizes(legacyId, constants.prizeTypesIds.Contest)
   const [checkpointPrizesFromIfx] = await paymentService.getChallengePrizes(legacyId, constants.prizeTypesIds.Checkpoint)
   const v5Prizes = _.map(_.get(_.find(v5PrizeSets, p => p.type === constants.prizeSetTypes.ChallengePrizes), 'prizes', []), prize => prize.value)
@@ -67,6 +68,14 @@ async function updateMemberPayments (legacyId, v5PrizeSets) {
         if (_.toInteger(ifxPrize.prize_amount) !== v5Prizes[i]) {
           await paymentService.updatePrize(ifxPrize.prize_id, legacyId, v5Prizes[i], 1)
         }
+      } else {
+        await paymentService.createPrize(legacyId, i + 1, v5Prizes[i], constants.prizeTypesIds.Contest, 1, createdBy)
+      }
+    }
+    if (prizesFromIfx.length > v5Prizes.length) {
+      const prizesToDelete = _.filter(prizesFromIfx, p => p.place > v5Prizes.length)
+      for (const prizeToDelete of prizesToDelete) {
+        await paymentService.deletePrize(legacyId, prizeToDelete.prize_id)
       }
     }
   }
@@ -76,6 +85,8 @@ async function updateMemberPayments (legacyId, v5PrizeSets) {
     if (v5CheckPointPrizes.length !== checkpointPrizesFromIfx.number_of_submissions || v5CheckPointPrizes[0] !== _.toInteger(checkpointPrizesFromIfx.prize_amount)) {
       await paymentService.updatePrize(checkpointPrizesFromIfx.prize_id, legacyId, v5CheckPointPrizes[0], v5CheckPointPrizes.length)
     }
+  } else if (checkpointPrizesFromIfx) {
+    await paymentService.deletePrize(legacyId, checkpointPrizesFromIfx.prize_id)
   }
 }
 
@@ -580,7 +591,7 @@ async function processUpdate (message) {
 
     // Direct IFX modifications
     await syncChallengePhases(message.payload.legacyId, message.payload.phases)
-    await updateMemberPayments(message.payload.legacyId, message.payload.prizeSets)
+    await updateMemberPayments(message.payload.legacyId, message.payload.prizeSets, _.get(message, 'payload.updatedBy') || _.get(message, 'payload.createdBy'))
     await associateChallengeGroups(saveDraftContestDTO.groupsToBeAdded, saveDraftContestDTO.groupsToBeDeleted, message.payload.legacyId)
     await associateChallengeTerms(message.payload.terms, message.payload.legacyId)
     await setCopilotPayment(message.payload.legacyId, _.get(message, 'payload.prizeSets'), _.get(message, 'payload.createdBy'), _.get(message, 'payload.updatedBy'))

src/services/paymentService.js

@@ -5,9 +5,14 @@
 const logger = require('../common/logger')
 const util = require('util')
 const helper = require('../common/helper')
+const IDGenerator = require('../common/idGenerator')
+
+const prizeIdGen = new IDGenerator('prize_id_seq')
 
 const QUERY_GET_CHALLENGE_PRIZES = 'SELECT prize_id, place, prize_amount, number_of_submissions FROM prize WHERE prize_type_id = %d and project_id = %d'
 const QUERY_UPDATE_CHALLENGE_PRIZE = 'UPDATE prize SET prize_amount = ?, number_of_submissions = ? WHERE prize_id = %d and project_id = %d'
+const QUERY_CREATE_CHALLENGE_PRIZE = 'INSERT INTO prize (prize_id, project_id, place, prize_amount, prize_type_id, number_of_submissions, create_user, create_date, modify_user, modify_date) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'
+const QUERY_DELETE_CHALLENGE_PRIZE = 'DELETE FROM prize WHERE prize_id = %d and project_id = %d'
 
 /**
  * Prepare Informix statement
@@ -60,13 +65,70 @@ async function updatePrize (prizeId, challengeLegacyId, prizeAmount, numberOfSub
     await connection.rollbackTransactionAsync()
     throw e
   } finally {
-    logger.info(`Phase ${prizeId} has been updated`)
+    logger.info(`Prize ${prizeId} has been updated`)
+    await connection.closeAsync()
+  }
+  return result
+}
+
+/**
+ * Creates a new prize in IFX
+ * @param {Number} challengeLegacyId the legacy challenge ID
+ * @param {Number} place the placement
+ * @param {Number} prizeAmount the prize amount
+ * @param {Number} prizeTypeId the prize type ID
+ * @param {Number} numberOfSubmissions the number of submissions that will receive the prize
+ * @param {String} createdBy the creator user
+ */
+async function createPrize (challengeLegacyId, place, prizeAmount, prizeTypeId, numberOfSubmissions, createdBy) {
+  const connection = await helper.getInformixConnection()
+  let result = null
+  let prizeId
+  try {
+    // await connection.beginTransactionAsync()
+    prizeId = await prizeIdGen.getNextId()
+    const currentDateIso = new Date().toISOString().replace('T', ' ').replace('Z', '').split('.')[0]
+    const query = await prepare(connection, QUERY_CREATE_CHALLENGE_PRIZE)
+    result = await query.executeAsync([prizeId, challengeLegacyId, place, prizeAmount, prizeTypeId, numberOfSubmissions, createdBy, currentDateIso, createdBy, currentDateIso])
+    // await connection.commitTransactionAsync()
+  } catch (e) {
+    logger.error(`Error in 'createPrize' ${e}, rolling back transaction`)
+    await connection.rollbackTransactionAsync()
+    throw e
+  } finally {
+    logger.info(`Prize ${prizeId} has been updated`)
+    await connection.closeAsync()
+  }
+  return result
+}
+
+/**
+ * Deletes a prize from IFX
+ * @param {Number} challengeLegacyId the legacy challenge ID
+ * @param {Number} prizeId the prize ID
+ */
+async function deletePrize (challengeLegacyId, prizeId) {
+  const connection = await helper.getInformixConnection()
+  let result = null
+  try {
+    // await connection.beginTransactionAsync()
+    const query = await prepare(connection, QUERY_DELETE_CHALLENGE_PRIZE)
+    result = await query.executeAsync([prizeId, challengeLegacyId])
+    // await connection.commitTransactionAsync()
+  } catch (e) {
+    logger.error(`Error in 'deletePrize' ${e}, rolling back transaction`)
+    await connection.rollbackTransactionAsync()
+    throw e
+  } finally {
+    logger.info(`Prize ${prizeId} has been deleted`)
     await connection.closeAsync()
   }
   return result
 }
 
 module.exports = {
   getChallengePrizes,
-  updatePrize
+  updatePrize,
+  createPrize,
+  deletePrize
 }