#252645675

Committed 16 Nov 2023 11:33AM UTC coverage: 71.023% (-1.2%) from 72.267%

Build Type

Committed by

Commit Message

debugging not-found transfer ID, tracing promise returns back to router

Pull Request Pull Request #456: staging version 1.9.2491

Run Details

1759 of 3420 branches covered (0.0%)

Branch coverage included in aggregate %.

137 of 291 new or added lines in 20 files covered. (47.08%)

61 existing lines in 11 files now uncovered.

8082 of 10436 relevant lines covered (77.44%)

28.11 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

62.5

/lib/router.transfer.js

// /api/v2/ Transfer


const Util = require("./thinx/util");
const Sanitka = require("./thinx/sanitka"); var sanitka = new Sanitka();

const Globals = require("./thinx/globals");
const app_config = Globals.app_config(); // for public_url

module.exports = function (app) {

  const Transfer = require("../lib/thinx/transfer"); var transfer = new Transfer(app.messenger, app.redis_client);

  function transferResultRedirect(success, res, response) {

    // solves `Headers already set` issue?
    if ((process.env.ENVIRONMENT === "test") || (process.env.ENVIRONMENT === "development")) {
      //return Util.responder(res, success, response);
      console.log("[test] returning promise resolve with response, instead of redirect:", response);
      return Promise.resolve(response);
    }

    if (success === false) {
      res.redirect(app_config.public_url + "/error.html?success=failed&reason=" + response);
    } else {
      res.redirect(app_config.public_url + "/error.html?success=true");
    }
  }

  async function requestTransfer(req, res) {
    if (!Util.validateSession(req)) return res.status(401).end();
    let owner = sanitka.owner(req.session.owner);
    const body = req.body;
    let response = await transfer.request(owner, body).catch( (error) => {
      console.log("[requestTransfer] await transfer.request with error", error, "in body", {body});
      transferResultRedirect(false, res, error);
    });
    console.log("[requestTransfer] with response: ", response);
    transferResultRedirect(true, res, response);
  
  }

  async function getDeclineTransfer(req, res) {
    
    if (!Util.isDefined(sanitka.udid(req.body.transfer_id))) return Util.responder(res, false, "transfer_id_missing");

    var body = {
      transfer_id: req.query.transfer_id,
      udids: []
    };

    let response = await transfer.decline(body).catch((response) => {
      transferResultRedirect(false, res, response);
    });

    console.log("[getDeclineTransfer] transfer.decline response", response);

    transferResultRedirect(true, res, response);
  }

  async function postDeclineTransfer(req, res) {

    if (!Util.validateSession(req)) return res.status(401).end();

    if (!Util.isDefined(sanitka.udid(req.body.transfer_id))) return Util.responder(res, false, "transfer_id_missing");
    if (!Util.isDefined(sanitka.owner(req.body.owner))) return Util.responder(res, false, "owner_missing");
    if (!Util.isDefined(req.body.udids)) return Util.responder(res, false, "udids_missing");

    var body = {
      transfer_id: req.body.transfer_id,
      udids: sanitka.udid(req.body.udid)
    };

    let response = await transfer.decline(body).catch((error) => {
      transferResultRedirect(false, res, error);
    });

    console.log("[getDeclineTransfer] transfer.decline response", response);

    transferResultRedirect(true, res);
  }

  // called from e-mail to accept a transfer ID
  async function getAcceptTransfer(req, res) {

    let transfer_id = req.query.transfer_id;
    
    if (!Util.isDefined(transfer_id)) {
      console.log("[warning] Transfer ID missing in getAcceptTransfer query", req.query);
      return Util.responder(res, false, "transfer_id_missing");
    }
    
    let response = await transfer.accept({
      transfer_id: transfer_id,
      udids: []
    }).catch((error) => {
      console.log("[getAcceptTransfer] failed with error", error.message);
      transferResultRedirect(false, res, error);
    });

    transferResultRedirect(true, res, response);
  }

  async function postAcceptTransfer(req, res) {

    if (!Util.validateSession(req)) return res.status(401).end();
    if (!Util.isDefined(req.body)) return Util.responder(res, false, "transfer_body_missing");

    const body = req.body;

    if (!Util.isDefined(sanitka.udid(body.transfer_id))) return Util.responder(res, false, "transfer_id_missing");
    if (!Util.isDefined(sanitka.owner(body.owner))) return Util.responder(res, false, "owner_missing");
    if (!Util.isDefined(body.udids)) return Util.responder(res, false, "udids_missing");

    console.log("🔨 [debug] <postAcceptTransfer> with body: ", {body});

    await transfer.accept(body).catch((response) => {
      console.log("[debug] postAcceptTransfer response", response);
      res.redirect(app_config.public_url + "/error.html?success=failed");
    }).then(() => {
      res.redirect(app_config.public_url + "/error.html?success=true");
    });
  }

  ///////////////////////////////////////////////////////////////////////
  // API ROUTES v2
  //

  app.post("/api/v2/transfer/request", async function (req, res) {
    await requestTransfer(req, res);
  });

  app.get("/api/v2/transfer/decline", async function (req, res) {
    await getDeclineTransfer(req, res);
  });

  app.post("/api/v2/transfer/decline", async function (req, res) {
    await postDeclineTransfer(req, res);
  });

  app.get("/api/v2/transfer/accept", async function (req, res) {
    await getAcceptTransfer(req, res);
  });

  app.post("/api/v2/transfer/accept", async function (req, res) {
    await postAcceptTransfer(req, res);
  });

  ///////////////////////////////////////////////////////////////////////
  // API ROUTES v1
  //

  /* Request device transfer */
  app.post("/api/transfer/request", async function (req, res) {
    await requestTransfer(req, res);
  });

  /* Decline device transfer (all by e-mail, selective will be POST) */
  app.get("/api/transfer/decline", async function (req, res) {
    await getDeclineTransfer(req, res);
  });

  /* Decline selective device transfer */
  app.post("/api/transfer/decline", async function (req, res) {
    await postDeclineTransfer(req, res);
  });

  /* Accept device transfer (all by e-mail, selective will be POST) */
  app.get("/api/transfer/accept", async function (req, res) {
    await getAcceptTransfer(req, res);
  });

  /* Accept selective device transfer */
  app.post("/api/transfer/accept", async function (req, res) {
    await postAcceptTransfer(req, res);
  });

};

1	// /api/v2/ Transfer
2
3
4	const Util = require("./thinx/util");	1✔
5	const Sanitka = require("./thinx/sanitka"); var sanitka = new Sanitka();	1✔
6
7	const Globals = require("./thinx/globals");	1✔
8	const app_config = Globals.app_config(); // for public_url	1✔
9
10	module.exports = function (app) {	1✔
11
12	const Transfer = require("../lib/thinx/transfer"); var transfer = new Transfer(app.messenger, app.redis_client);	15✔
13
14	function transferResultRedirect(success, res, response) {
15
16	// solves `Headers already set` issue?
17	if ((process.env.ENVIRONMENT === "test") \|\| (process.env.ENVIRONMENT === "development")) {	9!
18	//return Util.responder(res, success, response);
19	console.log("[test] returning promise resolve with response, instead of redirect:", response);	9✔
20	return Promise.resolve(response);	9✔
21	}
22
23	if (success === false) {	×
24	res.redirect(app_config.public_url + "/error.html?success=failed&reason=" + response);	×
25	} else {
26	res.redirect(app_config.public_url + "/error.html?success=true");	×
27	}
28	}
29
30	async function requestTransfer(req, res) {
31	if (!Util.validateSession(req)) return res.status(401).end();	5✔
32	let owner = sanitka.owner(req.session.owner);	4✔
33	const body = req.body;	4✔
34	let response = await transfer.request(owner, body).catch( (error) => {	4✔
35	console.log("[requestTransfer] await transfer.request with error", error, "in body", {body});	3✔
36	transferResultRedirect(false, res, error);	3✔
37	});
38	console.log("[requestTransfer] with response: ", response);	4✔
39	transferResultRedirect(true, res, response);	4✔
40
41	}
42
43	async function getDeclineTransfer(req, res) {
44
45	if (!Util.isDefined(sanitka.udid(req.body.transfer_id))) return Util.responder(res, false, "transfer_id_missing");	4!
46
UNCOV 47	var body = {	×
48	transfer_id: req.query.transfer_id,
49	udids: []
50	};
51
NEW 52	let response = await transfer.decline(body).catch((response) => {	×
NEW 53	transferResultRedirect(false, res, response);	×
54	});
55
NEW 56	console.log("[getDeclineTransfer] transfer.decline response", response);	×
57
NEW 58	transferResultRedirect(true, res, response);	×
59	}
60
61	async function postDeclineTransfer(req, res) {
62
63	if (!Util.validateSession(req)) return res.status(401).end();	7✔
64
65	if (!Util.isDefined(sanitka.udid(req.body.transfer_id))) return Util.responder(res, false, "transfer_id_missing");	6!
UNCOV 66	if (!Util.isDefined(sanitka.owner(req.body.owner))) return Util.responder(res, false, "owner_missing");	×
UNCOV 67	if (!Util.isDefined(req.body.udids)) return Util.responder(res, false, "udids_missing");	×
68
UNCOV 69	var body = {	×
70	transfer_id: req.body.transfer_id,
71	udids: sanitka.udid(req.body.udid)
72	};
73
NEW 74	let response = await transfer.decline(body).catch((error) => {	×
NEW 75	transferResultRedirect(false, res, error);	×
76	});
77
NEW 78	console.log("[getDeclineTransfer] transfer.decline response", response);	×
79
NEW 80	transferResultRedirect(true, res);	×
81	}
82
83	// called from e-mail to accept a transfer ID
84	async function getAcceptTransfer(req, res) {
85
86	let transfer_id = req.query.transfer_id;	7✔
87
88	if (!Util.isDefined(transfer_id)) {	7✔
89	console.log("[warning] Transfer ID missing in getAcceptTransfer query", req.query);	6✔
90	return Util.responder(res, false, "transfer_id_missing");	6✔
91	}
92
93	let response = await transfer.accept({	1✔
94	transfer_id: transfer_id,
95	udids: []
96	}).catch((error) => {
97	console.log("[getAcceptTransfer] failed with error", error.message);	1✔
98	transferResultRedirect(false, res, error);	1✔
99	});
100
101	transferResultRedirect(true, res, response);	1✔
102	}
103
104	async function postAcceptTransfer(req, res) {
105
106	if (!Util.validateSession(req)) return res.status(401).end();	4!
107	if (!Util.isDefined(req.body)) return Util.responder(res, false, "transfer_body_missing");	4!
108
109	const body = req.body;	4✔
110
111	if (!Util.isDefined(sanitka.udid(body.transfer_id))) return Util.responder(res, false, "transfer_id_missing");	4!
NEW 112	if (!Util.isDefined(sanitka.owner(body.owner))) return Util.responder(res, false, "owner_missing");	×
NEW 113	if (!Util.isDefined(body.udids)) return Util.responder(res, false, "udids_missing");	×
114
NEW 115	console.log("🔨 [debug] <postAcceptTransfer> with body: ", {body});	×
116
NEW 117	await transfer.accept(body).catch((response) => {	×
NEW 118	console.log("[debug] postAcceptTransfer response", response);	×
NEW 119	res.redirect(app_config.public_url + "/error.html?success=failed");	×
120	}).then(() => {
NEW 121	res.redirect(app_config.public_url + "/error.html?success=true");	×
122	});
123	}
124
125	///////////////////////////////////////////////////////////////////////
126	// API ROUTES v2
127	//
128
129	app.post("/api/v2/transfer/request", async function (req, res) {	15✔
130	await requestTransfer(req, res);	1✔
131	});
132
133	app.get("/api/v2/transfer/decline", async function (req, res) {	15✔
134	await getDeclineTransfer(req, res);	2✔
135	});
136
137	app.post("/api/v2/transfer/decline", async function (req, res) {	15✔
138	await postDeclineTransfer(req, res);	5✔
139	});
140
141	app.get("/api/v2/transfer/accept", async function (req, res) {	15✔
142	await getAcceptTransfer(req, res);	3✔
143	});
144
145	app.post("/api/v2/transfer/accept", async function (req, res) {	15✔
146	await postAcceptTransfer(req, res);	3✔
147	});
148
149	///////////////////////////////////////////////////////////////////////
150	// API ROUTES v1
151	//
152
153	/* Request device transfer */
154	app.post("/api/transfer/request", async function (req, res) {	15✔
155	await requestTransfer(req, res);	4✔
156	});
157
158	/* Decline device transfer (all by e-mail, selective will be POST) */
159	app.get("/api/transfer/decline", async function (req, res) {	15✔
160	await getDeclineTransfer(req, res);	2✔
161	});
162
163	/* Decline selective device transfer */
164	app.post("/api/transfer/decline", async function (req, res) {	15✔
165	await postDeclineTransfer(req, res);	2✔
166	});
167
168	/* Accept device transfer (all by e-mail, selective will be POST) */
169	app.get("/api/transfer/accept", async function (req, res) {	15✔
170	await getAcceptTransfer(req, res);	4✔
171	});
172
173	/* Accept selective device transfer */
174	app.post("/api/transfer/accept", async function (req, res) {	15✔
175	await postAcceptTransfer(req, res);	1✔
176	});
177
178	};

suculent / thinx-device-api / #252645675

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous