beginning of event contraint system. prints out constraint

src/Calendar.business.js

@@ -11,18 +11,51 @@ var BUSINESS_HOUR_EVENT_DEFAULTS = {
 
 // Return events objects for business hours within the current view.
 // Abuse of our event system :(
-Calendar.prototype.buildCurrentBusinessGroup = function(wholeDay) {
+Calendar.prototype.buildCurrentBusinessFootprints = function(wholeDay) {
 	var activeRange = this.getView().activeRange;
 
-	return this.buildBusinessGroup(
-		wholeDay,
-		this.opt('businessHours'),
-		activeRange.start,
-		activeRange.end
+	return this.eventInstanceGroupToFootprints(
+		this.buildBusinessGroup(
+			wholeDay,
+			this.opt('businessHours'),
+			activeRange.start,
+			activeRange.end
+		)
 	);
 };
 
 
+// doesn't consider resources :(
+// this is not only used for business hours
+Calendar.prototype.eventInstanceGroupToFootprints = function(eventInstanceGroup) {
+	var activeRange = this.getView().activeRange;
+
+	var eventRanges = eventInstanceGroup.buildEventRanges(
+		new UnzonedRange(activeRange.start, activeRange.end),
+		this // calendar
+	);
+
+	var i, eventRange;
+	var footprints = [];
+
+	for (i = 0; i < eventRanges.length; i++) {
+		eventRange = eventRanges[i];
+
+		footprints.push(
+			new EventFootprint( // TODO: DRY. also in Grid.event.js
+				eventRange.eventInstance,
+				new ComponentFootprint(
+					eventRange.dateRange,
+					eventRange.eventInstance.eventDateProfile.isAllDay()
+				)
+			)
+		);
+	}
+
+	return footprints;
+};
+
+
 // Given a raw input value from options, return events objects for business hours within the current view.
 Calendar.prototype.buildBusinessGroup = function(wholeDay, input, rangeStart, rangeEnd) {
 	if (input === true) {

src/Calendar.constraints.js

@@ -1,11 +1,113 @@
 
 Calendar.prototype.isEventFootprintAllowed = function(eventFootprint) {
-	console.log('isEventFootprintAllowed', eventFootprint);
-	return true;
+	var eventDef = eventFootprint.eventInstance.eventDefinition;
+	var source = eventDef.source || {};
+	var constraintVal;
+	var overlapVal;
+
+	constraintVal = eventDef.constraint;
+	if (constraintVal == null) {
+		constraintVal = source.constraint;
+		if (constraintVal == null) {
+			constraintVal = this.opt('eventConstraint');
+		}
+	}
+
+	overlapVal = eventDef.overlap;
+	if (overlapVal == null) {
+		overlapVal = source.overlap;
+		if (overlapVal == null) {
+			overlapVal = this.opt('eventOverlap');
+		}
+	}
+
+	return this.isFootprintAllowed(
+		eventFootprint.componentFootprint,
+		constraintVal,
+		overlapVal,
+		eventDef
+	);
 };
 
 
 Calendar.prototype.isSelectionFootprintAllowed = function(componentFootprint) {
-	console.log('isSelectionFootprintAllowed', componentFootprint);
+	var selectAllowFunc = this.opt('selectAllow');
+
+	if (this.isFootprintAllowed(
+		componentFootprint,
+		this.opt('selectConstraint'),
+		this.opt('selectOverlap')
+	)) {
+		if (selectAllowFunc) {
+			return selectAllowFunc(selectAllowFunc) !== false;
+		}
+		else {
+			return true;
+		}
+	}
+
+	return false;
+};
+
+
+Calendar.prototype.isFootprintAllowed = function(componentFootprint, constraintVal, overlapVal, subjectEventDef) {
+
+	console.log('constraint', this.constraintValToFootprints(constraintVal));
+
 	return true;
 };
+
+
+Calendar.prototype.constraintValToFootprints = function(constraintVal) {
+
+	if (constraintVal === 'businessHours') {
+		return this.buildCurrentBusinessFootprints();
+	}
+
+	if (typeof constraintVal === 'object') {
+		return this.eventInputToFootprints(constraintVal);
+	}
+
+	return this.eventIdToFootprints(constraintVal);
+};
+
+
+Calendar.prototype.eventInputToFootprints = function(eventInput) {
+	var activeRange = this.getView().activeRange;
+	var eventDef;
+	var eventInstances;
+	var eventInstanceGroup;
+
+	if (eventInput.start == null) {
+		return []; // invalid
+	}
+
+	eventDef = parseEventInput(eventInput, this);
+	eventInstances = eventDef.buildInstances(activeRange.start, activeRange.end);
+	eventInstanceGroup = new EventInstanceGroup(eventInstances);
+
+	return this.eventInstanceGroupToFootprints(eventInstanceGroup);
+};
+
+
+Calendar.prototype.eventIdToFootprints = function(eventId) {
+	var activeRange = this.getView().activeRange;
+	var eventDefs = this.eventDefCollection.getById(eventId);
+	var eventInstances = [];
+	var eventInstanceGroup;
+	var i;
+
+	if (!eventDefs) {
+		return []; // invalid
+	}
+
+	for (i = 0; i < eventDefs.length; i++) {
+		eventInstances.push.apply(eventInstances, // append
+			eventDefs[i].buildInstances(activeRange.start, activeRange.end)
+		);
+	}
+
+	eventInstanceGroup = new EventInstanceGroup(eventInstances);
+
+	return this.eventInstanceGroupToFootprints(eventInstanceGroup);
+};

src/models/EventDefinitionCollection.js

@@ -12,14 +12,7 @@ var EventDefinitionCollection = Class.extend({
 	},
 
 	addRaw: function(eventInput, source) {
-		var eventDef;
-
-		if (isEventInputRecurring(eventInput)) {
-			eventDef = RecurringEventDefinition.parse(eventInput);
-		}
-		else {
-			eventDef = SingleEventDefinition.parse(eventInput, this.calendar);
-		}
+		var eventDef = parseEventInput(eventInput, this.calendar);
 
 		if (source) {
 			eventDef.source = source;
@@ -101,6 +94,16 @@ var EventDefinitionCollection = Class.extend({
 });
 
 
+function parseEventInput(eventInput, calendar) {
+	if (isEventInputRecurring(eventInput)) {
+		return RecurringEventDefinition.parse(eventInput);
+	}
+	else {
+		return SingleEventDefinition.parse(eventInput, calendar);
+	}
+}
+
+
 function isEventInputRecurring(eventInput) {
 	var start = eventInput.start || eventInput.date;
 	var end = eventInput.end;