Merge pull request #21 from alastria/develop

Develop
alastria · Jun 15, 2020 · 8d4d3f7 · 8d4d3f7
2 parents 01fe06f + 72b2c30
commit 8d4d3f7
Show file tree

Hide file tree

Showing 16 changed files with 496 additions and 229 deletions.
diff --git a/entityBackend/api/controllers/entity.controller.js b/entityBackend/api/controllers/entity.controller.js
@@ -1,4 +1,4 @@
-'use strict';
+'use strict'
 
 /////////////////////////////////////////////////////////
 ///////                 constants                 ///////
@@ -245,10 +245,7 @@ function createCredential(req, res) {
   entityService.createCredential(identityDID, credentials)
   .then(credential => {
     log.info(`${controller_name}[${createCredential.name}] -----> Credentials created`)
-    let credentialToken = {
-      verifiableCredential: credential
-    }
-    res.status(200).send(credentialToken)
+    res.status(200).send(credential)
   })
   .catch(error => {
     log.error(`${controller_name}[${createCredential.name}] -----> ${error}`)
@@ -384,20 +381,20 @@ function getSubjectPresentationStatus(req, res) {
 }
 
 function updateReceiverPresentationStatus(req, res){
-  log.info(`${controller_name}[${updateReceiverPresentationStatus.name}] -----> IN ...`);
-  let presentationHash = req.swagger.params.presentationHash.value;
-  let newStatus = req.swagger.params.status.value.newStatus;
+  log.info(`${controller_name}[${updateReceiverPresentationStatus.name}] -----> IN ...`)
+  let presentationHash = req.swagger.params.presentationHash.value
+  let newStatus = req.swagger.params.status.value.newStatus
   log.debug(`${controller_name}[${updateReceiverPresentationStatus.name}] -----> Sending params: ${presentationHash}, ${newStatus}`)
   entityService.updateReceiverPresentationStatus(presentationHash, newStatus)
   .then(status => { 
-    log.info(`${controller_name}[${updateReceiverPresentationStatus.name}] -----> Successfully updated status presentation`);
+    log.info(`${controller_name}[${updateReceiverPresentationStatus.name}] -----> Successfully updated status presentation`)
     let gettedStatus = {
       presentationStatus: status
     }
-    res.status(200).send(gettedStatus);
+    res.status(200).send(gettedStatus)
   })
   .catch(error => {
-    log.error(`${controller_name}[${updateReceiverPresentationStatus.name}] -----> ${error}`);
+    log.error(`${controller_name}[${updateReceiverPresentationStatus.name}] -----> ${error}`)
     Errmsg.message = error
     res.status(404).send(Errmsg)
   }) 
@@ -413,22 +410,22 @@ function getIssuerPresentationStatus(req, res) {
     let gettedStatus = {
       presentationStatus: status
     }
-    res.status(200).send(gettedStatus);
+    res.status(200).send(gettedStatus)
   })
   .catch(error => {
-    log.error(`${controller_name}[${getIssuerPresentationStatus.name}] -----> ${error}`);
+    log.error(`${controller_name}[${getIssuerPresentationStatus.name}] -----> ${error}`)
     Errmsg.message = error
     res.status(404).send(Errmsg)
   })
 }
 
 function recivePresentationData(req, res) {
-  log.info(`${controller_name}[${recivePresentationData.name}] -----> IN ...`);
+  log.info(`${controller_name}[${recivePresentationData.name}] -----> IN ...`)
   let presentationSigned = req.swagger.params.presentation.value
   log.debug(`${controller_name}[${recivePresentationData.name}] -----> Sending params: ${presentationSigned}`)
   entityService.getPresentationData(presentationSigned)
   .then(subjectData => {
-    log.info(`${controller_name}[${recivePresentationData.name}] -----> Successfully obtained presentation data`);
+    log.info(`${controller_name}[${recivePresentationData.name}] -----> Successfully obtained presentation data`)
     io.emit('getPresentationData', {status: 200,
                                     message: subjectData})
 
@@ -439,7 +436,7 @@ function recivePresentationData(req, res) {
   })
   .catch(error => {
     Errmsg.message = (error == false) ? 'Clave pública no válida' : 'Error obteniendo los datos de la presentación'
-    log.error(`${controller_name}[${recivePresentationData.name}] -----> ${Errmsg.message}`);
+    log.error(`${controller_name}[${recivePresentationData.name}] -----> ${Errmsg.message}`)
     io.emit('error', {status: 400,
                       message: Errmsg.message})
     res.status(400).send(Errmsg)

diff --git a/entityBackend/api/controllers/user.controller.js b/entityBackend/api/controllers/user.controller.js
@@ -25,7 +25,8 @@ module.exports = {
   updateUser,
   getUser,
   getCredentialIdentityCatalog,
-  checkUserAuth
+  checkUserAuth,
+  getObjectFromDB
 }
 
 /////////////////////////////////////////////////////////
@@ -119,19 +120,11 @@ function getUser(req, res) {
   log.debug(`${controller_name}[${getUser.name}] -----> Sending params: ${JSON.stringify(id)}`)
   userModel.getUser(id)
   .then(userData => {
-    if (userData == null) {
-      log.info(`${controller_name}[${getUser.name}] -----> User not found`)
-      let msg = {
-        message: `User not found`
-      }
-      res.status(404).send(msg)
-    } else {
-      log.info(`${controller_name}[${getUser.name}] -----> User found`)
-      let userInfo = {
-        user: userData
-      }
-      res.status(200).send(userInfo)
+    log.info(`${controller_name}[${getUser.name}] -----> User found`)
+    let userInfo = {
+      user: userData
     }
+    res.status(200).send(userInfo)
   })
   .catch(error => {
     llog.error(`${controller_name}[${getUser.name}] -----> ${error}`)
@@ -158,6 +151,25 @@ function getCredentialIdentityCatalog(req, res) {
   })
 }
 
+function getObjectFromDB(req, res) {
+  log.info(`${controller_name}[${getObjectFromDB.name}] -----> IN ...`)
+  let authToken = req.swagger.params.authToken.value
+  log.debug(`${controller_name}[${getObjectFromDB.name}] -----> Sending params: ${authToken}`)
+  userModel.getObjectsFromDB(authToken)
+  .then(object => {
+    log.info(`${controller_name}[${getObjectFromDB.name}] -----> Getted object from DB`)
+    userModel.deleteObjectFromDB(authToken)
+    res.status(200).send(object)
+  })
+  .catch(error => {
+    Errmsg.message = error
+    log.error(`${controller_name}[${getObjectFromDB.name}] -----> ${Errmsg.message}`)
+    io.emit('error', {status: 400,
+                      message: Errmsg.message})
+    res.status(400).send(Errmsg)
+  })
+}
+
 function checkUserAuth(req, res) {
   log.info(`${controller_name}[${checkUserAuth.name}] -----> IN ...`)
   let token = req.swagger.params.authToken.value

diff --git a/entityBackend/api/models/user.model.js b/entityBackend/api/models/user.model.js
@@ -15,7 +15,8 @@ const moduleName = '[User Model]'
 const ObjectId = require('mongodb').ObjectID
 
 const mongoDatabase = myConfig.mongo.dbName
-const mongoCollection = myConfig.mongo.collection
+const userCollection = myConfig.mongo.collectionUser
+const collectionData = myConfig.mongo.collectionData
 
 /////////////////////////////////////////////////////////
 ///////               MODULE EXPORTS              ///////
@@ -27,7 +28,10 @@ module.exports = {
   updateUser,
   getUser,
   getCredentialIdentityCatalog,
-  checkAuth
+  checkAuth,
+  saveTempObject,
+  getObjectsFromDB,
+  deleteObjectFromDB
 }
 
 /////////////////////////////////////////////////////////
@@ -40,13 +44,12 @@ async function isAuth(data) {
     let connected = await mongoHelper.connect(myConfig.mongo)
     log.info(`${moduleName}[${isAuth.name}] -----> Checking if user is authenticated`);
     let db = connected.db(mongoDatabase)
-    let found = await db.collection(mongoCollection).findOne({"$or":[{"username": data.user}, {"email": data.user}], "password": data.password})
+    let found = await db.collection(userCollection).findOne({"$or":[{"username": data.user}, {"email": data.user}], "password": data.password})
     connected.close();
     return found
   }
   catch(error) {
     log.error(`${moduleName}[${isAuth.name}] Error -> ${error}`);
-    connected.close()
     throw error
   }
 }
@@ -63,7 +66,7 @@ async function login(params){
     let pwd = params.password
     let connected = await mongoHelper.connect(myConfig.mongo)
     let db = connected.db(mongoDatabase)
-    let found = await db.collection(mongoCollection).findOne({"$or":[{"username": username}, {"email": username}], "password": pwd})
+    let found = await db.collection(userCollection).findOne({"$or":[{"username": username}, {"email": username}], "password": pwd})
     if(found == null) {
       return found
     }
@@ -83,7 +86,6 @@ async function login(params){
   }
   catch(error) {
     log.error(`${moduleName}[${login.name}] Error -> ${error}`);
-    connected.close()
     throw error
   }
 }
@@ -104,7 +106,7 @@ async function createUser(params) {
       titleLegalBlockchain: myConfig.title
     }
     let db = connected.db(mongoDatabase)
-    let created = await db.collection(mongoCollection).insertOne(userData)
+    await db.collection(userCollection).insertOne(userData)
     log.info(`${moduleName}[${createUser.name}] -----> User created successfuly`)
     let msg = {
       message: 'Created new user correctly'
@@ -115,7 +117,6 @@ async function createUser(params) {
   }
   catch(error) {
     log.error(`${moduleName}[${createUser.name}] -----> Error: ${error}`)
-    connected.close()
     throw error
   }
 }
@@ -139,7 +140,7 @@ async function updateUser(params) {
       update.password = params.password
     }
     let db = connected.db(mongoDatabase)
-    let updated = await db.collection(mongoCollection).updateOne({"_id": new ObjectId(id)},{"$set": update })
+    let updated = await db.collection(userCollection).updateOne({"_id": new ObjectId(id)},{"$set": update })
     log.info(`${moduleName}[${updateUser.name}] -----> Updated Records: ${updated.result.nModified}`)
     let gettedUser = await getUser(id)
     let result = {
@@ -152,7 +153,6 @@ async function updateUser(params) {
   }
   catch(error) {
     log.error(`${moduleName}[${updateUser.name}] -----> Error: ${error}`)
-    connected.close()
     throw error
   }
 }
@@ -163,10 +163,12 @@ async function getUser(id) {
     let find = (id.startsWith('did') == true) ? {"did":id} : {"_id": new ObjectId(id)}
     let connected = await mongoHelper.connect(myConfig.mongo)
     let db = connected.db(mongoDatabase)
-    let user = await db.collection(mongoCollection).findOne(find)
+    let user = await db.collection(userCollection).findOne(find)
     if (user == null){
-      log.info(`${moduleName}[${getUser.name}] -----> User not found in the DataBase`)
-      return user
+      let error = 'User not found in the DataBase'
+      log.error(`${moduleName}[${getUser.name}] -----> ${error}`)
+      connected.close()
+      throw error
     } else {
       log.info(`${moduleName}[${getUser.name}] -----> Data obtained`)
       let loged = await login(user)
@@ -177,7 +179,6 @@ async function getUser(id) {
   }
   catch(error) {
     log.error(`${moduleName}[${getUser.name}] -----> Error: ${error}`)
-    connected.close()
     throw error
   }
 }
@@ -226,4 +227,70 @@ async function checkAuth(token) {
     log.error(`${moduleName}[${checkAuth.name}] -----> Error: ${error}`)
     throw error
   }
+}
+
+async function saveTempObject(object, subjectDID) {
+  try {
+    log.info(`${moduleName}[${saveTempObject.name}] -----> IN...`)
+    let connected = await mongoHelper.connect(myConfig.mongo)
+    let objectData = {
+      authToken: jwt.sign({data: subjectDID}, myConfig.authKeyToken, { expiresIn: 60 * 60 }),
+      object: object
+    }
+    let db = connected.db(mongoDatabase)
+    await db.collection(collectionData).insertOne(objectData)
+    log.info(`${moduleName}[${saveTempObject.name}] -----> Object saved successfuly`)
+    connected.close()
+    return objectData.authToken
+  }
+  catch(error) {
+    log.error(`${moduleName}[${saveTempObject.name}] -----> Error: ${error}`)
+    throw error
+  }
+}
+
+async function getObjectsFromDB(authToken) {
+  try {
+    log.info(`${moduleName}[${getObjectsFromDB.name}] -----> IN...`)
+    let find = {"authToken": authToken}
+    let connected = await mongoHelper.connect(myConfig.mongo)
+    let db = connected.db(mongoDatabase)
+    let objectFound = await db.collection(collectionData).findOne(find)
+    if(objectFound == null){
+      let error = 'Object not found'
+      log.error(`${moduleName}[${getObjectsFromDB.name}] -----> ${error}`)
+      connected.close()
+      throw error
+    }
+    connected.close()
+    log.info(`${moduleName}[${getObjectsFromDB.name}] -----> Object saved successfuly`)
+    return objectFound.object
+  }
+  catch(error) {
+    log.error(`${moduleName}[${getObjectsFromDB.name}] -----> Error: ${error}`)
+    throw error
+  }
+}
+
+async function deleteObjectFromDB(authToken) {
+  try {
+    log.info(`${moduleName}[${deleteObjectFromDB.name}] -----> IN...`)
+    let deleteOne = {"authToken": authToken}
+    let connected = await mongoHelper.connect(myConfig.mongo)
+    let db = connected.db(mongoDatabase)
+    let objectDeleted = await db.collection(collectionData).deleteOne(deleteOne)
+    if(objectDeleted == null) {
+      let error = 'Object not found'
+      log.error(`${moduleName}[${deleteObjectFromDB.name}] -----> ${error}`)
+      connected.close()
+      throw error
+    }
+    connected.close()
+    log.info(`${moduleName}[${deleteObjectFromDB.name}] -----> Object deleted successfuly`)
+    return
+  }
+  catch(error) {
+    log.error(`${moduleName}[${deleteObjectFromDB.name}] -----> Error: ${error}`)
+    throw error
+  }
 }
diff --git a/entityBackend/api/services/entity.service.js b/entityBackend/api/services/entity.service.js
@@ -114,7 +114,7 @@ async function createAlastriaToken(functionCall) {
       exp: expDate,
       ani: myConfig.netID,
       nbf: currentDate,
-      jti: Math.random().toString(36).substring(2)
+      jti: `Alastria/token/${Math.random().toString()}`
     }
     let alastriaToken = tokenHelper.createAlastriaToken(alastriaTokenData)
     let AlastriaTokenSigned = tokenHelper.signJWT(alastriaToken, myConfig.entityPrivateKey)
@@ -342,7 +342,7 @@ async function createCredential(identityDID, credentials) {
       let credentialSubject = {}
       const currentDate = Math.floor(Date.now());
       const expDate = currentDate + 86400000;
-      let jti = Math.random().toString(36).substring(2)
+      let jti = `Alastria/credential/${Math.random().toString()}`
       credentialSubject.levelOfAssurance = credential.levelOfAssurance
       credentialSubject[credential.field_name] = (credential.field_name == 'fullname') ? `${user.userData.name} ${user.userData.surname}` : user.userData[credential.field_name]
 
@@ -364,7 +364,17 @@ async function createCredential(identityDID, credentials) {
       })
     })
     log.info(`${serviceName}[${createCredential.name}] -----> Created Successfully`)
-    return credentialsJWT
+
+    let credentialObject = {
+      verifiableCredential: credentialsJWT
+    }
+
+    let responseToken = await userModel.saveTempObject(credentialObject, identityDID)
+    let objectTinyURL = {
+      url: `${myConfig.callbackUrl}objects/db?authToken=${responseToken}`
+    }
+
+    return objectTinyURL
   }
   catch(error){
     log.error(`${serviceName}[${createCredential.name}] -----> ${error}`)
@@ -428,12 +438,20 @@ async function createPresentationRequest(requestData) {
     log.info(`${serviceName}[${createPresentationRequest.name}] -----> IN ...`)
     const currentDate = Math.floor(Date.now());
     const expDate = currentDate + 86400000;
-    let jti = Math.random().toString(36).substring(2)
+    let jti = `Alastria/request/${Math.random().toString()}`
     let objectRequest = tokenHelper.createPresentationRequest(myConfig.entityDID, myConfig.entityDID, myConfig.context,
                                                                    myConfig.context[0], `0x${myConfig.procHash}`, requestData,
                                                                    `${myConfig.callbackUrl}alastria/presentation`,expDate, currentDate, jti)
     let presentationRequest = tokenHelper.signJWT(objectRequest, myConfig.entityPrivateKey)
-    return presentationRequest
+    let objectPresentationRequest = {
+      jwt: presentationRequest
+    }
+
+    let responseToken = await userModel.saveTempObject(objectPresentationRequest, myConfig.entityDID)
+    let objectTinyURL = {
+      url: `${myConfig.callbackUrl}objects/db?authToken=${responseToken}`
+    }
+    return objectTinyURL.url
   }
   catch(error) {
     log.error(`${serviceName}[${createPresentationRequest.name}] -----> ${error}`)