socket.on('roomCheck', function(req){
var now = moment(),
conflict = 0;
for (var j = 0; j < resourceData.length; j++) {
for (var k = 0; k < resourceData[j].events.length; k++) {
if (req == 'C02C05') {
if (resourceData[j].events[k].resourceId == 'C02' || resourceData[j].events[k].resourceId == 'C05') {
var range = moment.range(resourceData[j].events[k].start, resourceData[j].events[k].end)
if (now.within(range)) {
conflict++
break
}
}
}
else if (resourceData[j].events[k].resourceId == req) {
var range = moment.range(resourceData[j].events[k].start, resourceData[j].events[k].end)
if (now.within(range)) {
conflict++
break
}
}
}
}
if (conflict > 0) {
io.to(socket.id).emit('roomFree', false)
}
else {
io.to(socket.id).emit('roomFree', true)
}
})
it('returns true if the two ranges start and finish on the same day', function () {
var start = new Date(2012, 0, 15);
var end = new Date(2012, 4, 23);
var range1 = moment.range(start, end);
var range2 = moment.range(start, end);
expect(areMomentRangesEqual(range1, range2)).toBe(true);
});
it('returns false if the two ranges finish on the same day but start on different days', function () {
var start1 = new Date(2012, 0, 15);
var start2 = new Date(2012, 0, 16);
var end = new Date(2012, 4, 23);
var range1 = moment.range(start1, end);
var range2 = moment.range(start2, end);
expect(areMomentRangesEqual(range1, range2)).toBe(false);
});
it('should arrange points into ranges', () => {
const points = {
a: {
date: '2016-05-01T00:00:00.000Z',
value: 'foo',
},
b: {
date: '2016-05-10T00:00:00.000Z',
value: 'foo',
},
c: {
date: '2016-05-20T00:00:00.000Z',
value: 'foo',
},
d: {
date: '2016-05-30T00:00:00.000Z',
value: 'foo',
},
e: {
date: '2016-06-10T00:00:00.000Z',
value: 'foo',
},
f: {
date: '2016-06-20T00:00:00.000Z',
value: 'foo',
},
};
const ranges = pointsToRanges(values(points), [
moment.range('2016-05-01T00:00:00.000Z', '2016-05-11T00:00:00.000Z'),
moment.range('2016-05-11T00:00:00.000Z', '2016-05-12T00:00:00.000Z'),
moment.range('2016-05-12T00:00:00.000Z', '2016-06-10T00:00:00.000Z'),
moment.range('2016-06-10T00:00:00.000Z', '2017-01-01T00:00:00.000Z'),
]);
expect(ranges).to.eql([
{
from: '2016-05-01T00:00:00.000Z',
to: '2016-05-11T00:00:00.000Z',
points: [points.a, points.b],
},
{
from: '2016-05-11T00:00:00.000Z',
to: '2016-05-12T00:00:00.000Z',
points: [],
},
{
from: '2016-05-12T00:00:00.000Z',
to: '2016-06-10T00:00:00.000Z',
points: [points.c, points.d],
},
{
from: '2016-06-10T00:00:00.000Z',
to: '2017-01-01T00:00:00.000Z',
points: [points.e, points.f],
},
]);
});
ItemsBuilder.rangeIntersection = function(aStart, aEnd, bStart, bEnd) {
var rangeA = moment.range(moment.utc(aStart), moment.utc(aEnd).clone().add(1, "ms")),
rangeB = moment.range(moment.utc(bStart), moment.utc(bEnd).clone().add(1, "ms")),
intersection = rangeA.intersect(rangeB);
if (intersection) {
return intersection.diff("days");
} else {
return 0;
}
};
socket.on('calendarRequest', function(req) {
var dataCount = 0;
global.debugger('[SOCKET] - Client: Event data request from session ID: ' + socket.id.slice(2) + ', Range: ' + req.start + ' to ' + req.end)
var start = moment(req.start, "YYYY-MM-DD"),
end = moment(req.end, "YYYY-MM-DD"),
resources = req.resources,
range = moment.range(start, end),
eventData = [];
if (resources.length > 0) {
global.debugger('[SOCKET] - Client: Event data request from session ID: ' + req.resources);
for (var i = 0; i < resources.length; i++) {
dataCount++
for (var j = 0; j < resourceData.length; j++) {
if (resources[i] == resourceData[j].title ) {
for (var k = 0; k < resourceData[j].events.length; k++) {
if (resourceData[j].events[k].start) {
var eventRange = moment.range(moment(resourceData[j].events[k].start), moment(resourceData[j].events[k].end));
if (eventRange.overlaps(range)) {
eventData.push(resourceData[j].events[k])
}
}
}
}
}
if (dataCount == resources.length) {
io.to(socket.id).emit('calendarData', { id: 'CALDAV', events: eventData } )
global.debugger('[SOCKET] - Client: Event data sent to session ID: ' + socket.id.slice(2) + ', Resources: ' + resources + ', Range: ' + req.start + ' to ' + req.end)
}
}
}
else if (resources.length == 0) {
if (resourceData.length == 0) {
io.to(socket.id).emit('calendarData', [])
global.debugger('[SOCKET] - Client: Empty data sent to session ID: ' + socket.id.slice(2) + ', Resources: No data to send, Range: ' + req.start + ' to ' + req.end)
}
else {
for (var j = 0; j < resourceData.length; j++) {
for (var k = 0; k < resourceData[j].events.length; k++) {
var eventRange = moment.range(moment(resourceData[j].events[k].start), moment(resourceData[j].events[k].end));
if (eventRange.overlaps(range)) {
eventData.push(resourceData[j].events[k])
}
}
}
io.to(socket.id).emit('calendarData', { id: 'CALDAV', events: eventData } )
global.debugger('[SOCKET] - Client: Event data sent to session ID: ' + socket.id.slice(2) + ', Resources: All, Range: ' + req.start + ' to ' + req.end)
}
}
});
request.exec(function(error, user){
if(error)
var message = { code: "error:db-update"};
res.status(500);
if(user){
console.log(moment.range(user.lastSearch, new Date()).diff('days'));
if(moment.range(user.lastSearch, new Date()).diff('days') >= 1 || !user.lastSearch){
var message = {code: "response:ok-run-cycle", content: true};
}else{
var message = {code: "response:forbidden-run-cycle", content: false};
}
res.status(200);
}
res.send(message);
});
export function getMonthsForYear(year, min, max) {
var months = void 0;
if (min && min.year() == year) {
months = moment.range([min, max && max.year() == year ? max : moment(min).endOf('year')]);
} else if (max && max.year() == year) {
months = moment.range([min && min.year() == year ? min : moment(year, 'YYYY').startOf('year'), max]);
} else if (year) {
months = moment(year, 'YYYY').range('year');
} else {
months = moment().range('year');
}
return months.toArray('months');
}
function checkIfCompleted(task, currTime, cycleDate, cycle) {
let cycleWithoutS = cycle.slice(0, -1);
let currTimeCycle = isInActiveCycle(task, currTime);
let sinceLastUpdate = moment.range(cycleDate, currentTime);
if(!currTime.isSame(cycleDate, cycleWithoutS) && task.state !== taskState.COMPLETE && currTimeCycle(cycle)) {
sinceLastUpdate.by(cycle, (currCycle) => {
let inCycle = isInActiveCycle(task, currCycle);
if(inCycle(cycle)) {
if(task.occurrence !== occurrence.HOURLY) {
if(!isInNotCompleted(task, currTime) && !currTime.isSame(currCycle, cycleWithoutS)) {
task.notCompleted.push({updatedOn: currCycle.toDate()});
}
} else {
if(!currTime.isSame(currCycle, cycleWithoutS)) {
task.notCompleted.push({updatedOn: currCycle.toDate()});
}
}
}
});
}
}
static toRange(...moments) {
if (!moments || moments.length < 2) {
throw new Error(`Expected at least two moments but found only ${moments}`)
}
return moment.range(Moments.earliest(...moments), Moments.latest(...moments))
}
exports.isInYesterday = function (date) {
date = new Moment(date);
var start = new Moment().subtract(1, 'day').startOf('day');
var end = new Moment().subtract(1, 'day').endOf('day');
var range = Moment.range(start, end);
return range.contains(date);
};
beforeEach(function () {
const nextProps = {
value: moment.range(today(), today().add(2, 'days')),
};
this.result = hasUpdatedValue(this.previousProps, nextProps);
});
beforeEach( function () {
this.props = {
'att-string': 'val1',
'att-moment': moment(),
'att-moment-range': moment.range(),
};
});
var out = dates.map(start => {
var end = start.clone().add(step, 'seconds');
var range = moment.range(start, end);
var existingUsers = users.slice();
var edges = _(interactions)
.filter(interaction => range.contains(moment(interaction.timestamp), false))
.groupBy(interaction => [interaction.source, interaction.replyTo].sort().join('-'))
.map(userInteractions => {
var source = getUser(userInteractions[0].source);
if (userInteractions[0].replyTo) {
var target = getUser(userInteractions[0].replyTo);
return {
source,
target,
'value': userInteractions.length,
'blocked': _.some(userInteractions, 'blocked')
};
}
})
.filter(edge => edge)
.valueOf();
var newUsers = _.difference(users, existingUsers);
var vertices = newUsers.map(user => { return {user, 'blocked': blocks[user]}; });
console.error(start.format(), vertices.length, edges.length);
return {'start': start.format(), vertices, edges};
});
const getCalendarMonth = (props) => {
props = _.extend({
firstOfWeek: 0,
firstOfMonth: this.firstOfMonth,
enabledRange: moment.range(moment(), moment().add(3, 'years')),
dateComponent: CalendarDate,
disableNavigation: false,
dateRangesForDate: function () {
return {
count: function () {
return props.count || 1;
},
getIn: function (data) {
if (data[0] === 0) {
return '#333';
}
return '#444';
},
};
},
onMonthChange: function () {},
onYearChange: function () {},
bemBlock: 'DateRangePicker',
}, props);
return (<CalendarMonth {...props} />);
};
return function (date) {
date = new Moment(date);
var start = new Moment().startOf(type);
var end = new Moment().endOf(type);
var range = Moment.range(start, end);
return range.contains(date);
};
vevents.forEach(function(vevent){
var event = new ICAL.Event(vevent);
if (event.summary) {
var evres = calName,
evname = calName + ' - ' + event.summary,
evid = event.uid,
evHash = crypto.createHash('md5').update(event.toString()).digest('hex');
evstart = moment.utc(event.startDate.toJSDate()).local().format(),
evend = moment.utc(event.endDate.toJSDate()).local().format(),
evdesc = event.description,
evday = d3.time.day(new Date(evstart)),
evweek = d3.time.week(new Date(evstart)),
evmonth = d3.time.month(new Date(evstart)),
evduration = Math.round(moment.duration((moment.range(new Date(evstart), new Date(evend))).valueOf()).asHours() * 100) / 100;
eventArray.push({ id: evid, title: evname, resourceId: evres, className: evres, color: colour, description: evdesc, start: evstart, end: evend, day: evday, week: evweek, month: evmonth, duration: evduration })
if (eventArray.length === vevents.length) {
global.debugger('[IPADCALENDARS] - ' + evres + ': Parsed ' + eventArray.length + ' events')
for (var i = 0; i < resourceData.length; i++) {
if (resourceData[i].id > calID) {
calID = resourceData[i].id
}
}
calID++
resourceData.push({id: calID, hash: calHash, title: evres, color: colour, events: eventArray, method: 'webcal'});
}
}
})
getInitialState: function(){
var dateRange = Array.from(moment.range(
moment("04-22-2011"),
moment("11-22-2012")
).by('days'));
var visibleNights = 14;
return {
ready: false,
built: false,
dateRange: dateRange,
startDate: dateRange[0],
endDate: dateRange[visibleNights],
offsetIx: 0,
visibleNights: visibleNights,
nights: [],
activeView: 'overview',
activeNights: [],
activeNight: null,
activeNightIx: null,
activeState: null,
activeTime: null,
eventType: null,
statsState: 'range',
dateOffset: 0,
numNights: 387,
windows: [],
sliderGrabbed: false
}
},
exports.getDatesInRange = function(start,end){
"use strict";
var range = moment.range(start,end);
var pop = [];
range.by('days',function(m){
pop.push(m);
});
return pop;
};
dates: function(endDate) {
var that = this;
var classDates = [];
moment.range(this.get('term').get('start_date'), endDate).by('days', function(day) {
if (that.get('days').indexOf(day.format('dddd').toLowerCase()) > -1 &&
that.get('holidays').indexOf(day.format('YYYY-MM-DD')) === -1) {
classDates.push(day)
}
});
return classDates;
},
value: function calculateSpanningLayout(event) {
var end = moment.min(this.range.end, event.range().end);
var start = moment.max(this.range.start, event.range().start).clone();
do {
var range = moment.range(start, start.clone().endOf('week'));
var layout = new EventLayout(this, event, range);
this.addToCache(start, layout);
// go to first day of next week
start.add(7 - start.day(), 'day');
} while (!start.isAfter(end));
}
function parseEvent(calendar, event, vevent, colour) {
var evname = calendar.displayName + ' - ' + event.summary,
evid = event.uid,
evHash = crypto.createHash('md5').update(event.toString()).digest('hex'),
evstart = moment.utc(event.startDate.toJSDate()).local().format(),
evend = moment.utc(event.endDate.toJSDate()).local().format(),
evdesc = event.description,
evres = calendar.displayName,
evday = d3.time.day(new Date(evstart)),
evweek = d3.time.week(new Date(evstart)),
evmonth = d3.time.month(new Date(evstart)),
evduration = Math.round(moment.duration((moment.range(new Date(evstart), new Date(evend))).valueOf()).asHours() * 100) / 100;
return { id: evid, title: evname, resourceId: evres, className: evres, color: colour, description: evdesc, start: evstart, end: evend, day: evday, week: evweek, month: evmonth, duration: evduration }
}
_.forEach(seasons, function(season) {
if (_.isString(season.startAt)) {
season.startAt = new Date(season.startAt);
}
if (_.isString(season.endAt)) {
season.endAt = new Date(season.endAt);
}
season.monthes = [];
var range = moment.range(season.startAt, season.endAt);
range.by('months', function(moment) {
var month = moment.format('M');
if ( season.monthes.indexOf(month) )
season.monthes.push(month);
});
});
transform(events) {
var dateRanges = [];
for (var i = 0; i < events.length; i++) {
dateRanges.push(
{
state: 'unavailable',
range: moment.range(
events[i].start,
events[i].end
)
}
);
}
return dateRanges;
}
calculateLayout: function calculateLayout(props) {
var range = moment.range(props.date.clone().startOf(props.display), props.date.clone().endOf(props.display));
if (props.events) {
this.detachEventBindings();
props.events.on('change', this.onEventsChange, this);
}
if (props.display === 'month') {
range.start.subtract(range.start.weekday(), 'days');
range.end.add(6 - range.end.weekday(), 'days');
}
var layout = new Layout(_extends({}, props, { range: range }));
this.setState({ range: range, layout: layout });
},
self.formatDates = function(dateRange, cumulative){
var dates = Object.keys(dateRange);
var formattedDateRange = [];
var startDate, endDate, momentRange, finalRange;
finalRange = [];
for(var i=0; i < dates.length; i++){
// console.log(typeof dates[i]);
// console.log(moment(dates[i], "ddd MMM DD YYYY").format('YYYY-MM-DD, h:mm:ss'));
// console.log(moment(dates[i] + " UTC", "ddd MMM DD YYYY").format('YYYY-MM-DD, h:mm:ss'));
// console.log(moment.utc(dates[i], "ddd MMM DD YYYY").utcOffset(-4).format('YYYY-MM-DD, h:mm:ss'));
// console.log(moment.utc(dates[i], "ddd MMM DD YYYY").utcOffset(+4).format('YYYY-MM-DD, h:mm:ss'));
// console.log(moment.utc(dates[i]+ " UTC", "ddd MMM DD YYYY").utcOffset(-4).format('YYYY-MM-DD, h:mm:ss'));
// console.log(moment.utc(dates[i]+ " UTC", "ddd MMM DD YYYY").utcOffset(+4).format('YYYY-MM-DD, h:mm:ss'));
// console.log(moment(dates[i], "ddd MMM DD YYYY").utcOffset(-4).format('YYYY-MM-DD, h:mm:ss'));
// console.log(moment(dates[i], "ddd MMM DD YYYY").utcOffset(+4).format('YYYY-MM-DD, h:mm:ss'));
// console.log(moment(dates[i]+ " UTC", "ddd MMM DD YYYY").utcOffset(+16).format('YYYY-MM-DD, h:mm:ss'));
// console.log(moment(dates[i]+ " UTC", "ddd MMM DD YYYY").utcOffset(+4).format('YYYY-MM-DD, h:mm:ss'));
formattedDateRange.push({
"request_date": moment.utc(dates[i], "MMM YYYY").format('MMM YYYY'),
"count": dateRange[dates[i]]
})
}
startDate = moment(formattedDateRange[0].request_date, 'MMM YYYY')
endDate = moment(formattedDateRange[formattedDateRange.length-1].request_date, 'MMM YYYY')
momentRange = moment.range(startDate, endDate);
momentRange.by('months', function(moment){
dateStr = moment.format('MMM YYYY');
var finalData = {};
var dateData = _.find(formattedDateRange, {"request_date": dateStr})
if(dateData){
finalData.request_date = dateData.request_date;
finalData.count = dateData.count;
}
else{
finalData.request_date = dateStr;
finalData.count = 0;
}
finalRange.push(finalData);
});
if(cumulative){
for(var i = 0; i < finalRange.length; i++){
if(i > 0){
finalRange[i].count = finalRange[i-1].count + finalRange[i].count;
}
}
}
return finalRange;
}
courses.forEach(course => {
moment
.range(course.term.start_date, moment(course.term.end_date)
.add(1, 'days'))
.by('days', date => {
if (
course.get('days').includes(date.format('dddd').toLowerCase()) &&
!course.get('holidays').includes(date.format('YYYY-MM-DD'))
) {
dates.push({
course_id: course._id.toString(),
date: date.format('YYYY-MM-DD')
});
}
});
});
showResponse: function(results) {
console.log(results);
var lastElement = results.results.length - 1;
console.warn(results.results[0]);
console.warn(results.results[lastElement]);
var start = moment(results.results[0].day);
var end = moment(results.results[lastElement].day);
var range = moment.range(start, end);
console.log(range);
var day = moment(results.results[0].day);
console.warn(day.add(1, 'day'));
var span = end.diff(start, 'days');
console.log(span);
var momentizedRange = []; // Moment.js-ified dates, everyday from start to finish
for (var i = 0; i < span; i++) {
console.log(i);
momentizedRange.push(moment(results.results[0].day).add(i, 'days'));
}
console.log(momentizedRange);
var momentizedResults = [];
results.results.forEach(function(result) {
var momentizedResult = moment(result.day);
momentizedResults.push(momentizedResult);
})
console.log(momentizedResults);
// Potential new strategy:
//
// 1. Iterate through results. range[0] to range[last]
// 2. Add in dates between results if it is in range but not in results
this.setState({
data: results
})
},
assignments.forEach(function(assignment) {
var assignmentRange = moment.range(moment(assignment.start_date), moment(assignment.end_date));
assignmentRange.by('days', function(date) {
if (date.within(scheduleRange) && date.isoWeekday() < 6) {
var day = date.format('YYYY-MM-DD');
if (typeof dates[day] === 'undefined') {
dates[day] = {};
}
if (typeof dates[day][assignment.person_id] === 'undefined') {
dates[day][assignment.person_id] = [];
}
dates[day][assignment.person_id].push({
project_id: assignment.project_id,
project: data.projectsById[assignment.project_id],
allocation: assignment.allocation,
notes: assignment.notes,
});
}
});
});
/**
* Clamps `range` to `within`, so that if the result range is within `within`.
* Returns `null` if range is entirely outside.
*/
function clampTimeRange(range, within) {
if (within) {
if (range.overlaps(within)) {
var start = range.start < within.start ?
range.start > within.end ?
within.end :
within.start : range.start;
var end = range.end > within.end ?
range.end < within.start ?
within.start :
within.end : range.end;
if (start > end) {
[start, end] = [end, start];
}
return moment.range(start, end);
} else {
return null;
}
} else {
return range;
}
}