Created
February 9, 2016 01:33
-
-
Save Wardormeur/927fa37a8834af82f542 to your computer and use it in GitHub Desktop.
not finished
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* global google */ | |
(function() { | |
'use strict'; | |
function getEveryTargetWeekdayInDateRange(startDateTime, endDateTime, targetWeekday, eventType) { | |
var currentDate = startDateTime; | |
var dates = []; | |
var biWeeklyEventSwitch = false; | |
// this function calculates the start time and end time for each recurring event occurrence. | |
// the result of this function will be finally saved in the DB | |
function calculateDatesObj(startDateTime, endDateTime){ | |
var date = {}; | |
var offset = moment(startDateTime.toISOString()).utcOffset(); | |
moment().utcOffset(offset); | |
date.startTime = moment.utc(startDateTime).add(startDateTimeOffset, 'minutes'); | |
var mEventDate = moment.utc(startDateTime); | |
var mEventLastDate = moment.utc(endDateTime).add(endDateTimeOffset, 'minutes'); | |
date.endTime = moment([ mEventDate.get('year'), mEventDate.get('month'), mEventDate.date(), | |
mEventLastDate.get('hour'), mEventLastDate.get('minute'), mEventLastDate.get('second'), mEventLastDate.get('millisecond') ]).toDate(); | |
return date; | |
} | |
if(eventType === 'one-off') { | |
dates.push(calculateDatesObj(currentDate, endDateTime)); | |
} else { | |
while (currentDate <= endDateTime) { | |
var currentTime = moment(new Date(currentDate)); | |
currentDate = currentTime.toDate() | |
if (currentDate.getDay() === targetWeekday) { | |
if (eventType === 'weekly') { | |
dates.push(calculateDatesObj(currentTime, endDateTime)); | |
} else { | |
if (!biWeeklyEventSwitch) { | |
dates.push(calculateDatesObj(currentTime, endDateTime)); | |
biWeeklyEventSwitch = true; | |
} else { | |
biWeeklyEventSwitch = false; | |
} | |
} | |
} | |
currentDate = moment.utc(currentDate).add(1, 'days'); | |
} | |
} | |
return dates; | |
} | |
function goToManageDojoEvents($state, usSpinnerService, dojoId) { | |
if(usSpinnerService) { | |
usSpinnerService.stop('create-event-spinner'); | |
} | |
$state.go('manage-dojo-events', { | |
dojoId: dojoId | |
}); | |
} | |
function goToManageDojoEvent($state, usSpinnerService, dojoId, eventId) { | |
if(usSpinnerService) { | |
usSpinnerService.stop('create-event-spinner'); | |
} | |
$state.go('manage-applications', { | |
dojoId: dojoId, | |
eventId: eventId | |
}); | |
} | |
function goToMyDojos($state, usSpinnerService) { | |
usSpinnerService.stop('create-event-spinner'); | |
$state.go('my-dojos'); | |
} | |
function fixEventDates(newDate, oldDate){ | |
newDate = moment.utc(newDate); | |
oldDate = moment.utc(oldDate); | |
return moment.utc([ newDate.get('year'),newDate.get('month'), newDate.date(), | |
oldDate.get('hour'), oldDate.get('minute'), oldDate.get('second'), oldDate.get('millisecond') ]); | |
} | |
function fixEventTime(newTime, date){ | |
newTime = moment.utc(newTime); | |
date = moment.utc(date); | |
return moment.utc([ date.get('year'), date.get('month'), date.date(), | |
newTime.get('hour'), newTime.get('minute'), newTime.get('second'), newTime.get('millisecond') ]); | |
} | |
function dojoEventFormCtrl($scope, $stateParams, $state, $sce, $localStorage, $modal, cdEventsService, cdDojoService, cdUsersService, auth, $translate, cdLanguagesService, usSpinnerService, alertService, utilsService, ticketTypes, currentUser) { | |
var dojoId = $stateParams.dojoId; | |
var now = moment.utc().toDate(); | |
var defaultEventTime = moment.utc(now).add(2, 'hours').toDate(); | |
var defaultEventEndTime = moment.utc(now).add(3, 'hours').toDate(); | |
$scope.today = moment.utc().toDate(); | |
$scope.ticketTypes = ticketTypes.data || []; | |
$scope.ticketTypesTooltip = ''; | |
_.each($scope.ticketTypes, function (ticketType, index) { | |
ticketType.title = $translate.instant(ticketType.title); | |
if(index !== 0) { | |
$scope.ticketTypesTooltip += '<br>' + $translate.instant(ticketType.tooltip); | |
} else { | |
$scope.ticketTypesTooltip += $translate.instant(ticketType.tooltip); | |
} | |
}); | |
$scope.ticketTypesTooltip = $sce.trustAsHtml($scope.ticketTypesTooltip); | |
$scope.eventInfo = {}; | |
$scope.eventInfo.dojoId = dojoId; | |
$scope.eventInfo.public = true; | |
$scope.eventInfo.prefillAddress = false; | |
$scope.eventInfo.recurringType = 'weekly'; | |
$scope.eventInfo.sessions = [{name: null, tickets:[{name: null, type: null, quantity: 0}]}]; | |
$scope.eventInfo.date = defaultEventTime; | |
$scope.eventInfo.toDate = defaultEventEndTime; | |
$scope.eventInfo.startTime = defaultEventTime; | |
$scope.eventInfo.startTime.setMinutes(0); | |
$scope.eventInfo.startTime.setSeconds(0); | |
$scope.eventInfo.endTime = defaultEventEndTime; | |
$scope.eventInfo.endTime.setMinutes(0); | |
$scope.eventInfo.endTime.setSeconds(0); | |
$scope.eventInfo.fixedStartDateTime = $scope.eventInfo.date; | |
$scope.eventInfo.fixedEndDateTime = $scope.eventInfo.toDate; | |
$scope.datepicker = {}; | |
$scope.datepicker.minDate = now; | |
$scope.hasAccess = true; | |
$scope.$watch('eventInfo.date', function (date) { | |
$scope.eventInfo.fixedStartDateTime = fixEventDates(date, $scope.eventInfo.fixedStartDateTime); | |
$scope.eventInfo.startTime = $scope.eventInfo.fixedStartDateTime; | |
$scope.eventInfo.endTime = fixEventDates($scope.eventInfo.fixedStartDateTime, $scope.eventInfo.fixedEndDateTime); | |
}); | |
$scope.$watch('eventInfo.toDate', function (toDate) { | |
$scope.eventInfo.fixedEndDateTime = fixEventDates(toDate, $scope.eventInfo.fixedEndDateTime); | |
$scope.eventInfo.endTime = $scope.eventInfo.fixedEndDateTime; | |
}); | |
$scope.$watch('eventInfo.startTime', function (startTime) { | |
$scope.eventInfo.fixedStartDateTime = fixEventTime(startTime, $scope.eventInfo.fixedStartDateTime); | |
}); | |
$scope.$watch('eventInfo.endTime', function (endTime) { | |
$scope.eventInfo.fixedEndDateTime = fixEventTime(endTime, $scope.eventInfo.fixedEndDateTime); | |
}); | |
$scope.toggleDatepicker = function($event, isOpen) { | |
$event.preventDefault(); | |
$event.stopPropagation(); | |
$scope.datepicker[isOpen] = !$scope.datepicker[isOpen]; | |
}; | |
$scope.updateLocalStorage = function (item, value) { | |
if(!_.isEmpty(currentUser.data) && !$stateParams.eventId) { | |
if(!$localStorage[currentUser.data.id]) $localStorage[currentUser.data.id] = {}; | |
if(!$localStorage[currentUser.data.id][dojoId]) $localStorage[currentUser.data.id][dojoId] = {}; | |
if(!$localStorage[currentUser.data.id][dojoId].eventForm) $localStorage[currentUser.data.id][dojoId].eventForm = {}; | |
// what if the actual value is 'false' or 'null' | |
if(value === false || value === null || value) { | |
$localStorage[currentUser.data.id][dojoId].eventForm[item] = value; | |
} | |
} | |
}; | |
var deleteLocalStorage = function () { | |
if(!_.isEmpty(currentUser.data)) { | |
if($localStorage[currentUser.data.id] && $localStorage[currentUser.data.id][dojoId] && $localStorage[currentUser.data.id][dojoId].eventForm) { | |
delete $localStorage[currentUser.data.id][dojoId].eventForm; | |
} | |
} | |
} | |
$scope.getLocationFromAddress = function(eventInfo, cb) { | |
utilsService.getEventLocationFromAddress(eventInfo).then(function (data) { | |
$scope.googleMaps.mapOptions.center = new google.maps.LatLng(data.lat, data.lng); | |
$scope.googleMaps.map.panTo($scope.googleMaps.mapOptions.center); | |
$scope.googleMaps.marker.setMap(null); | |
$scope.googleMaps.marker = new google.maps.Marker({ | |
map: $scope.googleMaps.map, | |
position: $scope.googleMaps.mapOptions.center | |
}); | |
eventInfo.position = { | |
lat: data.lat, | |
lng: data.lng | |
}; | |
if(cb) cb(); | |
}, function (err) { | |
if(err) console.error(err); | |
alertService.showError($translate.instant('Please add the event location manually by clicking on the map.')); | |
if(cb) cb(); | |
}); | |
}; | |
$scope.validateSessions = function (sessions) { | |
return sessions.length !== 0; | |
}; | |
$scope.timepicker = {}; | |
$scope.timepicker.hstep = 1; | |
$scope.timepicker.mstep = 15; | |
$scope.timepicker.ismeridian = true; | |
$scope.weekdayPicker = {}; | |
$scope.weekdayPicker.weekdays = [{ | |
id: 0, | |
name: $translate.instant('Sunday') | |
}, { | |
id: 1, | |
name: $translate.instant('Monday') | |
}, { | |
id: 2, | |
name: $translate.instant('Tuesday') | |
}, { | |
id: 3, | |
name: $translate.instant('Wednesday') | |
}, { | |
id: 4, | |
name: $translate.instant('Thursday') | |
}, { | |
id: 5, | |
name: $translate.instant('Friday') | |
}, { | |
id: 6, | |
name: $translate.instant('Saturday') | |
}]; | |
$scope.searchCity = function($select) { | |
if($scope.hasAccess) { | |
return utilsService.getPlaces($scope.eventInfo.country.alpha2, $select).then(function (data) { | |
$scope.cities = data; | |
}, function (err) { | |
$scope.cities = []; | |
console.error(err); | |
}); | |
} | |
}; | |
$scope.prefillDojoAddress = function() { | |
if($scope.eventInfo.prefillAddress) { | |
$scope.eventInfo.city = $scope.eventInfo.dojoCity; | |
$scope.eventInfo.address = $scope.eventInfo.dojoAddress; | |
$scope.updateLocalStorage('city', $scope.eventInfo.dojoCity); | |
$scope.updateLocalStorage('address', $scope.eventInfo.dojoAddress); | |
$scope.updateLocalStorage('prefillAddress', true); | |
return; | |
} | |
$scope.updateLocalStorage('prefillAddress', false); | |
$scope.eventInfo.city = $scope.eventInfo.address = null; | |
$scope.updateLocalStorage('city', null); | |
$scope.updateLocalStorage('address', null); | |
}; | |
$scope.eventInfo.invites = []; | |
$scope.cancel = function($event) { | |
$event.preventDefault(); | |
$event.stopPropagation(); | |
deleteLocalStorage(); | |
goToManageDojoEvents($state, null, dojoId); | |
}; | |
$scope.addSession = function () { | |
if($scope.eventInfo.sessions.length === 20) return alertService.showError($translate.instant('You can only create a max of 20 sessions/rooms')); | |
var session = { | |
name: null, | |
tickets: [{name: null, type: null, quantity: 0}] | |
}; | |
$scope.eventInfo.sessions.push(session); | |
}; | |
$scope.addTicket = function (session) { | |
if(session.tickets.length === 20) return alertService.showError($translate.instant('You can only create a max of 20 ticket types')); | |
var ticket = { | |
name: null, | |
type: null, | |
quantity: 0 | |
}; | |
session.tickets.push(ticket); | |
}; | |
$scope.removeTicket = function ($index, session) { | |
if(session.tickets.length === 1) return alertService.showAlert($translate.instant('Your event must contain at least one ticket.')); | |
return session.tickets.splice($index, 1); | |
}; | |
$scope.removeSession = function ($index) { | |
if($scope.eventInfo.sessions.length === 1) return alertService.showAlert($translate.instant('Your event must contain at least one session.')); | |
return $scope.eventInfo.sessions.splice($index, 1); | |
}; | |
$scope.totalSessionCapacity = function (session) { | |
var total = 0; | |
_.each(session.tickets, function (ticket) { | |
if(ticket.type !== 'other') total += ticket.quantity || 0; | |
}); | |
return total; | |
}; | |
$scope.totalEventCapacity = function () { | |
var total = 0; | |
_.each($scope.eventInfo.sessions, function (session) { | |
total += $scope.totalSessionCapacity(session); | |
}); | |
return total; | |
}; | |
$scope.inviteDojoMembers = function (session) { | |
var emptyTicketsFound = _.find(session.tickets, function (ticket) { | |
return _.isEmpty(ticket.name) || _.isEmpty(ticket.type); | |
}); | |
if(emptyTicketsFound) return alertService.showAlert($translate.instant('You must complete all of the ticket details before inviting Dojo members.')); | |
async.waterfall([ | |
retrieveDojoUsers, | |
showInviteDojoMembersModal | |
], function (err) { | |
if(err) return console.error(err); | |
}); | |
function retrieveDojoUsers(done) { | |
cdDojoService.loadDojoUsers({dojoId: dojoId}, function (dojoUsers) { | |
var eventUserSelection = {}; | |
eventUserSelection[dojoId] = []; | |
_.each(dojoUsers, function (dojoUser) { | |
eventUserSelection[dojoId].push({userId: dojoUser.id, title: dojoUser.name}); | |
}); | |
return done(null, eventUserSelection); | |
}, function (err) { | |
if(err) { | |
console.error(err); | |
return done(err); | |
} | |
}); | |
} | |
function showInviteDojoMembersModal(eventUserSelection, done) { | |
var inviteDojoMembersModalInstance = $modal.open({ | |
animation: true, | |
templateUrl: '/dojos/template/events/session-invite', | |
controller: 'session-invite-modal-controller', | |
size: 'lg', | |
resolve: { | |
dojoId: function () { | |
return dojoId; | |
}, | |
session: function () { | |
return session; | |
}, | |
event: function () { | |
return $scope.eventInfo; | |
}, | |
eventUserSelection: function () { | |
return eventUserSelection; | |
}, | |
currentUser: function () { | |
return currentUser.data; | |
} | |
} | |
}); | |
inviteDojoMembersModalInstance.result.then(function (result) { | |
if(result.ok === false) return alertService.showError($translate.instant(result.why)); | |
alertService.showAlert($translate.instant('Dojo members successfully added to invite list. They will be notified of the invite when you publish this event.')); | |
}, null); | |
return done(); | |
} | |
}; | |
$scope.scrollToInvalid = function (form) { | |
if (form.$invalid) { | |
angular.element('form[name=' + form.$name + '] .ng-invalid')[0].scrollIntoView(); | |
} else { | |
$scope.eventInfo.publish=true; | |
} | |
}; | |
$scope.submit = function(eventInfo) { | |
usSpinnerService.spin('create-event-spinner'); | |
if($scope.googleMaps && $scope.googleMaps.marker) { | |
var eventPosition = { | |
lat: $scope.googleMaps.marker.getPosition().lat(), | |
lng: $scope.googleMaps.marker.getPosition().lng() | |
}; | |
// Extend eventInfo | |
eventInfo.position = eventPosition; | |
} | |
eventInfo.status = eventInfo.publish ? 'published' : 'saved'; | |
delete eventInfo.publish; | |
eventInfo.userType = eventInfo.userType && eventInfo.userType.name ? eventInfo.userType.name : ''; | |
if(!_.isEmpty(eventInfo.invites)) { | |
eventInfo.emailSubject = $translate.instant('Event Invitation'); | |
} | |
var isDateRange = !moment.utc(eventInfo.toDate).isSame(eventInfo.date, 'day'); | |
if (eventInfo.type === 'recurring' && isDateRange) { | |
// Extend eventInfo | |
if(eventInfo.recurringType === 'weekly') { | |
eventInfo.dates = getEveryTargetWeekdayInDateRange( | |
eventInfo.fixedStartDateTime, | |
eventInfo.fixedEndDateTime, | |
$scope.weekdayPicker.selection.id, | |
'weekly' | |
); | |
} else { | |
eventInfo.dates = getEveryTargetWeekdayInDateRange( | |
eventInfo.fixedStartDateTime, | |
eventInfo.fixedEndDateTime, | |
$scope.weekdayPicker.selection.id, | |
'biweekly' | |
); | |
} | |
} else { | |
eventInfo.dates = getEveryTargetWeekdayInDateRange( | |
eventInfo.fixedStartDateTime, | |
eventInfo.fixedEndDateTime, | |
null, | |
'one-off' | |
); | |
} | |
if(!$scope.dojoInfo) { | |
loadDojo(function(err){ | |
if(err) { | |
alertService.showError($translate.instant('An error has occurred while loading Dojo') + ' ' + err); | |
goToMyDojos($state, usSpinnerService, dojoId) | |
} | |
if ($scope.dojoInfo.verified === 1 && $scope.dojoInfo.stage !== 4) { | |
cdEventsService.saveEvent( | |
eventInfo, | |
function (response) { | |
if(response.ok === false) { | |
alertService.showError($translate.instant(response.why)); | |
} else { | |
deleteLocalStorage(); | |
} | |
if(response.dojoId && response.id) { | |
goToManageDojoEvent($state, usSpinnerService, response.dojoId, response.id); | |
} else { | |
goToManageDojoEvents($state, usSpinnerService, dojoId) | |
} | |
}, | |
function(err){ | |
alertService.showError($translate.instant('Error setting up event') + ' ' + err); | |
goToMyDojos($state, usSpinnerService, dojoId) | |
} | |
); | |
} else { | |
alertService.showError($translate.instant('Error setting up event')); | |
goToMyDojos($state, usSpinnerService, dojoId) | |
} | |
}) | |
} else { | |
if ($scope.dojoInfo.verified === 1 && $scope.dojoInfo.stage !== 4) { | |
cdEventsService.saveEvent( | |
eventInfo, | |
function (response) { | |
if(response.ok === false) { | |
alertService.showError($translate.instant(response.why)); | |
} else { | |
deleteLocalStorage(); | |
} | |
if(response.dojoId && response.id) { | |
goToManageDojoEvent($state, usSpinnerService, response.dojoId, response.id); | |
} else { | |
goToManageDojoEvents($state, usSpinnerService, dojoId) | |
} | |
}, | |
function (err){ | |
alertService.showError($translate.instant('Error setting up event') + ' ' + err); | |
goToMyDojos($state, usSpinnerService, dojoId) | |
} | |
); | |
} else { | |
alertService.showError($translate.instant('Error setting up event')); | |
goToMyDojos($state, usSpinnerService, dojoId) | |
} | |
} | |
}; | |
function addMap(eventPosition) { | |
var markerPosition; | |
if(!$scope.eventInfo.position) { | |
markerPosition = new google.maps.LatLng(eventPosition.lat, eventPosition.lng); | |
} else { | |
markerPosition = new google.maps.LatLng($scope.eventInfo.position.lat, $scope.eventInfo.position.lng); | |
} | |
$scope.googleMaps = { | |
mapOptions: { | |
center: markerPosition, | |
zoom: 15, | |
mapTypeId: google.maps.MapTypeId.ROADMAP | |
}, | |
onTilesLoaded: onTilesLoaded, | |
addMarker: addMarker | |
}; | |
function onTilesLoaded() { | |
var map = $scope.googleMaps.map; | |
$scope.googleMaps.marker = new google.maps.Marker({ | |
map: map, | |
draggable: true, | |
animation: google.maps.Animation.DROP, | |
position: markerPosition | |
}); | |
google.maps.event.clearListeners(map, 'tilesloaded'); | |
} | |
function addMarker ($event, $params, eventInfo) { | |
var map = $scope.googleMaps.map; | |
$scope.googleMaps.marker.setMap(null); | |
$scope.googleMaps.marker = new google.maps.Marker({ | |
map: map, | |
position: $params[0].latLng | |
}); | |
eventInfo.position = { | |
lat: $params[0].latLng.lat(), | |
lng: $params[0].latLng.lng() | |
}; | |
} | |
} | |
function loadDojo(done) { | |
cdDojoService.load(dojoId, function(dojo) { | |
if(dojo.place && dojo.place.toponymName){ | |
dojo.place.nameWithHierarchy = dojo.place.toponymName; | |
delete dojo.place.toponymName; | |
} | |
$scope.eventInfo.country = dojo.country; | |
$scope.eventInfo.dojoCity = dojo.place; | |
$scope.eventInfo.dojoAddress = dojo.address1; | |
var position = []; | |
if(dojo.coordinates) { | |
position = dojo.coordinates.split(','); | |
} | |
$scope.dojoInfo = dojo; | |
if(position && position.length === 2 && !isNaN(utilsService.filterFloat(position[0])) && !isNaN(utilsService.filterFloat(position[1]))) { | |
addMap({ | |
lat: parseFloat(position[0]), | |
lng: parseFloat(position[1]) | |
}); | |
} else if($scope.dojoInfo.geoPoint && $scope.dojoInfo.geoPoint.lat && $scope.dojoInfo.geoPoint.lon) { | |
//add map using coordinates from geopoint if possible | |
addMap({ | |
lat: $scope.dojoInfo.geoPoint.lat, | |
lng: $scope.dojoInfo.geoPoint.lon | |
}) | |
} else { //add empty map | |
cdDojoService.loadCountriesLatLongData(function(countries){ | |
var country = countries[dojo.alpha2]; | |
addMap({ | |
lat: country[0], | |
lng: country[1] | |
}) | |
}, done) | |
} | |
done(null, dojo); | |
}, done); | |
} | |
function loadCurrentUser(done) { | |
auth.get_loggedin_user(function(user) { | |
$scope.eventInfo.userId = user.id; | |
done(null, user); | |
}, done); | |
} | |
function validateEventRequest(done) { | |
cdDojoService.getUsersDojos({userId: currentUser.data.id, dojoId: dojoId}, function (usersDojos) { | |
if(_.isEmpty(usersDojos)) return done(new Error('No permissions found')); | |
var ticketingPermissionFound = _.find(usersDojos[0].userPermissions, function (permission) { | |
return permission.name === 'ticketing-admin'; | |
}); | |
if(!ticketingPermissionFound) return done(new Error('You must have the ticketing admin permission to edit a Dojo event')); | |
return done(); | |
}); | |
} | |
function loadDojoUsers(done) { | |
cdDojoService.loadDojoUsers({ | |
dojoId: dojoId, | |
limit$: 'NULL' | |
}, function(users) { | |
$scope.dojoUsers = users; | |
done(null, users); | |
}, done); | |
} | |
function loadUserTypes(done) { | |
cdUsersService.getInitUserTypes(function(userTypes) { | |
_.each(userTypes, function (userType) { | |
userType.title = $translate.instant(userType.title); | |
}); | |
userTypes.push({title:$translate.instant('Everyone'), name:'all-user-types'}); | |
$scope.eventInfo.userTypes = userTypes; | |
done(null, userTypes); | |
}, done); | |
} | |
function loadEvent(done) { | |
var eventId = $stateParams.eventId; | |
cdEventsService.getEvent(eventId, function(event) { | |
console.log(event); | |
$scope.isEditMode = true; | |
var startTime = _.first(event.dates).startTime || moment.utc().toISOString(); | |
var endTime = _.last(event.dates).endTime || moment.utc().toISOString(); | |
var startDateUtcOffset = moment(startTime).utcOffset(); | |
var endDateUtcOffset = moment(endTime).utcOffset(); | |
event.startTime = moment(startTime).subtract(startDateUtcOffset, 'minutes').toDate(); | |
event.endTime = moment(endTime).subtract(endDateUtcOffset, 'minutes').toDate(); | |
event.createdAt = new Date(event.createdAt); | |
event.date = new Date(startTime); | |
var lastEventOcurrance = _.last(event.dates).startTime || moment.utc().toISOString(); | |
event.toDate = new Date(lastEventOcurrance); | |
var eventDay = moment.utc(_.first(event.dates).startTime, 'YYYY-MM-DD HH:mm:ss').format('dddd'); | |
$scope.weekdayPicker.selection = _.find($scope.weekdayPicker.weekdays, function (dayObject) { | |
return dayObject.name === $translate.instant(eventDay); | |
}); | |
$scope.eventInfo.fixedStartDateTime = event.startTime; | |
$scope.eventInfo.fixedEndDateTime = event.endTime; | |
$scope.eventInfo = _.assign($scope.eventInfo, event); | |
$scope.eventInfo.userType = _.where($scope.eventInfo.userTypes, {name: $scope.eventInfo.userType})[0]; | |
$scope.pastEvent = isEventInPast(_.last(event.dates)); | |
//description editor | |
$scope.editorOptions = { | |
readOnly: $scope.pastEvent, | |
language: 'en', | |
uiColor: '#000000', | |
height: '200px' | |
}; | |
done(null, event); | |
}, done); | |
} | |
function loadSessions(done) { | |
var eventId = $stateParams.eventId; | |
cdEventsService.searchSessions({eventId: eventId, status: 'active'}, function (sessions) { | |
$scope.eventInfo.sessions = sessions; | |
return done(); | |
}, function (err) { | |
console.error(err); | |
return done(err); | |
}); | |
} | |
function loadLocalStorage(done) { | |
if($localStorage[currentUser.data.id] && $localStorage[currentUser.data.id][dojoId] && $localStorage[currentUser.data.id][dojoId].eventForm) { | |
if(!_.isEmpty($localStorage[currentUser.data.id][dojoId].eventForm)) { | |
alertService.showAlert($translate.instant('There are unsaved changes on this page')); | |
var localStorage = $localStorage[currentUser.data.id][dojoId].eventForm; | |
if(localStorage.name) $scope.eventInfo.name = localStorage.name; | |
if(localStorage.description) $scope.eventInfo.description = localStorage.description; | |
if(localStorage.public) $scope.eventInfo.public = localStorage.public; | |
if(localStorage.prefillAddress) $scope.eventInfo.prefillAddress = localStorage.prefillAddress; | |
if(localStorage.type) $scope.eventInfo.type = localStorage.type; | |
if(localStorage.recurringType) $scope.eventInfo.recurringType = localStorage.recurringType; | |
if(localStorage.weekdaySelection) $scope.weekdayPicker.selection = localStorage.weekdaySelection; | |
if(localStorage.date) $scope.eventInfo.date = new Date(localStorage.date); | |
if(localStorage.toDate) $scope.eventInfo.toDate = new Date(localStorage.toDate); | |
if(localStorage.city) $scope.eventInfo.city = localStorage.city; | |
if(localStorage.address) $scope.eventInfo.address = localStorage.address; | |
if(localStorage.sessions) $scope.eventInfo.sessions = localStorage.sessions; | |
if(localStorage.position) $scope.eventInfo.position = localStorage.position; | |
} | |
} | |
$scope.$watch('eventInfo.sessions', function (sessions) { | |
sessions = _.without(sessions, _.findWhere(sessions, {name: null})) | |
if(!_.isEmpty(sessions)) $scope.updateLocalStorage('sessions', sessions); | |
}, true); | |
$scope.$watch('eventInfo.position', function (mapLatLng) { | |
$scope.updateLocalStorage('position', mapLatLng); | |
}); | |
return done(); | |
} | |
function isEventInPast(dateObj) { | |
var now = moment.utc(); | |
var eventUtcOffset = moment(dateObj.startTime).utcOffset(); | |
var start = moment.utc(dateObj.startTime).subtract(eventUtcOffset, 'minutes'); | |
return now.isAfter(start); | |
} | |
if ($stateParams.eventId) { | |
if(_.isEmpty(currentUser.data)) return $state.go('error-404-no-headers'); | |
return async.series([ | |
validateEventRequest, | |
loadDojoUsers, | |
loadUserTypes, | |
loadEvent, | |
loadSessions | |
], function(err, results) { | |
if (err) { | |
$scope.hasAccess = false; | |
return $state.go('error-404-no-headers'); | |
} else { | |
var eventPosition = results[3].position; | |
addMap(eventPosition); | |
} | |
}); | |
} else { | |
cdEventsService.search({dojoId: dojoId, sort$: {createdAt: -1}, limit$: 1}).then(function (events) { | |
var latestEvent = events[0]; | |
if(latestEvent) $scope.eventInfo.ticketApproval = latestEvent.ticketApproval; | |
}); | |
} | |
async.parallel([ | |
validateEventRequest, | |
loadDojo, | |
loadCurrentUser, | |
loadDojoUsers, | |
loadUserTypes, | |
loadLocalStorage | |
], function(err, results) { | |
if (err) { | |
$scope.hasAccess = false; | |
return $state.go('error-404-no-headers'); | |
} | |
}); | |
} | |
angular.module('cpZenPlatform') | |
.controller('dojo-event-form-controller', [ | |
'$scope', | |
'$stateParams', | |
'$state', | |
'$sce', | |
'$localStorage', | |
'$modal', | |
'cdEventsService', | |
'cdDojoService', | |
'cdUsersService', | |
'auth', | |
'$translate', | |
'cdLanguagesService', | |
'usSpinnerService', | |
'alertService', | |
'utilsService', | |
'ticketTypes', | |
'currentUser', | |
dojoEventFormCtrl | |
]); | |
})(); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment