#252645666

Committed 15 Nov 2023 10:32PM UTC coverage: 71.073% (-1.2%) from 72.267%

Build Type

Committed by

Commit Message

from 6 issues, trying to resolve some promises with thenables

Pull Request Pull Request #456: staging version 1.9.2491

Run Details

1757 of 3422 branches covered (0.0%)

Branch coverage included in aggregate %.

124 of 260 new or added lines in 18 files covered. (47.69%)

51 existing lines in 13 files now uncovered.

8088 of 10430 relevant lines covered (77.55%)

27.73 hits per line

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

59.6

/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);
    }

    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;
    await transfer.request(owner, body).catch( (error) => {
      console.log("[transferResultRedirect] await transfer.request with error", error, "in body", {body});
      transferResultRedirect(false, res, error);
    }).then((resolve) => {
      console.log("[transferResultRedirect] with response", response);
      transferResultRedirect(true, res, response);
      resolve(true);
    });
  }

  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);
    }).then((resolve) => {
      transferResultRedirect(true, res, response);
      resolve(true);
    });
  }

  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)
    };

    // may throw
    await transfer.decline(body).catch((error) => {
      transferResultRedirect(false, res, error);
    }).then(() => {
      transferResultRedirect(true, res);
    });
  }

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

suculent / thinx-device-api / #252645666

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