def calendar_js_globals(self): limit_start = ISchedulingContext(self.context).start_date limit_end = ISchedulingContext(self.context).end_date cal_globals = dict( limit_start=limit_start.isoformat() if limit_start else None, limit_end=limit_end.isoformat() if limit_end else None, ical_url=self.ical_url, required_fields=[ field.field.getName() for field in self.partial_event_form.form_fields if field.field.required ], view_url=self.url, venues_view_title=translate_i18n(TITLE_VENUES_VIEW), text_group=translate_i18n(FIELD_GROUP), text_start_date=translate_i18n(FIELD_START_DATE), text_end_date=translate_i18n(FIELD_END_DATE), text_venue=translate_i18n(FIELD_VENUE), text_activity_type=translate_i18n(_(u"Activity Type")), text_meeting_type=translate_i18n(_(u"Meeting Type")), text_convocation_type=translate_i18n(_(u"Convocation Type")), text_sitting=translate_i18n(TITLE_SITTING), text_view=translate_i18n(ACTION_VIEW_SITTING), error_messages=dict( default=_(u"Please check the highlighted sittings. " "Failed to apply changes"), updated=_(u"Please review the highlighted sittings." " Could not apply changes."), deleted=_(u"Please review the highlighted events." " Could not be deleted."))) return """var cal_globals = %s; var timeline_data = { venues: %s, combined: %s }; var group_urls= %s;""" % ( json.dumps(cal_globals), json.dumps(self.venues_data), json.dumps(self.groups_data), json.dumps(self.calendar_urls()))
def process_form(self, data): class optionsobj(object): """Object that holds all the options.""" self.options = optionsobj() if not hasattr(self, "short_name"): if "short_name" in data: self.short_name = data["short_name"] self.sittings = [] if IGroupSitting.providedBy(self.context): trusted = removeSecurityProxy(self.context) order = "real_order" if self.display_minutes else "planned_order" trusted.item_schedule.sort(key=operator.attrgetter(order)) self.sittings.append(trusted) self.start_date = self.context.start_date self.end_date = self.get_end_date(self.start_date, self.time_span(data)) else: self.start_date = data["date"] if "date" in data else \ datetime.datetime.today().date() self.end_date = self.get_end_date(self.start_date, self.time_span(data)) sittings = ISchedulingContext(self.context).get_sittings( self.start_date, self.end_date).values() self.sittings = map(removeSecurityProxy, sittings) self.ids = "" for sitting in self.sittings: self.ids += str(sitting.group_sitting_id) + "," def cleanup(string): return string.lower().replace(" ", "_") for item_type in data["item_types"]: itemtype = cleanup(item_type) type_key = itemtype.rstrip("s").replace("_", "") setattr(self.options, type_key, True) setattr(self.options, itemtype, True) for option in data[itemtype + "_options"]: opt_key = "".join( (cleanup(itemtype.rstrip("s")).replace("_", ""), "_", cleanup(option))) setattr(self.options, opt_key, True) if self.display_minutes: self.link = url.absoluteURL(self.context, self.request) \ + "/votes-and-proceedings" else: self.link = url.absoluteURL(self.context, self.request) + "/agenda" try: self.group = self.context.group except: self.group = ISchedulingContext(self.context).get_group()
def __init__(self, context, request, view, manager): while not ISchedulingContext.providedBy(context): context = ISchedulingContext(context, context.__parent__) if context is None: raise RuntimeError("Unable to locate a scheduling context.") super(SchedulablesViewlet, self).__init__(context, request, view, manager)
def set_sitting_parent_ids(ob, event): """We add the group ID/sesssion id if adding a sitting in contexts not bound to groups in traversal hierarchy """ scheduling_context = ISchedulingContext(ob.__parent__, None) if ob.group_id is None: if scheduling_context is not None: ob.group_id = removeSecurityProxy(scheduling_context).group_id if ob.session_id is None or IObjectModifiedEvent.providedBy(event): if scheduling_context is not None: group = scheduling_context.get_group() if interfaces.IChamber.providedBy(group): container = removeSecurityProxy(group).sessions else: return else: try: container = ob.group.sessions except AttributeError: return try: session_id = container._query.filter( sql.and_( domain.Session.start_date < ob.start_date, domain.Session.end_date > ob.end_date)).one().session_id ob.session_id = session_id except (orm.exc.NoResultFound, orm.exc.MultipleResultsFound): log.error("Could not determine session for sitting %s", ob)
def __call__(self, timestamp=None): trusted = removeSecurityProxy(self.context) trusted.__name__ = self.__name__ interface.alsoProvides(trusted, ILocation) self.url = url.absoluteURL(trusted.__parent__, self.request) self.title = ISchedulingContext(self.context).label return self.render()
def handle_publish(self, action, data): self.generated_content = self.generateContent(data) if IWorkspaceScheduling.providedBy(self.request): if not hasattr(self.context, "group_id"): context_group_id = ISchedulingContext(self.context).group_id else: context_group_id = self.context.group_id else: #get the chamber id context_group_id = get_chamber_for_context( self.context).parliament_id report = domain.Report( title=self.title, start_date=self.start_date, end_date=self.end_date, body=self.generated_content, owner_id=get_login_user().user_id, # !+GROUP_AS_OWNER language=self.language, group_id=context_group_id) session = Session() session.add(report) session.flush() notify(ObjectCreatedEvent(report)) self.status = _(u"Report has been processed and saved") return self.template()
def __init__(self, context, request): super(DhtmlxCalendarSittings, self).__init__(ISchedulingContext(context), request) self.context.__name__ = self.__name__ interface.alsoProvides(self.context, ILocation) interface.alsoProvides(self.context, IDCDescriptiveProperties) self.__parent__ = context
def validate(self, action, data): errors = super(ReportView, self).validate(action, data) time_span = self.time_span(data) if IGroupSitting.providedBy(self.context): if not self.context.items: errors.append( interface.Invalid( _(u"The sitting has no scheduled items"))) else: start_date = data["date"] if "date" in data else \ datetime.datetime.today().date() end_date = self.get_end_date(start_date, time_span) try: ctx = ISchedulingContext(self.context) except: errors.append( interface.Invalid( _(u"You are trying to generate a report " "outside scheduling"))) sittings = ctx.get_sittings(start_date, end_date).values() if not sittings: errors.append( interface.Invalid( _(u"The period selected has no sittings"), "date")) parliament = queries.get_parliament_by_date_range( start_date, end_date) if parliament is None: errors.append( interface.Invalid( _(u"A parliament must be active in the period"), "date")) return errors
def handle_insert(self, action, data): session = Session() sitting = domain.GroupSitting() trusted = removeSecurityProxy(ISchedulingContext(self.context)) group = session.query(domain.Group).get(trusted.group_id) if ("rec_type" not in data.keys()) or (data["rec_type"] == ""): sitting.start_date = datetime.datetime.strptime(data["start_date"], '%Y-%m-%d %H:%M') sitting.end_date = datetime.datetime.strptime(data["end_date"], '%Y-%m-%d %H:%M') sitting.group_id = trusted.group_id if "language" in data.keys(): sitting.language = data["language"] if "venue" in data.keys(): sitting.venue_id = data["venue"] session.add(sitting) notify(ObjectCreatedEvent(sitting)) session.commit() self.request.response.setHeader('Content-type', 'text/xml') return '<data><action type="inserted" sid="'+str(data["ids"])+'" tid="'+str(sitting.sitting_id)+'" /></data>' else: try: recurrence_start_date = datetime.datetime.strptime(data["start_date"], '%Y-%m-%d %H:%M') recurrence_end_date = datetime.datetime.strptime(data["end_date"], '%Y-%m-%d %H:%M') except: print "Date is not in the correct format" year = timedelta(days=365) #max end date is one year from now or end_date of the group whichever is sooner if (group is not None) and (group.end_date is not None): if (datetime.datetime.now() + year) < group.end_date: end = datetime.datetime.now() + year else: end = group.end_date if recurrence_end_date > end: recurrence_end_date = end else: if recurrence_end_date > (datetime.datetime.now() + year): recurrence_end_date = datetime.datetime.now() + year recurrence_type = data["rec_type"] length = data["event_length"] sitting_length = timedelta(seconds=int(length)) dates = self.generate_recurrence_dates(recurrence_start_date, recurrence_end_date, recurrence_type) output = '<data>' for date in dates: sitting = domain.GroupSitting() sitting.group_id = trusted.group_id sitting.start_date = date sitting.end_date = date + sitting_length sitting.status = None if "language" in data.keys(): sitting.language = data["language"] if "venue" in data.keys(): sitting.venue_id = data["venue"] session.add(sitting) notify(ObjectCreatedEvent(sitting)) output = output+'<action type="inserted" sid="'+str(data["ids"])+'" tid="'+str(sitting.sitting_id)+'" />' session.commit() output = output + '</data>' self.request.response.setHeader('Content-type', 'text/xml') return output
def buildSittings(self): if ISitting.providedBy(self.context): trusted = removeSecurityProxy(self.context) order = "real_order" trusted.item_schedule.sort(key=operator.attrgetter(order)) self.sittings.append(trusted) else: sittings = ISchedulingContext(self.context).get_sittings( self.start_date, self.end_date).values() self.sittings = map(removeSecurityProxy, sittings) self.sittings = [ExpandedSitting(sitting) for sitting in self.sittings]
def __init__(self, context, request): log.debug("CalendarView.__init__: %s" % (context)) super(CalendarView, self).__init__(ISchedulingContext(context), request) self.context.__name__ = self.__name__ self.context.title = self.short_name interface.alsoProvides(self.context, ILocation) interface.alsoProvides(self.context, IDCDescriptiveProperties) self.__parent__ = context log.debug(debug.interfaces(self)) log.debug(debug.location_stack(self))
def set_schedule_text_group(context, event): """Sets the current group id of schedule meta Headings and Notes """ if hasattr(context, "group_id") and context.group_id is None: request_context = common.get_traversed_context() scheduling_context = ISchedulingContext( request_context.context.__parent__, None) if scheduling_context is not None: context.group_id = scheduling_context.group_id
def __call__(self, timestamp=None): trusted = removeSecurityProxy(self.context) trusted.__name__ = self.__name__ interface.alsoProvides(trusted, ILocation) if (IBusinessSectionLayer.providedBy(self.request) and isinstance(trusted, SittingContainerSchedulingContext)): self.url = url.absoluteURL(trusted.__parent__.__parent__, self.request) else: self.url = url.absoluteURL(trusted.__parent__, self.request) self.title = ISchedulingContext(self.context).label return self.render()
def build_context(self): if ISitting.providedBy(self.context): sittings = [removeSecurityProxy(self.context)] else: sittings = map( removeSecurityProxy, ISchedulingContext(self.context).get_sittings( self.start_date, self.end_date).values()) # sort sittings chronologically sittings.sort(key=operator.attrgetter("start_date")) # ensure item_schedule is sorted via "real_order" within each sitting for sitting in sittings: sitting.item_schedule.sort(key=operator.attrgetter("real_order")) self.sittings = [ExpandedSitting(s) for s in sittings]
def __init__(self, context, request): log.debug("CalendarView.__init__: %s" % (context)) super(CalendarView, self).__init__(ISchedulingContext(context), request) trusted = removeSecurityProxy(self.context) trusted.__name__ = self.__name__ trusted.title = self.short_name interface.alsoProvides(trusted, ILocation) interface.alsoProvides(trusted, IDCDescriptiveProperties) if (IBusinessSectionLayer.providedBy(request) and isinstance(trusted, SittingContainerSchedulingContext)): self.url = url.absoluteURL(trusted.__parent__.__parent__, request) else: self.url = url.absoluteURL(trusted.__parent__, request) self.__parent__ = context log.debug(debug.interfaces(self)) log.debug(debug.location_stack(self))
def generate_dates(self, data): trusted = removeSecurityProxy(ISchedulingContext(self.context)) recurrence_start_date = data["start_date"].replace(tzinfo=None) recurrence_end_date = data["rec_end_date"].replace(tzinfo=None) group = trusted.get_group() # If group is none then there is a big problem assert group is not None year = timedelta(days=365) now = datetime.datetime.now() if (((group.end_date is not None) and ((now + year) < group.end_date)) or (group.end_date is None)): end = now + year else: end = group.end_date if recurrence_end_date > end: recurrence_end_date = end return utils.generate_recurrence_dates(recurrence_start_date, recurrence_end_date, data["rec_type"])
def handle_publish(self, action, data): self.generated_content = self.generateContent(data) if not hasattr(self.context, "group_id"): context_group_id = ISchedulingContext(self.context).group_id else: context_group_id = self.context.group_id report = domain.Report(short_name=self.title, start_date=self.start_date, end_date=self.end_date, body_text=self.generated_content, owner_id=get_db_user_id(), language=self.language, group_id=context_group_id) session = Session() session.add(report) session.flush() self.status = _(u"Report has been processed and saved") return self.template()
def handle_save(self, action, data): report = domain.Report() session = Session() report.body = data["body"] report.start_date = data["start_date"] report.end_date = data["end_date"] report.note = data["note"] report.short_name = data["short_name"] report.owner_id = get_login_user().user_id # !+GROUP_AS_OWNER report.language = get_default_language() report.created_date = datetime.datetime.now() if not hasattr(self.context, "group_id"): report.group_id = ISchedulingContext(self.context).group_id else: report.group_id = self.context.group_id session.add(report) session.flush() notify(ObjectCreatedEvent(report)) if "sittings" in data.keys(): try: ids = data["sittings"].split(",") for id_number in ids: sit_id = int(id_number) sitting = session.query(domain.Sitting).get(sit_id) sr = domain.SittingReport() sr.report = report sr.sitting = sitting session.add(sr) notify(ObjectCreatedEvent(report)) except: #if no sittings are present in report or some other error occurs pass session.flush() if ISitting.providedBy(self.context): back_link = "./schedule" else: back_link = "./" self.request.response.redirect(back_link)
def get_sittings_path(self): """get the url to the context sittings container""" scheduling_context = None context = self.context while scheduling_context is None: scheduling_context = ISchedulingContext(context, None) if not scheduling_context: context = context.__parent__ if scheduling_context: try: ctx = scheduling_context.__parent__ if hasattr(ctx, "sittings"): sittings_container = ctx.sittings else: sittings_container = removeSecurityProxy(ctx).publishTraverse( self.request, "sittings" ) return url.absoluteURL(sittings_container, self.request) except NotFound: log.error("Could not determine sittings path for context %s", self.context ) return "../sittings"
def __init__(self, context, request): log.debug("CalendarView.__init__: %s" % (context)) super(CalendarView, self).__init__(ISchedulingContext(context), request)
def handle_insert(self, action, data): session = Session() data["rec_end_date"] = data["end_date"] self.template_data = [] trusted = removeSecurityProxy(ISchedulingContext(self.context)) initial_sitting = None length = data["event_length"] venue_id = unicode(data["venue"]) if data['venue'] else None if data.get("rec_type") not in [None, "none"]: data["end_date"] = data["start_date"] + timedelta(seconds=length) self.request.form["end_date"] = data["end_date"].strftime( DT_FORMAT) data["headless"] = "true" self.request.form["venue_id"] = data["venue_id"] = venue_id self.request.form["headless"] = "true" add_form = AddForm(trusted.get_group().sittings, self.request) add_form.update() if not add_form.errors: initial_sitting = removeSecurityProxy(add_form.created_object) else: return self.insert_sitting_failure_handler(action, data, add_form.errors) if ("rec_type" in data.keys()) and (data["rec_type"] not in [None, "none"]): # create recurring sittings #base_sitting_length = sitting_length + timedelta(hours=1) sitting_length = timedelta(seconds=length) base_sitting_length = timedelta(seconds=length) + timedelta( hours=1) dates = self.generate_dates(data) initial_sitting.recurring_type = data.get("rec_type") initial_sitting.recurring_id = 0 initial_sitting.sitting_length = length for count, date in enumerate(dates): if not count: #we've already added the initial sitting initial_sitting.recurring_end_date = ( dates[len(dates) - 1] + base_sitting_length) session.merge(initial_sitting) continue sitting_data = copy(data) sitting_data["start_date"] = date.strftime(DT_FORMAT) sitting_data["end_date"] = (date + sitting_length).strftime(DT_FORMAT) request_copy = copy(self.request) request_copy.form = sitting_data add_form = AddForm(trusted.get_group().sittings, request_copy) add_form.update() if not add_form.errors: # use finishConstruction API here obj = add_form.created_object obj.sitting_length = int(time.mktime(date.timetuple())) obj.recurring_id = initial_sitting.sitting_id session.merge(obj) else: initial_sitting.recurring_type = data.get("rec_type") initial_sitting.recurring_id = data.get("event_pid", 0) if data.get("event_length"): initial_sitting.sitting_length = data.get("event_length") session.merge(initial_sitting) wfc = IWorkflowController(initial_sitting) wfc.fireAutomatic() sitting_action = "inserted" if data["rec_type"] == "none": sitting_action = "deleted" session.merge(initial_sitting) self.template_data.append({ "sitting_id": initial_sitting.sitting_id, "action": sitting_action, "ids": data["ids"], }) self.request.response.setHeader("Content-type", "text/xml") return self.xml_template()
def __init__(self, context, request): super(CalendarView, self).__init__(ISchedulingContext(context), request)
def handle_insert(self, action, data): session = Session() self.template_data = [] trusted = removeSecurityProxy(ISchedulingContext(self.context)) if ("rec_type" in data.keys()) and (data["rec_type"] is not None): # !+ DATETIME(miano, dec-2010) the datetime widget above returns # aware datetime objects while the current database setup only # supports naive objects. The lines below(and in subsequent actions) # convert them to naive datetimes recurrence_start_date = data["start_date"].replace(tzinfo=None) recurrence_end_date = data["end_date"].replace(tzinfo=None) length = data["event_length"] sitting_length = timedelta(seconds=int(length)) # # Check the end date of the recurrence # The end date is set to be the end date of the current group # or one year from the present date whichever is sooner. group = trusted.get_group() # If group is none then there is a big problem assert group is not None year = timedelta(days=365) now = datetime.datetime.now() if ((group.end_date is not None) and ((now + year) < group.end_date)) or (group.end_date is None): end = now + year else: end = group.end_date if recurrence_end_date > end: recurrence_end_date = end dates = utils.generate_recurrence_dates(recurrence_start_date, recurrence_end_date, data["rec_type"]) recurrent_sittings = [] for date in dates: sitting = domain.GroupSitting() sitting.group_id = trusted.group_id sitting.start_date = date sitting.end_date = date + sitting_length sitting.language = data["language"] sitting.venue_id = data["venue"] session.add(sitting) recurrent_sittings.append(sitting) session.flush() for s in recurrent_sittings: notify(ObjectCreatedEvent(s)) self.template_data.append({ "group_sitting_id": s.group_sitting_id, "action": "inserted", "ids": data["ids"] }) self.request.response.setHeader('Content-type', 'text/xml') return self.xml_template() else: sitting = domain.GroupSitting() sitting.start_date = data["start_date"].replace(tzinfo=None) sitting.end_date = data["end_date"].replace(tzinfo=None) sitting.group_id = trusted.group_id sitting.language = data["language"] sitting.venue_id = data["venue"] session.add(sitting) session.flush() notify(ObjectCreatedEvent(sitting)) self.template_data.append({ "group_sitting_id": sitting.group_sitting_id, "action": "inserted", "ids": data["ids"] }) self.request.response.setHeader('Content-type', 'text/xml') return self.xml_template()
def handle_insert(self, action, data): self.template_data = [] session = Session() trusted = removeSecurityProxy(ISchedulingContext(self.context)) if ("rec_type" in data.keys()) and (data["rec_type"] is not None): try: recurrence_start_date = datetime.datetime \ .strptime(data["start_date"], '%Y-%m-%d %H:%M') except: log.error("The start date of the recurrence \ is not in the correct format") try: recurrence_end_date = datetime.datetime.strptime( data["end_date"], '%Y-%m-%d %H:%M') except: log.error("The start date of the recurrence is not in \ the correct format") length = data["event_length"] sitting_length = timedelta(seconds=int(length)) # Check the end date of the recurrence # The end date is set to be the end date of the current group # or one year from the present date whichever is sooner. group = trusted.get_group() # If group is none then there is a big problem assert group is not None year = timedelta(days=365) now = datetime.datetime.now() if ((group.end_date is not None) and ((now + year) < group.end_date)) or (group.end_date is None): end = now + year else: end = group.end_date if recurrence_end_date > end: recurrence_end_date = end dates = utils.generate_recurrence_dates(recurrence_start_date, recurrence_end_date, data["rec_type"]) for date in dates: sitting = domain.GroupSitting() sitting.group_id = trusted.group_id sitting.start_date = date sitting.end_date = date + sitting_length sitting.status = None if "language" in data.keys(): sitting.language = data["language"] if "venue" in data.keys(): sitting.venue_id = data["venue"] # set extra data needed by template sitting.ids = data["ids"] sitting.action = 'inserted' session.add(sitting) # commiting after adding a sitting is incredibly inefficient # but thats the only way to get the sitting id. # Adding recurrring sittings is not a recurrent activity (see, # what I did there :)) so we can live with it. session.commit(sitting) notify(ObjectCreatedEvent(sitting)) self.template_data.append({"sitting_id": sitting.sitting_id, "action": "inserted", "ids": data["ids"]}) self.request.response.setHeader('Content-type', 'text/xml') return self.template() else: sitting = domain.GroupSitting() try: sitting.start_date = datetime.datetime.strptime( data["start_date"], '%Y-%m-%d %H:%M') except: log.error("The start date of the sitting \ is not in the correct format") try: sitting.end_date = datetime.datetime.strptime(data["end_date"], '%Y-%m-%d %H:%M') except: log.error("The end date of the sitting is not in the correct format") sitting.group_id = trusted.group_id if "language" in data.keys(): sitting.language = data["language"] if "venue" in data.keys(): sitting.venue_id = data["venue"] # set extra data needed by template sitting.ids = data["ids"] sitting.action = 'inserted' session.add(sitting) session.commit() notify(ObjectCreatedEvent(sitting)) self.template_data.append({"sitting_id": sitting.sitting_id, "action": "inserted", "ids": data["ids"]}) self.request.response.setHeader('Content-type', 'text/xml') return self.template()