Merge pull request #377 from Real-Dev-Squad/FeatureFlags

Issue #376  Define CRUD operation for feature flag

Author: Cartmanishere

controllers/featureFlags.js

@@ -0,0 +1,90 @@
+const featureFlagQuery = require('../models/featureFlags')
+
+/**
+ * Fetches all the featureFlag
+ *
+ * @param req {Object} - Express request object
+ * @param res {Object} - Express response object
+ */
+
+const getFeatureFlags = async (req, res) => {
+  try {
+    const allFeatureFlags = await featureFlagQuery.fetchFeatureFlag()
+    return res.json({
+      message: 'FeatureFlags returned successfully!',
+      featureflags: allFeatureFlags.length > 0 ? allFeatureFlags : []
+    })
+  } catch (err) {
+    logger.error(`Error while fetching tasks ${err}`)
+    return res.boom.badImplementation('An internal server error occurred')
+  }
+}
+
+/**
+ * Posts the data of the featureFlag
+ *
+ * @param req {Object} - Express request object
+ * @param res {Object} - Express response object
+ */
+
+const addFeatureFlag = async (req, res) => {
+  try {
+    const featureFlag = await featureFlagQuery.addFeatureFlags(req.body, req.userData.username)
+    return res.json({
+      message: 'FeatureFlag added successfully!',
+      data: featureFlag
+    })
+  } catch (err) {
+    logger.error(`Error while adding featureFlag info: ${err}`)
+    return res.boom.badImplementation('Something went wrong please contact admin')
+  }
+}
+
+/**
+ * Update the data of the featureFlag
+ *
+ * @param req {Object} - Express request object
+ * @param res {Object} - Express response object
+ */
+
+const updateFeatureFlag = async (req, res) => {
+  try {
+    const result = await featureFlagQuery.updateFeatureFlags(req.body, req.params.id)
+    if (result.isUpdated) {
+      return res.status(204).send()
+    }
+    return res.boom.notFound('FeatureFlag doesn\'t exist')
+  } catch (err) {
+    logger.error(`Error while updating featureFlag info: ${err}`)
+    return res.boom.badImplementation('Something went wrong please contact admin')
+  }
+}
+
+/**
+ * Delete featureFlag
+ *
+ * @param req {Object} - Express request object
+ * @param res {Object} - Express response object
+ */
+
+const deleteFeatureFlag = async (req, res) => {
+  try {
+    const result = await featureFlagQuery.deleteFeatureFlag(req.params.id)
+    if (result.isDeleted) {
+      return res.json({
+        message: 'FeatureFlag deleted successfully!!'
+      })
+    }
+    return res.boom.notFound('featureFlag doesn\'t exist')
+  } catch (err) {
+    logger.error(`Error while deleting featureFlag info: ${err}`)
+    return res.boom.badImplementation('Something went wrong please contact admin')
+  }
+}
+
+module.exports = {
+  getFeatureFlags,
+  addFeatureFlag,
+  updateFeatureFlag,
+  deleteFeatureFlag
+}

docs/swaggerDefinition.js

@@ -590,6 +590,36 @@ const swaggerOptions = {
             }
           }
         },
+        featureFlag: {
+          type: 'object',
+          properties: {
+            name: {
+              type: 'string'
+            },
+            id: {
+              type: 'string'
+            },
+            title: {
+              type: 'string'
+            },
+            created_at: {
+              type: 'number'
+            },
+            updated_at: {
+              type: 'number'
+            },
+            config: {
+              type: 'object'
+            },
+            owner: {
+              type: 'string'
+            },
+            launched_at: {
+              type: 'number'
+            }
+
+          }
+        },
         errors: {
           unAuthorized: {
             type: 'object',

middlewares/validators/featureFlags.js

@@ -0,0 +1,43 @@
+const joi = require('joi')
+
+const validateFeatureFlag = async (req, res, next) => {
+  const schema = joi.object().keys({
+    name: joi.string().required(),
+    title: joi.string().required(),
+    created_at: joi.number().optional(),
+    updated_at: joi.number().optional(),
+    config: joi.object({
+      enabled: joi.boolean().required()
+    }).required(),
+    launched_at: joi.number().optional()
+  })
+
+  try {
+    await schema.validateAsync(req.body)
+    next()
+  } catch (error) {
+    logger.error(`Error in validating featureFlag data: ${error}`)
+    res.boom.badRequest(error.details[0].message)
+  }
+}
+
+const updateFeatureFlags = async (req, res, next) => {
+  const schema = joi.object().keys({
+    title: joi.string().optional(),
+    config: joi.object({
+      enabled: joi.boolean().required()
+    }).required()
+  })
+  try {
+    await schema.validateAsync(req.body)
+    next()
+  } catch (error) {
+    logger.error(`Error in validating featureFlag data: ${error}`)
+    res.boom.badRequest(error.details[0].message)
+  }
+}
+
+module.exports = {
+  validateFeatureFlag,
+  updateFeatureFlags
+}

models/featureFlags.js

@@ -0,0 +1,134 @@
+const firestore = require('../utils/firestore')
+const featureFlagModel = firestore.collection('featureFlags')
+const userModel = require('./users')
+
+/**
+ * Fetch all tasks
+ *
+ * @return {Promise<featureFlags|Array>}
+ */
+const fetchFeatureFlag = async () => {
+  try {
+    const snapshot = await featureFlagModel.get()
+    const featureFlags = []
+    snapshot.forEach((doc) => {
+      featureFlags.push({
+        id: doc.id,
+        ...doc.data()
+      })
+    })
+    const users = []
+    const result = {}
+
+    featureFlags.forEach((item) => {
+      if (!users.includes(item.owner)) { users.push(item.owner) }
+    })
+
+    let start = 0
+    let end = 10
+
+    for (let i = 0; i < Math.ceil(users.length / 10); i++) {
+      const usersData = users.slice(start, end)
+      const image = await userModel.fetchUserImage(usersData)
+      start = end
+      end += 10
+      Object.assign(result, image)
+    }
+
+    featureFlags.forEach((item) => {
+      item.owner = {
+        username: item.owner,
+        img: result[item.owner]
+      }
+    })
+    return featureFlags
+  } catch (err) {
+    logger.error('error getting featureFlags', err)
+    throw err
+  }
+}
+
+/**
+ * Add the feature flag data
+ *
+ * @param featureFlagData { Object }: featureFlag data object to be stored in DB
+ * @param username { String }: Username String to be used to add owner in feature flag object
+ * @return {Promise<{featureFlagData:object}>}
+ */
+const addFeatureFlags = async (featureFlag, username) => {
+  try {
+    featureFlag.created_at = Date.now()
+    featureFlag.updated_at = featureFlag.created_at
+    featureFlag.owner = username
+    const { id } = await featureFlagModel.add(featureFlag)
+    const featureFlagData = (await featureFlagModel.doc(id).get()).data()
+    featureFlagData.id = id
+    return featureFlagData
+  } catch (err) {
+    logger.error('Error in adding featureFlag', err)
+    throw err
+  }
+}
+
+/**
+ * Adds or updates the feature flag data
+ *
+ * @param featureFlag { Object }: feature flag data object to be stored in DB
+ * @param featureFlagId { String }: feature flag Id String to be used to update the feature Flag
+ * @return {Promise<{isUpdated: boolean}>}
+ */
+const updateFeatureFlags = async (featureFlag, featureFlagId) => {
+  try {
+    const doc = await featureFlagModel.doc(featureFlagId).get()
+    if (!doc.data()) {
+      return {
+        isUpdated: false
+      }
+    }
+    if (doc.data()) {
+      featureFlag.updated_at = Date.now()
+      featureFlag.launched_at = Date.now()
+      await featureFlagModel.doc(featureFlagId).set({
+        ...doc.data(),
+        ...featureFlag
+      })
+    }
+    return {
+      isUpdated: true
+    }
+  } catch (err) {
+    logger.error('Error in updating featureFlag', err)
+    throw err
+  }
+}
+
+/**
+ * Delete the feature flag data
+ *
+ * @param featureFlagId { String }: feature flag Id String to be used to delete the feature Flag
+ * @return {Promise<{isDeleted: boolean}>}
+ */
+const deleteFeatureFlag = async (featureFlagId) => {
+  try {
+    const doc = await featureFlagModel.doc(featureFlagId).get()
+    if (!doc.exists) {
+      return {
+        isDeleted: false
+      }
+    }
+    await featureFlagModel.doc(featureFlagId).delete()
+    return {
+      isDeleted: true
+    }
+  } catch (err) {
+    logger.error('Error in deleting featureFlag', err)
+    throw err
+  }
+}
+
+module.exports = {
+  fetchFeatureFlag,
+  addFeatureFlags,
+  updateFeatureFlags,
+  deleteFeatureFlag
+}

models/users.js

@@ -167,11 +167,26 @@ const updateUserPicture = async (image, userId) => {
   }
 }
 
+/**
+ * fetch the users image by passing array of users
+ *
+ * @param users {array}
+ */
+const fetchUserImage = async (users) => {
+  const data = await userModel.where('username', 'in', users).get()
+  const images = {}
+  data.forEach((item) => {
+    images[item.data().username] = item.data().img
+  })
+  return images
+}
+
 module.exports = {
   addOrUpdate,
   fetchUsers,
   fetchUser,
   setIncompleteUserDetails,
   initializeUser,
-  updateUserPicture
+  updateUserPicture,
+  fetchUserImage
 }