Merge branch 'Trust-line-in-practitioner-acceptance' into 'master'

trustline creation for issuer

See merge request !22

ExpressBackend/model/stellar/nftRequests.js

+const mongoose = require("mongoose");
+
+const NFTRequest = new mongoose.Schema({
+  assetcode: String,
+  requesterpk: String,
+  issuerpk: String,
+  status: String,
+});
+
+module.exports = mongoose.model("NFTRequest", NFTRequest);

ExpressBackend/route/practitioner-routes/requestnft-route.js

+const express = require("express");
+const router = express.Router();
+const GetIssuerAndAssetCode = require("./../../services/assetCodeGetterFromDB");
+const DecryptWithServerKey = require("./../../services/decryptionservice");
+const StellarSdk = require("stellar-sdk");
+const CreateTrustline = require("./../../services/trustlineCreator");
+const NFTRequest = require("./../../model/stellar/nftRequests");
+require("dotenv").config();
+
+router.post("/", async (req, res) => {
+  const practitionerPK = req.body.practitionerkey;
+  const practitionerSK = req.body.practitionerseed;
+  const patientKey = req.body.patient;
+
+  //take the current asset code and the issuer key for the patient from the data base
+  const assetAndIssuer = await GetIssuerAndAssetCode("patients", patientKey);
+
+  console.log("AC", assetAndIssuer.assetCode);
+  console.log("IP", DecryptWithServerKey(assetAndIssuer.issuerKey));
+
+  const assetCode = assetAndIssuer.assetCode;
+  const issuerPK = DecryptWithServerKey(assetAndIssuer.issuerKey);
+
+  CreateTrustline(assetCode, issuerPK, practitionerSK)
+    .then(async (result) => {
+      console.log("Trust line created successfully!");
+      //add request to DB
+      const nftRequestObj = new NFTRequest({
+        assetcode: assetCode,
+        issuerpk: issuerPK,
+        requesterpk: practitionerPK,
+        status: "Pending",
+      });
+      try {
+        const saveRequest = await nftRequestObj.save();
+        console.log("NFT request saved to database : " + saveRequest);
+        res.status(200).json({
+          message: "NFT request saved to database",
+        });
+        console.log("/practitioner/requestnft - requesting NFT success");
+      } catch (errorWhenAddingRequestToDB) {
+        console.log(
+          "Error when adding NFT request to DB : ",
+          errorWhenAddingRequestToDB
+        );
+        console.log("/practitioner/requestnft - requesting NFT failed");
+        return res.status(500).json({
+          message: "Error when adding NFT request to DB : ",
+          errorWhenAddingRequestToDB,
+        });
+      }
+    })
+    .catch((error) => {
+      console.log("Failed to create the trust line  : ", error);
+      console.log("/practitioner/requestnft - requesting NFT failed");
+      return res.status(500).json({
+        message: "Failed to create the trust line  : ",
+        error,
+      });
+    });
+
+  // await server
+  //   .loadAccount(sourceAccountKeypair.publicKey())
+  //   .then((sourceAccount) => {
+  //     return CreateTrustline(
+  //       assetCode,
+  //       DecryptWithServerKey(assetAndIssuer.issuerKey),
+  //       sourceAccount
+  //     )
+  //   })
+  //   .then(async (result) => {
+  //     if (result) {
+  //       console.log("Trust line created successfully!");
+
+  //       //add request to DB
+  //       const nftRequestObj = new NFTRequest({
+  //         assetcode: assetCode,
+  //         issuerpk: issuerPK,
+  //         requesterpk: practitionerPK,
+  //         status: "Pending",
+  //       });
+  //       try {
+  //         const saveRequest = await nftRequestObj.save();
+  //         console.log("NFT request saved to database : " + saveRequest);
+  //         res.status(200).json({
+  //           message: "NFT request saved to database",
+  //         });
+  //         console.log("/practitioner/requestnft - requesting NFT success");
+  //       } catch (errorWhenAddingRequestToDB) {
+  //         console.log(
+  //           "Error when adding NFT request to DB : ",
+  //           errorWhenAddingRequestToDB
+  //         );
+  //         console.log("/practitioner/requestnft - requesting NFT failed");
+  //         return res.status(500).json({
+  //           message: "Error when adding NFT request to DB : ",
+  //           errorWhenAddingRequestToDB,
+  //         });
+  //       }
+  //     } else {
+  //       console.log("/practitioner/requestnft - requesting NFT failed");
+  //       return res.status(500).json({
+  //         message: "Failed to request the NFT",
+  //       });
+  //     }
+  //   });
+});
+
+module.exports = router;

ExpressBackend/server.js

@@ -42,6 +42,9 @@ app.use("/practitioner/records", practitionerRecords);
 const practitionerAcceptance = require("./route/practitioner-routes/acceptance-route");
 app.use("/practitioner/request", practitionerAcceptance);
 
+const practitionerNFTReq = require("./route/practitioner-routes/requestnft-route");
+app.use("/practitioner/requestnft", practitionerNFTReq);
+
 app.listen(process.env.SERVER_PORT, () =>
   console.log("Server started on port " + process.env.SERVER_PORT)
 );

ExpressBackend/services/assetCodeGetterFromDB.js

+const MongoClient = require("mongodb").MongoClient;
+
+async function GetIssuerAndAssetCode(collectionName, publicKey) {
+  const uri = process.env.DATABASE_URL;
+  const client = new MongoClient(uri, {
+    useNewUrlParser: true,
+    useUnifiedTopology: true,
+  });
+
+  try {
+    await client.connect();
+
+    const collection = client.db().collection(collectionName);
+    const result = await collection.findOne({ publickey: publicKey });
+
+    if (!result) {
+      throw new Error("No record found for the provided public key");
+    }
+
+    return {
+      issuerKey: result.issuerpk,
+      assetCode: result.keysequence,
+    };
+  } finally {
+    await client.close();
+  }
+}
+module.exports = GetIssuerAndAssetCode;

ExpressBackend/services/trustlineCreator.js

+const StellarSdk = require("stellar-sdk");
+const server = new StellarSdk.Server(process.env.STELLARTESTNET);
+
+async function CreateTrustline(assetCode, issuerKey, sourceAccountSeed) {
+  //load user account
+  const userSourceKeyPair = StellarSdk.Keypair.fromSecret(sourceAccountSeed);
+  const userPublicKey = userSourceKeyPair.publicKey();
+  const account = await server.loadAccount(userPublicKey);
+  const fee = await server.fetchBaseFee();
+
+  //create trustline transaction
+  const trustlineTxn = new StellarSdk.TransactionBuilder(account, {
+    fee,
+    networkPassphrase: StellarSdk.Networks.TESTNET,
+  })
+    .addMemo(StellarSdk.Memo.text("Trustline creation"))
+    .addOperation(
+      StellarSdk.Operation.changeTrust({
+        asset: new StellarSdk.Asset(assetCode, issuerKey),
+        limit: "1",
+      })
+    )
+    .setTimeout(30)
+    .build();
+
+  trustlineTxn.sign(userSourceKeyPair);
+
+  try {
+    const transactionResult = await server.submitTransaction(trustlineTxn);
+    console.log(
+      `Transaction hash for issuer trust line : ${transactionResult.hash}`
+    );
+    return true;
+  } catch (error) {
+    console.error("Error creating trustline:", error);
+    return false;
+  }
+}
+module.exports = CreateTrustline;