refactoring and announcementtype API issue

src/app/helpers/announcement/controller.js

@@ -269,11 +269,12 @@ class AnnouncementController {
  __getAnnouncementTypes(requestObj) {
  return new Promise((resolve, reject) => {
  let query = {
- table: 'announcement',
+ table: 'announcementtype',
  query: {
  'rootorgid': _.get(requestObj, 'body.request.rootorgid')
  }
  }
+
  this.objectStoreRest.findObject(query)
  .then((data) => {
  if (!_.isObject(data)) {

src/app/helpers/announcement/index.js

@@ -5,49 +5,39 @@ let controller = require('./controller.js')
 let metricsModel = require('./model/MetricsModel.js')
 let announcementCreateModel = require('./model/AnnouncementCreateModel.js')
 let announcementTypeModel = require('./model/AnnouncementTypeModel.js')
-const API_ID = 'api.plugin.announcement'
 let path = require('path')
 let multer = require('multer')
 const _ = require('lodash')
 let await = require('asyncawait/await')
 let async = require('asyncawait/async')
 const CREATE_ROLE = 'ANNOUNCEMENT_SENDER'
+const API_ID_BASE = 'api.plugin.announcement'
+const API_IDS = {
+ create: 'create',
+ getbyid: 'get.id',
+ cancel: 'cancel',
+ userinbox: 'user.inbox',
+ useroutbox: 'user.outbox',
+ definitions: 'definitions',
+ received: 'received',
+ read: 'read',
+ getresend: 'getresend.id',
+ resend: 'resend'
+}
 
 let announcementController = new controller({
  metrics: metricsModel,
  announcement: announcementCreateModel,
  announcementtype: announcementTypeModel
 })
-/*
-for file upload
-*/
-const maxUploadFileSize = 1000000 // in bytes, 1MB
-const AllowableUploadFileTypes = /jpeg|jpg|png|pdf/ // images/pdf
-let storage = multer.memoryStorage()
-let upload = multer({
- storage: storage,
- limits: {
- fileSize: maxUploadFileSize
- },
- fileFilter: uploadFileFilter
-})
-let singleFileUpload = upload.single('document')
 
-function uploadFileFilter(req, file, cb) {
- var mimetype = AllowableUploadFileTypes.test(file.mimetype)
- var extname = AllowableUploadFileTypes.test(path.extname(file.originalname).toLowerCase())
- if (mimetype && extname) return cb(null, true)
- cb({
- msg: 'File upload only supports the following filetypes-' + AllowableUploadFileTypes,
- code: 'INVALID_FILETYPE'
- })
-}
+const API_VERSION = '1.0'
 
 function sendSuccessResponse(res, id, result, code = HttpStatus.OK) {
  res.status(code)
  res.send({
- 'id': API_ID + '.' + id,
- 'ver': '1.0',
+ 'id': API_ID_BASE + '.' + id,
+ 'ver': API_VERSION,
  'ts': dateFormat(new Date(), 'yyyy-mm-dd HH:MM:ss:lo'),
  'params': {
  'resmsgid': uuidv1(),
@@ -65,8 +55,8 @@ function sendSuccessResponse(res, id, result, code = HttpStatus.OK) {
 function sendErrorResponse(res, id, message, code = HttpStatus.BAD_REQUEST) {
  res.status(code)
  res.send({
- 'id': API_ID + '.' + id,
- 'ver': '1.0',
+ 'id': API_ID_BASE + '.' + id,
+ 'ver': API_VERSION,
  'ts': dateFormat(new Date(), 'yyyy-mm-dd HH:MM:ss:lo'),
  'params': {
  'resmsgid': uuidv1(),
@@ -83,6 +73,7 @@ function sendErrorResponse(res, id, message, code = HttpStatus.BAD_REQUEST) {
 
 function isCreateRolePresent(userProfile, sourceid) {
  let organisationId = _.map(userProfile.organisations, "organisationId")
+ // console.log(userProfile.organisations)
  let organisation = undefined;
  for (var i = 0; i <= organisationId.length; i++) {
  if (organisationId[i]) {
@@ -102,7 +93,6 @@ function validateRoles() {
  return async((requestObj, responseObj, next, config) => {
  let authUserToken = _.get(requestObj, 'kauth.grant.access_token.token') || _.get(requestObj, "headers['x-authenticated-user-token']")
  try {
- // TODO: verify Is logged in userid matching with senderid
  let userProfile = await (announcementController.__getUserProfile({
  id: config.userid
  }, authUserToken))
@@ -114,175 +104,188 @@ function validateRoles() {
  }
  } catch (error) {
  if (error === 'USER_NOT_FOUND') {
- sendErrorResponse(responseObj, '', "USER_NOT_FOUND", 401)
- } else if (error === 'UNAUTHORIZE_USER') {
- sendErrorResponse(responseObj, '', "UNAUTHORIZE_USER", 401)
+ sendErrorResponse(responseObj, config.apiid, "USER_NOT_FOUND", HttpStatus.BAD_REQUEST)
+ } else if (error === 'UNAUTHORIZED_USER') {
+ sendErrorResponse(responseObj, config.apiid, "UNAUTHORIZED_USER", HttpStatus.UNAUTHORIZED)
  } else {
- sendErrorResponse(responseObj, '', "UNAUTHORIZE_USER", 401)
+ sendErrorResponse(responseObj, config.apiid, "UNAUTHORIZED_USER", HttpStatus.UNAUTHORIZED)
  }
  }
  })
 }
 
 function validate() {
- return async((requestObj, responseObj, next, keycloak) => {
+ return async((requestObj, responseObj, next, keycloak, config) => {
  let authUserToken = _.get(requestObj, "headers['x-authenticated-user-token']")
  if (authUserToken) {
  var tokenDetails = await (announcementController.__getTokenDetails(authUserToken))
  if (tokenDetails) {
  next()
  } else {
- sendErrorResponse(responseObj, '', "UNAUTHORIZE_USER", 401)
+ sendErrorResponse(responseObj, config.apiid, "UNAUTHORIZED_USER", HttpStatus.UNAUTHORIZED)
  }
  } else {
- if (keycloak) {
+ if (!keycloak) {
  keycloak.protect()(requestObj, responseObj, next)
  } else {
- sendErrorResponse(responseObj, '', "UNAUTHORIZE_USER", 401)
+ sendErrorResponse(responseObj, config.apiid, "UNAUTHORIZED_USER", HttpStatus.UNAUTHORIZED)
  }
  }
  });
 }
 
 module.exports = function(keycloak) {
  router.post('/create', (requestObj, responseObj, next) => {
- validate()(requestObj, responseObj, next, keycloak)
+ let config = {apiid: API_IDS.create}
+ validate()(requestObj, responseObj, next, keycloak, config)
  }, (requestObj, responseObj, next) => {
  let config = {
  userid: _.get(requestObj, 'body.request.createdBy'),
- sourceid: _.get(requestObj, 'body.request.sourceId')
+ sourceid: _.get(requestObj, 'body.request.sourceId'),
+ apiid: API_IDS.create
  }
  validateRoles()(requestObj, responseObj, next, config)
  }, (requestObj, responseObj, next) => {
  announcementController.create(requestObj)
  .then((data) => {
- sendSuccessResponse(responseObj, 'create', data, HttpStatus.CREATED)
+ sendSuccessResponse(responseObj, API_IDS.create, data, HttpStatus.CREATED)
  })
  .catch((err) => {
- sendErrorResponse(responseObj, 'create', err.msg, err.statusCode)
+ sendErrorResponse(responseObj, API_IDS.create, err.msg, err.statusCode)
  })
  })
 
  router.get('/get/:id', (requestObj, responseObj, next) => {
  announcementController.getAnnouncementById(requestObj)
  .then((data) => {
- sendSuccessResponse(responseObj, 'get.id', data, HttpStatus.OK)
+ sendSuccessResponse(responseObj, API_IDS.getbyid, data, HttpStatus.OK)
  })
  .catch((err) => {
- sendErrorResponse(responseObj, 'get.id', err.msg, err.statusCode)
+ sendErrorResponse(responseObj, API_IDS.getbyid, err.msg, err.statusCode)
  })
  })
 
  router.delete('/cancel', (requestObj, responseObj, next) => {
- validate()(requestObj, responseObj, next, keycloak)
+ let config = {apiid: API_IDS.cancel}
+ validate()(requestObj, responseObj, next, keycloak, config)
  }, (requestObj, responseObj, next) => {
  let config = {
- userid: _.get(requestObj, 'body.request.userid')
+ userid: _.get(requestObj, 'body.request.userid'),
+ apiid: API_IDS.cancel
  }
  validateRoles()(requestObj, responseObj, next, config)
  }, (requestObj, responseObj, next) => {
  announcementController.cancelAnnouncementById(requestObj)
  .then((data) => {
- sendSuccessResponse(responseObj, 'cancel.id', data, HttpStatus.OK)
+ sendSuccessResponse(responseObj, API_IDS.cancel, data, HttpStatus.OK)
  })
  .catch((err) => {
- sendErrorResponse(responseObj, 'cancel.id', err.msg, err.statusCode)
+ sendErrorResponse(responseObj, API_IDS.cancel, err.msg, err.statusCode)
  })
  })
 
  router.post('/user/inbox', (requestObj, responseObj, next) => {
- validate()(requestObj, responseObj, next, keycloak)
+ let config = {apiid: API_IDS.userinbox}
+ validate()(requestObj, responseObj, next, keycloak, config)
  }, (requestObj, responseObj, next) => {
  announcementController.getUserInbox(requestObj)
  .then((data) => {
- sendSuccessResponse(responseObj, 'user.inbox', data, HttpStatus.OK)
+ sendSuccessResponse(responseObj, API_IDS.userinbox, data, HttpStatus.OK)
  })
  .catch((err) => {
- sendErrorResponse(responseObj, 'user.inbox', err.msg, err.statusCode)
+ sendErrorResponse(responseObj, API_IDS.userinbox, err.msg, err.statusCode)
  })
  })
 
  router.post('/user/outbox', (requestObj, responseObj, next) => {
- validate()(requestObj, responseObj, next, keycloak)
+ let config = {apiid: API_IDS.useroutbox}
+ validate()(requestObj, responseObj, next, keycloak, config)
  }, (requestObj, responseObj, next) => {
  announcementController.getUserOutbox(requestObj)
  .then((data) => {
- sendSuccessResponse(responseObj, 'user.outbox', data, HttpStatus.OK)
+ sendSuccessResponse(responseObj, API_IDS.useroutbox, data, HttpStatus.OK)
  })
  .catch((err) => {
- sendErrorResponse(responseObj, 'user.outbox', err.msg, err.statusCode)
+ sendErrorResponse(responseObj, API_IDS.useroutbox, err.msg, err.statusCode)
  })
  })
 
  router.post('/definitions', (requestObj, responseObj, next) => {
- validate()(requestObj, responseObj, next, keycloak)
+ let config = {apiid: API_IDS.definitions}
+ validate()(requestObj, responseObj, next, keycloak, config)
  }, (requestObj, responseObj, next) => {
  let config = {
- userid: _.get(requestObj, 'body.request.userid')
+ userid: _.get(requestObj, 'body.request.userid'),
+ apiid: API_IDS.definitions
  }
  validateRoles()(requestObj, responseObj, next, config)
  }, (requestObj, responseObj, next) => {
  announcementController.getDefinitions(requestObj)
  .then((data) => {
- sendSuccessResponse(responseObj, 'definitions', data, HttpStatus.OK)
+ sendSuccessResponse(responseObj, API_IDS.definitions, data, HttpStatus.OK)
  })
  .catch((err) => {
- sendErrorResponse(responseObj, 'definitions', err.msg, err.statusCode)
+ sendErrorResponse(responseObj, API_IDS.definitions, err.msg, err.statusCode)
  })
  })
 
  router.post('/received', (requestObj, responseObj, next) => {
- validate()(requestObj, responseObj, next, keycloak)
+ let config = {apiid: API_IDS.received}
+ validate()(requestObj, responseObj, next, keycloak, config)
  }, (requestObj, responseObj, next) => {
  announcementController.received(requestObj)
  .then((data) => {
- sendSuccessResponse(responseObj, 'received', data, HttpStatus.CREATED)
+ sendSuccessResponse(responseObj, API_IDS.received, data, HttpStatus.CREATED)
  })
  .catch((err) => {
- sendErrorResponse(responseObj, 'received', err.msg, err.statusCode)
+ sendErrorResponse(responseObj, API_IDS.received, err.msg, err.statusCode)
  })
  })
 
  router.post('/read', (requestObj, responseObj, next) => {
- validate()(requestObj, responseObj, next, keycloak)
+ let config = {apiid: API_IDS.read}
+ validate()(requestObj, responseObj, next, keycloak, config)
  }, (requestObj, responseObj, next) => {
  announcementController.read(requestObj)
  .then((data) => {
- sendSuccessResponse(responseObj, 'read', data, HttpStatus.CREATED)
+ sendSuccessResponse(responseObj, API_IDS.read, data, HttpStatus.CREATED)
  })
  .catch((err) => {
- sendErrorResponse(responseObj, 'read', err.msg, err.statusCode)
+ sendErrorResponse(responseObj, API_IDS.read, err.msg, err.statusCode)
  })
  })
 
  router.get('/resend/:announcementId', (requestObj, responseObj, next) => {
- validate()(requestObj, responseObj, next, keycloak)
+ let config = {apiid: API_IDS.getresend}
+ validate()(requestObj, responseObj, next, keycloak, config)
  }, (requestObj, responseObj, next) => {
  announcementController.getResend()(requestObj)
  .then((data) => {
- sendSuccessResponse(responseObj, 'getresend.id', data, HttpStatus.OK)
+ sendSuccessResponse(responseObj, API_IDS.getresend, data, HttpStatus.OK)
  })
  .catch((err) => {
- sendErrorResponse(responseObj, 'getresend.id', err.msg, err.statusCode)
+ sendErrorResponse(responseObj, API_IDS.getresend, err.msg, err.statusCode)
  })
 
 
  })
 
  router.post('/resend', (requestObj, responseObj, next) => {
- validate()(requestObj, responseObj, next, keycloak)
+ let config = {apiid: API_IDS.resend}
+ validate()(requestObj, responseObj, next, keycloak, config)
  }, (requestObj, responseObj, next) => {
  let config = {
- userid: _.get(requestObj, 'body.request.createdBy')
+ userid: _.get(requestObj, 'body.request.createdBy'),
+ apiid: API_IDS.resend
  }
  validateRoles()(requestObj, responseObj, next, config)
  }, (requestObj, responseObj, next) => {
  announcementController.resend(requestObj)
  .then((data) => {
- sendSuccessResponse(responseObj, 'resend', data, HttpStatus.CREATED)
+ sendSuccessResponse(responseObj, API_IDS.resend, data, HttpStatus.CREATED)
  })
  .catch((err) => {
- sendErrorResponse(responseObj, 'resend', err.msg, err.statusCode)
+ sendErrorResponse(responseObj, API_IDS.resend, err.msg, err.statusCode)
  })
  })