How to use moment-timezone - 10 common examples

console.log("all work sessions:");
							console.log(workSessions);

							var endTime = moment();
							// IF you chose a new task not on your list to have completed
							if (differentCompletedTask) {

								var minutes; // calculate time worked on that task
								if (workSessions.length > 0) {

									// use this to get how long the
									// custom added task took
									var startSession = workSessions[0];
									var startTime    = moment(startSession.startTime);
									minutes          = moment.duration(endTime.diff(startTime)).asMinutes();

								} else {
									// this should never happen.
									minutes = 30; // but if it does... default minutes duration
								}

								// create new task that the user just got done
								user.getDailyTasks({
									where: [ `"DailyTask"."type" = ?`, "live" ]
								})
								.then((dailyTasks) => {
									const priority = dailyTasks.length+1;
									const text     = differentCompletedTask;
									// record the different completed task
									models.Task.create({
										text,

import moment from 'moment-timezone';

// Init locale for moment
moment.locale(navigator.language);

// Initialise moment timezone
const tz = moment.tz.guess();
if (!tz) {
  console.error('DateUtils: TimeZone could not be determined. This should not happen!');
}

const yearRegex = / ?YY(YY)?/;

const Hours = {
  Morning: 9,
  Evening: 20,
  Midnight: 24,
};

const Days = {

rows.forEach((row, index) => {
      row = row.split(']').join('').trim().split(',');

      // First column contains the hour of the recordings
      var date = moment.tz(row[0], 'HH:mm', 'Europe/Stockholm').date(moment().date());

      // Adapt date to yesterday for the relevant measurements
      if (date > moment(rows[rows.length - 1], 'HH:mm').date(moment().date())) {
        date.subtract(1, 'day');
      }

      date = {utc: date.toDate(), local: date.format()};

      // Now loop over all the measurements, for now just try and insert them
      // all and let them fail at insert time. This could probably be more
      // efficient.
      legend.forEach((e, i) => {
        // Filter out time or background columns
        if (e === 'Tid' || e.includes('bakgrund')) {
          return;
        }

        var city = 'Stockholm';
        if (e.includes('Uppsala')) city = 'Uppsala';

exports.fetchData = function (source, cb) {
  // A workaround to getting rate limited for 6 logins in 1 hr for AirNow
  // system. Only try to grab data in last 20 minutes of an hour.
  if (moment().minute() < 40) {
    return cb(null, {name: 'unused', measurements: []});
  }

  // First fetch the stations list and then get the latest measurements
  const file = 'Locations/monitoring_site_locations.dat';
  const lineToObj = function (line) {
    const convertCity = function (city) {
      if (!city) {
        return;
      }

      return city.split(',')[0].trim();
    };

    return {
      aqsid: line[0],

const niceParameter = function (parameter) {
      switch (parameter) {
        case 'OZONE':
          return 'o3';
        case 'PM2.5':
          return 'pm25';
        default:
          return parameter.toLowerCase();
      }
    };

    // Get the measurements
    // Filename should be the current time in UTC like '2016030616' and then
    // get the previous hours measurements
    const dateString = moment.utc().subtract(1, 'hours').format('YYYYMMDDHH');
    const file = `HourlyData/${dateString}.dat`;
    const lineToObj = function (line) {
      return {
        aqsid: line[2],
        day: line[0],
        hour: line[1],
        location: line[3].trim(),
        timezoneOffset: Number(line[4]),
        parameter: niceParameter(line[5]),
        unit: niceUnit(line[6]),
        value: Number(line[7]),
        attribution: [{name: 'US EPA AirNow', url: 'http://www.airnow.gov/'}, {name: line[8].trim()}],
        averagingPeriod: {unit: 'hours', value: 1}
      };
    };
    getObjects(source.url, file, lineToObj, (err, measurements) => {

.then((dailyTasks) => {

									// if there is an already open session we will store it
									// and if it is paused

									let now           = moment();
									let endTime       = moment(openWorkSession.endTime);
									let endTimeString = endTime.format("h:mm a");
									let minutes       = Math.round(moment.duration(endTime.diff(now)).asMinutes());
									var minutesString = convertMinutesToHoursString(minutes);

									let dailyTaskTexts = dailyTasks.map((dailyTask) => {
										return dailyTask.dataValues.Task.text;
									});

									let sessionTasks = commaSeparateOutTaskArray(dailyTaskTexts);

									currentSession = {
										minutes,
										minutesString,
										sessionTasks,
										endTimeString,

}

      // If you've never opened the menu before, then return the last daily batch, else
      // create batch for all periods that happened since you last opened it
      const startDate = lastOpened ? moment.min(oneWeekPrior, moment(lastOpened)) : oneWeekPrior
      return {
        start: startDate.toDate(),
        end: lastWeeklyReset.toDate(),
      };
    }
    case "realtime":
      if (!lastOpened) {
        // If set to realtime and never opened before (eg, you just changed the
        // setting), default to the last 24 hours.
        return {
          start: moment().subtract(1, 'days').toDate(),
          end: now
        }
      } else {
        return {
          start: lastOpened,
          end: now
        }
      }
  }
}

timeLabelAsRange(interval, point) {
    const timeMoment = moment(point.x * 1000);
    const nextMoment = timeMoment.clone().add(interval - 1, 'second');
    const format = this.use24Hours() ? 'MMM Do, HH:mm' : 'MMM Do, h:mm a';

    // e.g. Aug 23rd, 12:50 pm
    return (
      <span>
        {timeMoment.format(format)}
        →
        {nextMoment.format(format)}
      </span>
    );
  }

schoolHomeFeatureEligibilityPresenter.getPresentationData = (checkWindowData, timezone) => {
  const currentDate = moment.tz(timezone || config.DEFAULT_TIMEZONE)
  const featureEligibilityData = {}
  const resultsPublishedDate = checkWindowData.checkEndDate.clone()
    .add(1, 'weeks').isoWeekday('Monday')
    .utcOffset(currentDate.utcOffset(), true)
    .set({ hour: 6, minutes: 0, seconds: 0 })

  // Pin generation
  featureEligibilityData.familiarisationCheckStartDate = dateService.formatFullGdsDate(checkWindowData.familiarisationCheckStartDate)
  featureEligibilityData.familiarisationCheckEndDate = dateService.formatFullGdsDate(checkWindowData.familiarisationCheckEndDate)
  featureEligibilityData.liveCheckStartDate = dateService.formatFullGdsDate(checkWindowData.checkStartDate)
  featureEligibilityData.liveCheckEndDate = dateService.formatFullGdsDate(checkWindowData.checkEndDate)

  // Results
  featureEligibilityData.resultsPublishedDate = dateService.formatFullGdsDate(resultsPublishedDate)

  // TODO: logic related properties should get refactored into services

_calculateStartMoment(props) {
    let start;

    // NOTE: Since we initialize a new time from one of the properties of
    // the props.currentMomet, we need to check for the timezone!
    //
    // Other relative operations (like adding or subtracting time) are
    // independent of a timezone.
    const tz = props.currentMoment.tz();
    if (tz) {
      start = moment.tz([props.currentMoment.year()], tz);
    } else {
      start = moment([props.currentMoment.year()]);
    }

    start = start
      .weekday(0)
      .week(props.currentMoment.week())
      .subtract(BUFFER_DAYS, 'days');
    return start;
  }