4297

pending completion

Build # 4297

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #982 from mozilla/fix-remove-monitor-button-941

fix #941: implement remove button

Run Details

167 of 416 branches covered (40.14%)

Branch coverage included in aggregate %.

34 of 34 new or added lines in 3 files covered. (100.0%)

668 of 1426 relevant lines covered (46.84%)

3.47 hits per line

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

83.82

/db/DB.js

"use strict";


// eslint-disable-next-line node/no-extraneous-require
const uuidv4 = require("uuid/v4");
const Knex = require("knex");

const { FluentError } = require("../locale-utils");
const AppConstants = require("../app-constants");
const HIBP = require("../hibp");
const Basket = require("../basket");
const getSha1 = require("../sha1-utils");
const mozlog = require("../log");

const knexConfig = require("./knexfile");

let knex = Knex(knexConfig);
const log = mozlog("DB");


const DB = {
  async getSubscriberByToken(token) {
    const res = await knex("subscribers")
      .where("primary_verification_token", "=", token);

    return res[0];
  },

  async getEmailByToken(token) {
    const res = await knex("email_addresses")
      .where("verification_token", "=", token);

    return res[0];
  },

  async getEmailById(emailAddressId) {
    const res = await knex("email_addresses")
      .where("id", "=", emailAddressId);

    return res[0];
  },

  async getSubscriberByTokenAndHash(token, emailSha1) {
    const res = await knex.table("subscribers")
      .first()
      .where({
        "primary_verification_token": token,
        "primary_sha1": emailSha1,
      });
    return res;
  },

  async getSubscriberByEmail(email) {
    const [subscriber] = await knex("subscribers").where({
      "primary_email": email,
      "primary_verified": true,
    });
    if (subscriber) {
      subscriber.email_addresses = await knex("email_addresses").where({
        "subscriber_id": subscriber.id,
      });
    }
    return subscriber;
  },

  async addSubscriberUnverifiedEmailHash(user, email) {
    const res = await knex("email_addresses").insert({
      subscriber_id: user.id,
      email: email,
      sha1: getSha1(email),
      verification_token: uuidv4(),
      verified: false,
    }).returning("*");
    return res[0];
  },

  async resetUnverifiedEmailAddress(emailAddressId) {
    const newVerificationToken = uuidv4();
    const res = await knex("email_addresses")
      .update({
        verification_token: newVerificationToken,
        updated_at: knex.fn.now(),
      })
      .where("id", emailAddressId)
      .returning("*");
    return res[0];
  },

  async verifyEmailHash(token) {
    const unverifiedEmail = await this.getEmailByToken(token);
    if (!unverifiedEmail) {
      throw new FluentError("Error message for this verification email timed out or something went wrong.");
    }
    const verifiedEmail = await this._verifyNewEmail(unverifiedEmail);
    return verifiedEmail[0];
  },

  // TODO: refactor into an upsert? https://jaketrent.com/post/upsert-knexjs/
  // Used internally, ideally should not be called by consumers.
  async _getSha1EntryAndDo(sha1, aFoundCallback, aNotFoundCallback) {
    const existingEntries = await knex("subscribers")
      .where("primary_sha1", sha1);

    if (existingEntries.length && aFoundCallback) {
      return await aFoundCallback(existingEntries[0]);
    }

    if (!existingEntries.length && aNotFoundCallback) {
      return await aNotFoundCallback();
    }
  },

  // Used internally.
  async _addEmailHash(sha1, email, signup_language, verified = false) {
    try {
      return await this._getSha1EntryAndDo(sha1, async aEntry => {
        // Entry existed, patch the email value if supplied.
        if (email) {
          const res = await knex("subscribers")
            .update({
              primary_email: email,
              primary_verified: verified,
              updated_at: knex.fn.now(),
            })
            .where("id", "=", aEntry.id)
            .returning("*");
          return res[0];
        }

        return aEntry;
      }, async () => {
        // Always add a verification_token value
        const verification_token = uuidv4();
        const res = await knex("subscribers")
          .insert({ primary_sha1: sha1, primary_email: email, signup_language, primary_verification_token: verification_token, primary_verified: verified })
          .returning("*");
        return res[0];
      });
    } catch (e) {
      throw new FluentError("error-could-not-add-email");
    }
  },

  /**
   * Add a subscriber:
   * 1. Add a record to subscribers
   * 2. Immediately call _verifySubscriber
   * 3. For FxA subscriber, add refresh token and profile data
   *
   * @param {string} email to add
   * @param {string} fxaRefreshToken from Firefox Account Oauth
   * @param {string} fxaProfileData from Firefox Account
   * @returns {object} subscriber knex object added to DB
   */
  async addSubscriber(email, signupLanguage, fxaRefreshToken=null, fxaProfileData=null) {
    const emailHash = await this._addEmailHash(getSha1(email), email, signupLanguage, true);
    const verified = await this._verifySubscriber(emailHash);
    const verifiedSubscriber = Array.isArray(verified) ? verified[0] : null;
    if (fxaRefreshToken || fxaProfileData) {
      return this._updateFxAData(verifiedSubscriber, fxaRefreshToken, fxaProfileData);
    }
    return verifiedSubscriber;
  },

  /**
   * When an email is verified, convert it into a subscriber:
   * 1. Subscribe the hash to HIBP
   * 2. Update our subscribers record to verified
   * 3. (if opted in) Subscribe the email to Fx newsletter
   *
   * @param {object} emailHash knex object in DB
   * @returns {object} verified subscriber knex object in DB
   */
  async _verifySubscriber(emailHash) {
    // TODO: move this "up" into controllers/users ?
    await HIBP.subscribeHash(emailHash.primary_sha1);

    const verifiedSubscriber = await knex("subscribers")
      .where("primary_email", "=", emailHash.primary_email)
      .update({
        primary_verified: true,
        updated_at: knex.fn.now(),
      })
      .returning("*");

    // TODO: move this "up" into controllers/users ?
    if (emailHash.fx_newsletter) {
      Basket.subscribe(emailHash.primary_email);
    }

    return verifiedSubscriber;
  },

  // Verifies new emails added by existing users
  async _verifyNewEmail(emailHash) {
    await HIBP.subscribeHash(emailHash.sha1);

    const verifiedEmail = await knex("email_addresses")
      .where("email", "=", emailHash.email)
      .update({
        verified: true,
      })
      .returning("*");

  return verifiedEmail;
  },

  async getUserEmails(userId) {

    const userEmails = await knex("email_addresses")
      .where("subscriber_id", "=", userId)
      .returning("*");

    return userEmails;
  },

  /**
   * Update fxa_refresh_token and fxa_profile_json for subscriber
   *
   * @param {object} subscriber knex object in DB
   * @param {string} fxaRefreshToken from Firefox Account Oauth
   * @param {string} fxaProfileData from Firefox Account
   * @returns {object} updated subscriber knex object in DB
   */
  async _updateFxAData(subscriber, fxaRefreshToken, fxaProfileData) {
    const fxaUID = JSON.parse(fxaProfileData).uid;
    const updated = await knex("subscribers")
    .where("id", "=", subscriber.id)
    .update({
      fxa_uid: fxaUID,
      fxa_refresh_token: fxaRefreshToken,
      fxa_profile_json: fxaProfileData,
    })
    .returning("*");
    const updatedSubscriber = Array.isArray(updated) ? updated[0] : null;
    return updatedSubscriber;
  },

  async setBreachesLastShownNow(subscriber) {
    // TODO: turn 2 db queries into a single query (also see #942)
    const nowDateTime = new Date();
    const nowTimeStamp = nowDateTime.toISOString();
    await knex("subscribers")
    .where("id", "=", subscriber.id)
    .update({
      breaches_last_shown: nowTimeStamp,
    });
    return this.getSubscriberByEmail(subscriber.primary_email);
  },

  async setAllEmailsToPrimary(subscriber, allEmailsToPrimary) {
    const updated = await knex("subscribers")
    .where("id", subscriber.id)
    .update({
      all_emails_to_primary: allEmailsToPrimary,
    })
    .returning("*");
    const updatedSubscriber = Array.isArray(updated) ? updated[0] : null;
    return updatedSubscriber;
  },

  async removeSubscriber(subscriber) {
    await knex("email_addresses").where({"subscriber_id": subscriber.id}).del();
    await knex("subscribers").where({"id": subscriber.id}).del();
  },

  async removeSubscriberByEmail(email) {
    const sha1 = getSha1(email);
    return await this._getSha1EntryAndDo(sha1, async aEntry => {
      await knex("subscribers")
        .where("id", "=", aEntry.id)
        .del();
      log.info("removed-subscriber", { id: aEntry.id });
      return aEntry;
    }, async () => {
      log.warn("removed-subscriber-not-found");
      return;
    });
  },

  async removeSubscriberByToken(token, emailSha1) {
    const subscriber = await this.getSubscriberByTokenAndHash(token, emailSha1);
    if (!subscriber) {
      return false;
    }
    await knex("subscribers")
      .where({
        "primary_verification_token": subscriber.primary_verification_token,
        "primary_sha1": subscriber.primary_sha1,
      })
      .del();
    return subscriber;
  },

  async removeOneSecondaryEmail(emailId) {
    await knex("email_addresses")
      .where({
        "id": emailId,
      })
      .del();
      return;
  },

  async getSubscribersByHashes(hashes) {
    return await knex("subscribers").whereIn("primary_sha1", hashes).andWhere("primary_verified", "=", true);
  },

  async getEmailAddressesByHashes(hashes) {
    return await knex("email_addresses")
      .join("subscribers", "email_addresses.subscriber_id", "=", "subscribers.id")
      .whereIn("email_addresses.sha1", hashes)
      .andWhere("email_addresses.verified", "=", true);
  },

  async deleteUnverifiedSubscribers() {
    const expiredDateTime = new Date(Date.now() - AppConstants.DELETE_UNVERIFIED_SUBSCRIBERS_TIMER * 1000);
    const expiredTimeStamp = expiredDateTime.toISOString();
    await knex("subscribers")
      .where("primary_verified", false)
      .andWhere("created_at", "<", expiredTimeStamp)
      .del();
  },

  async deleteSubscriberByFxAUID(fxaUID) {
    await knex("subscribers").where("fxa_uid", fxaUID).del();
  },

  async createConnection() {
    if (knex === null) {
      knex = Knex(knexConfig);
    }
  },

  async destroyConnection() {
    await knex.destroy();
    knex = null;
  },

};

module.exports = DB;

1	"use strict";
2
3
4	// eslint-disable-next-line node/no-extraneous-require
5	const uuidv4 = require("uuid/v4");	6✔
6	const Knex = require("knex");	6✔
7
8	const { FluentError } = require("../locale-utils");	6✔
9	const AppConstants = require("../app-constants");	6✔
10	const HIBP = require("../hibp");	6✔
11	const Basket = require("../basket");	6✔
12	const getSha1 = require("../sha1-utils");	6✔
13	const mozlog = require("../log");	6✔
14
15	const knexConfig = require("./knexfile");	6✔
16
17	let knex = Knex(knexConfig);	6✔
18	const log = mozlog("DB");	6✔
19
20
21	const DB = {	6✔
22	async getSubscriberByToken(token) {
23	const res = await knex("subscribers")	3✔
24	.where("primary_verification_token", "=", token);
25
26	return res[0];	3✔
27	},
28
29	async getEmailByToken(token) {
30	const res = await knex("email_addresses")	19✔
31	.where("verification_token", "=", token);
32
33	return res[0];	19✔
34	},
35
36	async getEmailById(emailAddressId) {
37	const res = await knex("email_addresses")	5✔
38	.where("id", "=", emailAddressId);
39
40	return res[0];	5✔
41	},
42
43	async getSubscriberByTokenAndHash(token, emailSha1) {
44	const res = await knex.table("subscribers")	3✔
45	.first()
46	.where({
47	"primary_verification_token": token,
48	"primary_sha1": emailSha1,
49	});
50	return res;	3✔
51	},
52
53	async getSubscriberByEmail(email) {
54	const [subscriber] = await knex("subscribers").where({	19✔
55	"primary_email": email,
56	"primary_verified": true,
57	});
58	if (subscriber) {	19✔
59	subscriber.email_addresses = await knex("email_addresses").where({	18✔
60	"subscriber_id": subscriber.id,
61	});
62	}
63	return subscriber;	19✔
64	},
65
66	async addSubscriberUnverifiedEmailHash(user, email) {
67	const res = await knex("email_addresses").insert({	3✔
68	subscriber_id: user.id,
69	email: email,
70	sha1: getSha1(email),
71	verification_token: uuidv4(),
72	verified: false,
73	}).returning("*");
74	return res[0];	3✔
75	},
76
77	async resetUnverifiedEmailAddress(emailAddressId) {
78	const newVerificationToken = uuidv4();	1✔
79	const res = await knex("email_addresses")	1✔
80	.update({
81	verification_token: newVerificationToken,
82	updated_at: knex.fn.now(),
83	})
84	.where("id", emailAddressId)
85	.returning("*");
86	return res[0];	1✔
87	},
88
89	async verifyEmailHash(token) {
90	const unverifiedEmail = await this.getEmailByToken(token);	2✔
91	if (!unverifiedEmail) {	2!
92	throw new FluentError("Error message for this verification email timed out or something went wrong.");	×
93	}
94	const verifiedEmail = await this._verifyNewEmail(unverifiedEmail);	2✔
95	return verifiedEmail[0];	2✔
96	},
97
98	// TODO: refactor into an upsert? https://jaketrent.com/post/upsert-knexjs/
99	// Used internally, ideally should not be called by consumers.
100	async _getSha1EntryAndDo(sha1, aFoundCallback, aNotFoundCallback) {
101	const existingEntries = await knex("subscribers")	14✔
102	.where("primary_sha1", sha1);
103
104	if (existingEntries.length && aFoundCallback) {	14✔
105	return await aFoundCallback(existingEntries[0]);	4✔
106	}
107
108	if (!existingEntries.length && aNotFoundCallback) {	10!
109	return await aNotFoundCallback();	10✔
110	}
111	},
112
113	// Used internally.
114	async _addEmailHash(sha1, email, signup_language, verified = false) {	×
115	try {	11✔
116	return await this._getSha1EntryAndDo(sha1, async aEntry => {	11✔
117	// Entry existed, patch the email value if supplied.
118	if (email) {	1!
119	const res = await knex("subscribers")	1✔
120	.update({
121	primary_email: email,
122	primary_verified: verified,
123	updated_at: knex.fn.now(),
124	})
125	.where("id", "=", aEntry.id)
126	.returning("*");
127	return res[0];	1✔
128	}
129
130	return aEntry;	×
131	}, async () => {
132	// Always add a verification_token value
133	const verification_token = uuidv4();	10✔
134	const res = await knex("subscribers")	10✔
135	.insert({ primary_sha1: sha1, primary_email: email, signup_language, primary_verification_token: verification_token, primary_verified: verified })
136	.returning("*");
137	return res[0];	9✔
138	});
139	} catch (e) {
140	throw new FluentError("error-could-not-add-email");	1✔
141	}
142	},
143
144	/**
145	* Add a subscriber:
146	* 1. Add a record to subscribers
147	* 2. Immediately call _verifySubscriber
148	* 3. For FxA subscriber, add refresh token and profile data
149	*
150	* @param {string} email to add
151	* @param {string} fxaRefreshToken from Firefox Account Oauth
152	* @param {string} fxaProfileData from Firefox Account
153	* @returns {object} subscriber knex object added to DB
154	*/
155	async addSubscriber(email, signupLanguage, fxaRefreshToken=null, fxaProfileData=null) {	19✔
156	const emailHash = await this._addEmailHash(getSha1(email), email, signupLanguage, true);	11✔
157	const verified = await this._verifySubscriber(emailHash);	10✔
158	const verifiedSubscriber = Array.isArray(verified) ? verified[0] : null;	10!
159	if (fxaRefreshToken \|\| fxaProfileData) {	10✔
160	return this._updateFxAData(verifiedSubscriber, fxaRefreshToken, fxaProfileData);	2✔
161	}
162	return verifiedSubscriber;	8✔
163	},
164
165	/**
166	* When an email is verified, convert it into a subscriber:
167	* 1. Subscribe the hash to HIBP
168	* 2. Update our subscribers record to verified
169	* 3. (if opted in) Subscribe the email to Fx newsletter
170	*
171	* @param {object} emailHash knex object in DB
172	* @returns {object} verified subscriber knex object in DB
173	*/
174	async _verifySubscriber(emailHash) {
175	// TODO: move this "up" into controllers/users ?
176	await HIBP.subscribeHash(emailHash.primary_sha1);	10✔
177
178	const verifiedSubscriber = await knex("subscribers")	10✔
179	.where("primary_email", "=", emailHash.primary_email)
180	.update({
181	primary_verified: true,
182	updated_at: knex.fn.now(),
183	})
184	.returning("*");
185
186	// TODO: move this "up" into controllers/users ?
187	if (emailHash.fx_newsletter) {	10!
188	Basket.subscribe(emailHash.primary_email);	×
189	}
190
191	return verifiedSubscriber;	10✔
192	},
193
194	// Verifies new emails added by existing users
195	async _verifyNewEmail(emailHash) {
196	await HIBP.subscribeHash(emailHash.sha1);	2✔
197
198	const verifiedEmail = await knex("email_addresses")	2✔
199	.where("email", "=", emailHash.email)
200	.update({
201	verified: true,
202	})
203	.returning("*");
204
205	return verifiedEmail;	2✔
206	},
207
208	async getUserEmails(userId) {
209
210	const userEmails = await knex("email_addresses")	1✔
211	.where("subscriber_id", "=", userId)
212	.returning("*");
213
214	return userEmails;	1✔
215	},
216
217	/**
218	* Update fxa_refresh_token and fxa_profile_json for subscriber
219	*
220	* @param {object} subscriber knex object in DB
221	* @param {string} fxaRefreshToken from Firefox Account Oauth
222	* @param {string} fxaProfileData from Firefox Account
223	* @returns {object} updated subscriber knex object in DB
224	*/
225	async _updateFxAData(subscriber, fxaRefreshToken, fxaProfileData) {
226	const fxaUID = JSON.parse(fxaProfileData).uid;	2✔
227	const updated = await knex("subscribers")	2✔
228	.where("id", "=", subscriber.id)
229	.update({
230	fxa_uid: fxaUID,
231	fxa_refresh_token: fxaRefreshToken,
232	fxa_profile_json: fxaProfileData,
233	})
234	.returning("*");
235	const updatedSubscriber = Array.isArray(updated) ? updated[0] : null;	2!
236	return updatedSubscriber;	2✔
237	},
238
239	async setBreachesLastShownNow(subscriber) {
240	// TODO: turn 2 db queries into a single query (also see #942)
241	const nowDateTime = new Date();	1✔
242	const nowTimeStamp = nowDateTime.toISOString();	1✔
243	await knex("subscribers")	1✔
244	.where("id", "=", subscriber.id)
245	.update({
246	breaches_last_shown: nowTimeStamp,
247	});
248	return this.getSubscriberByEmail(subscriber.primary_email);	1✔
249	},
250
251	async setAllEmailsToPrimary(subscriber, allEmailsToPrimary) {
252	const updated = await knex("subscribers")	3✔
253	.where("id", subscriber.id)
254	.update({
255	all_emails_to_primary: allEmailsToPrimary,
256	})
257	.returning("*");
258	const updatedSubscriber = Array.isArray(updated) ? updated[0] : null;	3!
259	return updatedSubscriber;	3✔
260	},
261
262	async removeSubscriber(subscriber) {
263	await knex("email_addresses").where({"subscriber_id": subscriber.id}).del();	1✔
264	await knex("subscribers").where({"id": subscriber.id}).del();	1✔
265	},
266
267	async removeSubscriberByEmail(email) {
268	const sha1 = getSha1(email);	3✔
269	return await this._getSha1EntryAndDo(sha1, async aEntry => {	3✔
270	await knex("subscribers")	3✔
271	.where("id", "=", aEntry.id)
272	.del();
273	log.info("removed-subscriber", { id: aEntry.id });	3✔
274	return aEntry;	3✔
275	}, async () => {
276	log.warn("removed-subscriber-not-found");	×
277	return;	×
278	});
279	},
280
281	async removeSubscriberByToken(token, emailSha1) {
282	const subscriber = await this.getSubscriberByTokenAndHash(token, emailSha1);	3✔
283	if (!subscriber) {	3!
284	return false;	3✔
285	}
286	await knex("subscribers")	×
287	.where({
288	"primary_verification_token": subscriber.primary_verification_token,
289	"primary_sha1": subscriber.primary_sha1,
290	})
291	.del();
292	return subscriber;	×
293	},
294
295	async removeOneSecondaryEmail(emailId) {
296	await knex("email_addresses")	2✔
297	.where({
298	"id": emailId,
299	})
300	.del();
301	return;	2✔
302	},
303
304	async getSubscribersByHashes(hashes) {
305	return await knex("subscribers").whereIn("primary_sha1", hashes).andWhere("primary_verified", "=", true);	16✔
306	},
307
308	async getEmailAddressesByHashes(hashes) {
309	return await knex("email_addresses")	5✔
310	.join("subscribers", "email_addresses.subscriber_id", "=", "subscribers.id")
311	.whereIn("email_addresses.sha1", hashes)
312	.andWhere("email_addresses.verified", "=", true);
313	},
314
315	async deleteUnverifiedSubscribers() {
316	const expiredDateTime = new Date(Date.now() - AppConstants.DELETE_UNVERIFIED_SUBSCRIBERS_TIMER * 1000);	×
317	const expiredTimeStamp = expiredDateTime.toISOString();	×
318	await knex("subscribers")	×
319	.where("primary_verified", false)
320	.andWhere("created_at", "<", expiredTimeStamp)
321	.del();
322	},
323
324	async deleteSubscriberByFxAUID(fxaUID) {
325	await knex("subscribers").where("fxa_uid", fxaUID).del();	1✔
326	},
327
328	async createConnection() {
329	if (knex === null) {	6!
330	knex = Knex(knexConfig);	×
331	}
332	},
333
334	async destroyConnection() {
335	await knex.destroy();	6✔
336	knex = null;	×
337	},
338
339	};
340
341	module.exports = DB;	6✔

mozilla / blurts-server / 4297

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