protected getDate(date: any, defaultValue: any = null) {
    if (!date) {
      return defaultValue;
    }

    return moment(date)
      .tz(this.timezone)
      .format(DATE_FORMAT);
  }

    function diffWithCurrentTime(team: Team) {
        let currentTime = moment();

        let endTime = moment(team.endQuestDate);


        return endTime.diff(currentTime, 'seconds');
    }

 it('understands cron intervals with a timezone when last run is the same as the interval', () => {
     job.attrs.lastRunAt = new Date('2015-01-01T06:00:00-00:00');
     job.repeatEvery('0 6 * * *', {
         timezone: 'GMT'
     });
     job.computeNextRunAt();
     expect(moment(job.attrs.nextRunAt).tz('GMT').hour()).to.be(6);
     expect(moment(job.attrs.nextRunAt).toDate().getDate()).to.be(moment(job.attrs.lastRunAt).add(1, 'days').toDate().getDate());
 });

  public async downloadEarnings(): Promise<void> {
    const date: Date = moment().tz("America/New_York").toDate();
    const dateStr: string = moment().tz("America/New_York").format("YYYY-MM-DD");
    const dateThreshold: Date = moment().add(5, "days").tz("America/New_York").toDate();
    const currentSeason = await this.sql.getSelectedSeason(undefined);
    if (currentSeason === undefined || currentSeason.getEndDate() < date) {
      return;
    }

    const moviesToGet = Enumerable.from(currentSeason.movies)
      .where((m) => m.releaseDate <= dateThreshold)
      .orderByDescending((m) => m.releaseDate)
      .toArray();

    let earnings: Earning[] = [];
    for (const url of currentSeason.urls) {
      const html = await this.http.download(url.url, {});
      const rows = MojoParser.parse(html);
      const earningsToAdd = MojoParser.getEarnings(rows, moviesToGet);
      earnings = earnings.concat(earningsToAdd);
    }

    for (const earning of earnings) {
      const value = accounting.formatMoney(earning.gross, "$", 0);
      this.output.write(`${earning.movie.name}: ${value}\n`);
    }

    await this.sql.deleteEarningsForDate(dateStr);
    const addPromise = this.sql.addEarningsForMovies(earnings);

    this.output.write("\n");

    const ratingsPromises: Array<Promise<void>> = [];
    for (const movie of moviesToGet) {
      if (movie.metacriticUrl === undefined) {
        continue;
      }
      const rating = await this.getRating(movie.metacriticUrl, 0);
      if (rating === undefined) {
        continue;
      }
      ratingsPromises.push(this.sql.updateRatingForMovie(movie, rating));
      this.output.write(`${movie.name}: ${rating}%\n`);
    }

    await addPromise;
    await Promise.all(ratingsPromises);
  }

 parse(value: string): NgbDateStruct {
   const inst: any = moment(value, DATE_FORMAT);
   return {
     year: inst.year(),
     month: inst.month() + 1, // moment return 0-11 for month
     day: inst.date(),
   };
 }

    endDateBeforeRender($view, $dates): void {
        if (this.editor.StartDate) {
            const activeDate: moment.Moment = moment(this.editor.StartDate).subtract(1, $view).add(1, "minute");

            $dates.filter(date => date.localDateValue() <= activeDate.valueOf())
                .forEach(date => date.selectable = false);
        }
    }

    startDateBeforeRender($dates): void {
        if (this.editor.EndDate) {
            const activeDate: moment.Moment = moment(this.editor.EndDate);

            $dates.filter(date => date.localDateValue() >= activeDate.valueOf())
                .forEach(date => date.selectable = false);
        }
    }

  format(date: NgbDateStruct): string {
    if (date == null) {
      return '';
    }

    const inst: any = moment();
    inst.set('year', date.year);
    inst.set('month', date.month - 1); // moment month is from 0-11
    inst.set('date', date.day);

    return inst.format(DATE_FORMAT);
  }

	export const upsertDevice = (memberid: string, device: string): Promise<any> =>

		DeviceTrackingModel.findOneAndUpdate(
			{
				memberid: memberid,
				device: device
			},
			{
				$set: {
					memberid: memberid,
					device: device,
					lastUsed: moment()
				}
			},
			UPSERT_OPTIONS);

    it("#formattedDate", () => {
        const dateTimeFormClass: DatetimeFormClass = new DatetimeFormClass($scope);
        const dateTime: moment.Moment = moment("2018-12-03");

        expect(dateTimeFormClass.formattedDate(dateTime)).toEqual("3 December 2018");
    });