11223

pending completion

Build # 11223

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #2206 from mozilla/show-delete-output-874

fix #874: show deleted rows in info log

Run Details

265 of 793 branches covered (33.42%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

899 of 2203 relevant lines covered (40.81%)

3.01 hits per line

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

80.79

/db/DB.js

"use strict";


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

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

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

let knex = Knex(knexConfig);
attachPaginate();

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 joinEmailAddressesToSubscriber(subscriber) {
    if (subscriber) {
      const emailAddressRecords = await knex("email_addresses").where({
        "subscriber_id": subscriber.id,
      });
      subscriber.email_addresses = emailAddressRecords.map(
        emailAddress=>({id: emailAddress.id, email: emailAddress.email})
      );
    }
    return subscriber;
  },

  async getSubscriberById(id) {
    const [subscriber] = await knex("subscribers").where({
      "id": id,
    });
    const subscriberAndEmails = await this.joinEmailAddressesToSubscriber(subscriber);
    return subscriberAndEmails;
  },

  async getSubscriberByFxaUid(uid) {
    const [subscriber] = await knex("subscribers").where({
      "fxa_uid": uid,
    });
    const subscriberAndEmails = await this.joinEmailAddressesToSubscriber(subscriber);
    return subscriberAndEmails;
  },

  async getPreFxaSubscribersPage(pagination) {
    return await knex("subscribers")
      .whereRaw("(fxa_uid = '') IS NOT FALSE")
      .paginate(pagination);

  },

  async getSubscriberByEmail(email) {
    const [subscriber] = await knex("subscribers").where({
      "primary_email": email,
      "primary_verified": true,
    });
    const subscriberAndEmails = await this.joinEmailAddressesToSubscriber(subscriber);
    return subscriberAndEmails;
  },

  async getEmailAddressRecordByEmail(email) {
    const emailAddresses = await knex("email_addresses").where({
      "email": email, verified: true,
    });
    if (!emailAddresses) {
      return null;
    }
    if (emailAddresses.length > 1) {
      // TODO: handle multiple emails in separate(?) subscriber accounts?
      log.warn("getEmailAddressRecordByEmail", {msg: "found the same email multiple times"});
    }
    return emailAddresses[0];
  },


  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_sha1: getSha1(email.toLowerCase()),
              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: getSha1(email.toLowerCase()), 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} signupLanguage from Accept-Language
   * @param {string} fxaAccessToken from Firefox Account Oauth
   * @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, fxaAccessToken=null, 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, fxaAccessToken, 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("*");

    return verifiedSubscriber;
  },

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

    const verifiedEmail = await knex("email_addresses")
      .where("id", "=", emailHash.id)
      .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} fxaAccessToken from Firefox Account Oauth
   * @param {string} fxaRefreshToken from Firefox Account Oauth
   * @param {string} fxaProfileData from Firefox Account
   * @returns {object} updated subscriber knex object in DB
   */
  async _updateFxAData(subscriber, fxaAccessToken, fxaRefreshToken, fxaProfileData) {
    const fxaUID = JSON.parse(fxaProfileData).uid;
    const updated = await knex("subscribers")
    .where("id", "=", subscriber.id)
    .update({
      fxa_uid: fxaUID,
      fxa_access_token: fxaAccessToken,
      fxa_refresh_token: fxaRefreshToken,
      fxa_profile_json: fxaProfileData,
    })
    .returning("*");
    const updatedSubscriber = Array.isArray(updated) ? updated[0] : null;
    if (updatedSubscriber) {
      FXA.destroyOAuthToken({refresh_token: subscriber.fxa_refresh_token});
    }
    return updatedSubscriber;
  },

  async updateFxAProfileData(subscriber, fxaProfileData) {
    await knex("subscribers").where("id", subscriber.id)
    .update({
      fxa_profile_json: fxaProfileData,
    });
    return this.getSubscriberById(subscriber.id);
  },

  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 setBreachesResolved(options) {
    const { user, updatedResolvedBreaches } = options;
    await knex("subscribers")
    .where("id", user.id)
    .update({
      breaches_resolved: updatedResolvedBreaches,
    });
    return this.getSubscriberByEmail(user.primary_email);
  },

  async setWaitlistsJoined(options) {
    const { user, updatedWaitlistsJoined } = options;
    await knex("subscribers")
      .where("id", user.id)
      .update({
        waitlists_joined: updatedWaitlistsJoined,
      });
    return this.getSubscriberByEmail(user.primary_email);
  },

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

  // This is used by SES callbacks to remove email addresses when recipients
  // perma-bounce or mark our emails as spam
  // Removes from either subscribers or email_addresses as necessary
  async removeEmail(email) {
    const subscriber = await this.getSubscriberByEmail(email);
    if (!subscriber) {
      const emailAddress = await this.getEmailAddressRecordByEmail(email);
      if (!emailAddress) {
        log.warn("removed-subscriber-not-found");
        return;
      }
      await knex("email_addresses")
        .where({
          "email": email,
          "verified": true,
        })
        .del();
      return;
    }
    // This can fail if a subscriber has more email_addresses and marks
    // a primary email as spam, but we should let it fail so we can see it
    // in the logs
    await knex("subscribers")
      .where({
        "primary_verification_token": subscriber.primary_verification_token,
        "primary_sha1": subscriber.primary_sha1,
      })
      .del();
    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();
    const numDeleted = await knex("subscribers")
      .where("primary_verified", false)
      .andWhere("created_at", "<", expiredTimeStamp)
      .del();
    log.info("deleteUnverifiedSubscribers", {msg:`Deleted ${numDeleted} rows.`});
  },

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

  async deleteEmailAddressesByUid(uid) {
    await knex("email_addresses").where({"subscriber_id": uid}).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");	8✔
6	const Knex = require("knex");	8✔
7	const { attachPaginate } = require("knex-paginate");	8✔
8
9	const { FluentError } = require("../locale-utils");	8✔
10	const AppConstants = require("../app-constants");	8✔
11	const { FXA } = require("../lib/fxa");	8✔
12	const HIBP = require("../hibp");	8✔
13	const getSha1 = require("../sha1-utils");	8✔
14	const mozlog = require("../log");	8✔
15
16	const knexConfig = require("./knexfile");	8✔
17
18	let knex = Knex(knexConfig);	8✔
19	attachPaginate();	8✔
20
21	const log = mozlog("DB");	8✔
22
23
24	const DB = {	8✔
25	async getSubscriberByToken(token) {
26	const res = await knex("subscribers")	5✔
27	.where("primary_verification_token", "=", token);
28
29	return res[0];	5✔
30	},
31
32	async getEmailByToken(token) {
33	const res = await knex("email_addresses")	24✔
34	.where("verification_token", "=", token);
35
36	return res[0];	24✔
37	},
38
39	async getEmailById(emailAddressId) {
40	const res = await knex("email_addresses")	9✔
41	.where("id", "=", emailAddressId);
42
43	return res[0];	9✔
44	},
45
46	async getSubscriberByTokenAndHash(token, emailSha1) {
47	const res = await knex.table("subscribers")	3✔
48	.first()
49	.where({
50	"primary_verification_token": token,
51	"primary_sha1": emailSha1,
52	});
53	return res;	3✔
54	},
55
56	async joinEmailAddressesToSubscriber(subscriber) {
57	if (subscriber) {	38✔
58	const emailAddressRecords = await knex("email_addresses").where({	33✔
59	"subscriber_id": subscriber.id,
60	});
61	subscriber.email_addresses = emailAddressRecords.map(	33✔
62	emailAddress=>({id: emailAddress.id, email: emailAddress.email})	57✔
63	);
64	}
65	return subscriber;	38✔
66	},
67
68	async getSubscriberById(id) {
69	const [subscriber] = await knex("subscribers").where({	2✔
70	"id": id,
71	});
72	const subscriberAndEmails = await this.joinEmailAddressesToSubscriber(subscriber);	2✔
73	return subscriberAndEmails;	2✔
74	},
75
76	async getSubscriberByFxaUid(uid) {
77	const [subscriber] = await knex("subscribers").where({	3✔
78	"fxa_uid": uid,
79	});
80	const subscriberAndEmails = await this.joinEmailAddressesToSubscriber(subscriber);	3✔
81	return subscriberAndEmails;	3✔
82	},
83
84	async getPreFxaSubscribersPage(pagination) {
85	return await knex("subscribers")	×
86	.whereRaw("(fxa_uid = '') IS NOT FALSE")
87	.paginate(pagination);
88
89	},
90
91	async getSubscriberByEmail(email) {
92	const [subscriber] = await knex("subscribers").where({	33✔
93	"primary_email": email,
94	"primary_verified": true,
95	});
96	const subscriberAndEmails = await this.joinEmailAddressesToSubscriber(subscriber);	33✔
97	return subscriberAndEmails;	33✔
98	},
99
100	async getEmailAddressRecordByEmail(email) {
101	const emailAddresses = await knex("email_addresses").where({	3✔
102	"email": email, verified: true,
103	});
104	if (!emailAddresses) {	3!
105	return null;	×
106	}
107	if (emailAddresses.length > 1) {	3!
108	// TODO: handle multiple emails in separate(?) subscriber accounts?
109	log.warn("getEmailAddressRecordByEmail", {msg: "found the same email multiple times"});	×
110	}
111	return emailAddresses[0];	3✔
112	},
113
114
115	async addSubscriberUnverifiedEmailHash(user, email) {
116	const res = await knex("email_addresses").insert({	7✔
117	subscriber_id: user.id,
118	email: email,
119	sha1: getSha1(email),
120	verification_token: uuidv4(),
121	verified: false,
122	}).returning("*");
123	return res[0];	7✔
124	},
125
126	async resetUnverifiedEmailAddress(emailAddressId) {
127	const newVerificationToken = uuidv4();	1✔
128	const res = await knex("email_addresses")	1✔
129	.update({
130	verification_token: newVerificationToken,
131	updated_at: knex.fn.now(),
132	})
133	.where("id", emailAddressId)
134	.returning("*");
135	return res[0];	1✔
136	},
137
138	async verifyEmailHash(token) {
139	const unverifiedEmail = await this.getEmailByToken(token);	4✔
140	if (!unverifiedEmail) {	4!
141	throw new FluentError("Error message for this verification email timed out or something went wrong.");	×
142	}
143	const verifiedEmail = await this._verifyNewEmail(unverifiedEmail);	4✔
144	return verifiedEmail[0];	4✔
145	},
146
147	// TODO: refactor into an upsert? https://jaketrent.com/post/upsert-knexjs/
148	// Used internally, ideally should not be called by consumers.
149	async _getSha1EntryAndDo(sha1, aFoundCallback, aNotFoundCallback) {
150	const existingEntries = await knex("subscribers")	13✔
151	.where("primary_sha1", sha1);
152
153	if (existingEntries.length && aFoundCallback) {	13✔
154	return await aFoundCallback(existingEntries[0]);	1✔
155	}
156
157	if (!existingEntries.length && aNotFoundCallback) {	12!
158	return await aNotFoundCallback();	12✔
159	}
160	},
161
162	// Used internally.
163	async _addEmailHash(sha1, email, signup_language, verified = false) {	×
164	try {	13✔
165	return await this._getSha1EntryAndDo(sha1, async aEntry => {	13✔
166	// Entry existed, patch the email value if supplied.
167	if (email) {	1!
168	const res = await knex("subscribers")	1✔
169	.update({
170	primary_email: email,
171	primary_sha1: getSha1(email.toLowerCase()),
172	primary_verified: verified,
173	updated_at: knex.fn.now(),
174	})
175	.where("id", "=", aEntry.id)
176	.returning("*");
177	return res[0];	1✔
178	}
179
180	return aEntry;	×
181	}, async () => {
182	// Always add a verification_token value
183	const verification_token = uuidv4();	12✔
184	const res = await knex("subscribers")	12✔
185	.insert({ primary_sha1: getSha1(email.toLowerCase()), primary_email: email, signup_language, primary_verification_token: verification_token, primary_verified: verified })
186	.returning("*");
187	return res[0];	11✔
188	});
189	} catch (e) {
190	throw new FluentError("error-could-not-add-email");	1✔
191	}
192	},
193
194	/**
195	* Add a subscriber:
196	* 1. Add a record to subscribers
197	* 2. Immediately call _verifySubscriber
198	* 3. For FxA subscriber, add refresh token and profile data
199	*
200	* @param {string} email to add
201	* @param {string} signupLanguage from Accept-Language
202	* @param {string} fxaAccessToken from Firefox Account Oauth
203	* @param {string} fxaRefreshToken from Firefox Account Oauth
204	* @param {string} fxaProfileData from Firefox Account
205	* @returns {object} subscriber knex object added to DB
206	*/
207	async addSubscriber(email, signupLanguage, fxaAccessToken=null, fxaRefreshToken=null, fxaProfileData=null) {	34✔
208	const emailHash = await this._addEmailHash(getSha1(email), email, signupLanguage, true);	13✔
209	const verified = await this._verifySubscriber(emailHash);	12✔
210	const verifiedSubscriber = Array.isArray(verified) ? verified[0] : null;	12!
211	if (fxaRefreshToken \|\| fxaProfileData) {	12✔
212	return this._updateFxAData(verifiedSubscriber, fxaAccessToken, fxaRefreshToken, fxaProfileData);	2✔
213	}
214	return verifiedSubscriber;	10✔
215	},
216
217	/**
218	* When an email is verified, convert it into a subscriber:
219	* 1. Subscribe the hash to HIBP
220	* 2. Update our subscribers record to verified
221	* 3. (if opted in) Subscribe the email to Fx newsletter
222	*
223	* @param {object} emailHash knex object in DB
224	* @returns {object} verified subscriber knex object in DB
225	*/
226	async _verifySubscriber(emailHash) {
227	// TODO: move this "up" into controllers/users ?
228	await HIBP.subscribeHash(emailHash.primary_sha1);	12✔
229
230	const verifiedSubscriber = await knex("subscribers")	12✔
231	.where("primary_email", "=", emailHash.primary_email)
232	.update({
233	primary_verified: true,
234	updated_at: knex.fn.now(),
235	})
236	.returning("*");
237
238	return verifiedSubscriber;	12✔
239	},
240
241	// Verifies new emails added by existing users
242	async _verifyNewEmail(emailHash) {
243	await HIBP.subscribeHash(emailHash.sha1);	4✔
244
245	const verifiedEmail = await knex("email_addresses")	4✔
246	.where("id", "=", emailHash.id)
247	.update({
248	verified: true,
249	})
250	.returning("*");
251
252	return verifiedEmail;	4✔
253	},
254
255	async getUserEmails(userId) {
256
257	const userEmails = await knex("email_addresses")	6✔
258	.where("subscriber_id", "=", userId)
259	.returning("*");
260
261	return userEmails;	6✔
262	},
263
264	/**
265	* Update fxa_refresh_token and fxa_profile_json for subscriber
266	*
267	* @param {object} subscriber knex object in DB
268	* @param {string} fxaAccessToken from Firefox Account Oauth
269	* @param {string} fxaRefreshToken from Firefox Account Oauth
270	* @param {string} fxaProfileData from Firefox Account
271	* @returns {object} updated subscriber knex object in DB
272	*/
273	async _updateFxAData(subscriber, fxaAccessToken, fxaRefreshToken, fxaProfileData) {
274	const fxaUID = JSON.parse(fxaProfileData).uid;	3✔
275	const updated = await knex("subscribers")	3✔
276	.where("id", "=", subscriber.id)
277	.update({
278	fxa_uid: fxaUID,
279	fxa_access_token: fxaAccessToken,
280	fxa_refresh_token: fxaRefreshToken,
281	fxa_profile_json: fxaProfileData,
282	})
283	.returning("*");
284	const updatedSubscriber = Array.isArray(updated) ? updated[0] : null;	3!
285	if (updatedSubscriber) {	3!
286	FXA.destroyOAuthToken({refresh_token: subscriber.fxa_refresh_token});	3✔
287	}
288	return updatedSubscriber;	3✔
289	},
290
291	async updateFxAProfileData(subscriber, fxaProfileData) {
292	await knex("subscribers").where("id", subscriber.id)	×
293	.update({
294	fxa_profile_json: fxaProfileData,
295	});
296	return this.getSubscriberById(subscriber.id);	×
297	},
298
299	async setBreachesLastShownNow(subscriber) {
300	// TODO: turn 2 db queries into a single query (also see #942)
301	const nowDateTime = new Date();	3✔
302	const nowTimeStamp = nowDateTime.toISOString();	3✔
303	await knex("subscribers")	3✔
304	.where("id", "=", subscriber.id)
305	.update({
306	breaches_last_shown: nowTimeStamp,
307	});
308	return this.getSubscriberByEmail(subscriber.primary_email);	3✔
309	},
310
311	async setAllEmailsToPrimary(subscriber, allEmailsToPrimary) {
312	const updated = await knex("subscribers")	3✔
313	.where("id", subscriber.id)
314	.update({
315	all_emails_to_primary: allEmailsToPrimary,
316	})
317	.returning("*");
318	const updatedSubscriber = Array.isArray(updated) ? updated[0] : null;	3!
319	return updatedSubscriber;	3✔
320	},
321
322	async setBreachesResolved(options) {
323	const { user, updatedResolvedBreaches } = options;	×
324	await knex("subscribers")	×
325	.where("id", user.id)
326	.update({
327	breaches_resolved: updatedResolvedBreaches,
328	});
329	return this.getSubscriberByEmail(user.primary_email);	×
330	},
331
332	async setWaitlistsJoined(options) {
333	const { user, updatedWaitlistsJoined } = options;	×
334	await knex("subscribers")	×
335	.where("id", user.id)
336	.update({
337	waitlists_joined: updatedWaitlistsJoined,
338	});
339	return this.getSubscriberByEmail(user.primary_email);	×
340	},
341
342	async removeSubscriber(subscriber) {
343	await knex("email_addresses").where({"subscriber_id": subscriber.id}).del();	2✔
344	await knex("subscribers").where({"id": subscriber.id}).del();	2✔
345	},
346
347	// This is used by SES callbacks to remove email addresses when recipients
348	// perma-bounce or mark our emails as spam
349	// Removes from either subscribers or email_addresses as necessary
350	async removeEmail(email) {
351	const subscriber = await this.getSubscriberByEmail(email);	5✔
352	if (!subscriber) {	5✔
353	const emailAddress = await this.getEmailAddressRecordByEmail(email);	2✔
354	if (!emailAddress) {	2✔
355	log.warn("removed-subscriber-not-found");	1✔
356	return;	1✔
357	}
358	await knex("email_addresses")	1✔
359	.where({
360	"email": email,
361	"verified": true,
362	})
363	.del();
364	return;	1✔
365	}
366	// This can fail if a subscriber has more email_addresses and marks
367	// a primary email as spam, but we should let it fail so we can see it
368	// in the logs
369	await knex("subscribers")	3✔
370	.where({
371	"primary_verification_token": subscriber.primary_verification_token,
372	"primary_sha1": subscriber.primary_sha1,
373	})
374	.del();
375	return;	3✔
376	},
377
378	async removeSubscriberByToken(token, emailSha1) {
379	const subscriber = await this.getSubscriberByTokenAndHash(token, emailSha1);	3✔
380	if (!subscriber) {	3!
381	return false;	3✔
382	}
383	await knex("subscribers")	×
384	.where({
385	"primary_verification_token": subscriber.primary_verification_token,
386	"primary_sha1": subscriber.primary_sha1,
387	})
388	.del();
389	return subscriber;	×
390	},
391
392	async removeOneSecondaryEmail(emailId) {
393	await knex("email_addresses")	2✔
394	.where({
395	"id": emailId,
396	})
397	.del();
398	return;	2✔
399	},
400
401	async getSubscribersByHashes(hashes) {
402	return await knex("subscribers").whereIn("primary_sha1", hashes).andWhere("primary_verified", "=", true);	16✔
403	},
404
405	async getEmailAddressesByHashes(hashes) {
406	return await knex("email_addresses")	5✔
407	.join("subscribers", "email_addresses.subscriber_id", "=", "subscribers.id")
408	.whereIn("email_addresses.sha1", hashes)
409	.andWhere("email_addresses.verified", "=", true);
410	},
411
412	async deleteUnverifiedSubscribers() {
413	const expiredDateTime = new Date(Date.now() - AppConstants.DELETE_UNVERIFIED_SUBSCRIBERS_TIMER * 1000);	×
414	const expiredTimeStamp = expiredDateTime.toISOString();	×
415	const numDeleted = await knex("subscribers")	×
416	.where("primary_verified", false)
417	.andWhere("created_at", "<", expiredTimeStamp)
418	.del();
419	log.info("deleteUnverifiedSubscribers", {msg:`Deleted ${numDeleted} rows.`});	×
420	},
421
422	async deleteSubscriberByFxAUID(fxaUID) {
423	await knex("subscribers").where("fxa_uid", fxaUID).del();	1✔
424	},
425
426	async deleteEmailAddressesByUid(uid) {
427	await knex("email_addresses").where({"subscriber_id": uid}).del();	×
428	},
429
430	async createConnection() {
431	if (knex === null) {	7!
432	knex = Knex(knexConfig);	×
433	}
434	},
435
436	async destroyConnection() {
437	await knex.destroy();	7✔
438	knex = null;	×
439	},
440
441	};
442
443	module.exports = DB;	8✔

mozilla / blurts-server / 11223

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