def handle_update(self, action, data): session = Session() self.template_data = [] sitting = domain.GroupSitting() sitting = session.query(domain.GroupSitting).get(data["ids"]) sitting.start_date = data["start_date"].replace(tzinfo=None) sitting.end_date = data["end_date"].replace(tzinfo=None) if "language" in data.keys(): sitting.language = data["language"] if "venue" in data.keys(): sitting.venue_id = data["venue"] sitting.short_name = data.get("short_name", None) sitting.activity_type = data.get("activity_type", None) sitting.meeting_type = data.get("meeting_type", None) sitting.convocation_type = data.get("convocation_type", None) # set extra data needed by template session.flush() notify(ObjectModifiedEvent(sitting)) self.template_data.append({"group_sitting_id": sitting.group_sitting_id, "action": "inserted", "ids": data["ids"]}) session.flush() self.request.response.setHeader('Content-type', 'text/xml') return self.xml_template()
def handle_update(self, action, data): session = Session() self.template_data = [] venue_id = unicode(data["venue"]) if data['venue'] else None data["rec_end_date"] = data["end_date"] data["headless"] = 'true' self.request.form["venue_id"] = data["venue_id"] = venue_id self.request.form["headless"] = "true" if ("rec_type" in data.keys()) and (data["rec_type"] is not None): # updating recurring events - we assume existing events fall # at the beginning of the sequence and offer in place update. parent_sitting_id = get_real_id(data["ids"] or data["event_pid"]) length = data["event_length"] sitting_length = timedelta(seconds=length) base_sitting_length = sitting_length + timedelta(hours=1) siblings_filter = or_( domain.Sitting.recurring_id==parent_sitting_id, domain.Sitting.sitting_id==parent_sitting_id ) siblings = [ sitting for sitting in self.sittings_container.batch(order_by=(domain.Sitting.sitting_id), limit=None, filter=siblings_filter ) ] dates = self.generate_dates(data) current_count = len(siblings) for count, date in enumerate(dates): is_new = not count < current_count 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 if is_new: add_form = AddForm(self.sittings_container, request_copy) add_form.update() if add_form.errors: log.error("Could not add sitting in sequence: %s", sitting_data ) continue else: sitting = add_form.created_object sitting.recurring_id = parent_sitting_id else: sitting = siblings[count] if not count: sitting.recurring_end_date = dates[len(dates)-1] + base_sitting_length sitting.recurring_type = data.get("rec_type") sitting.recurring_id = 0 sitting.sitting_length = length else: sitting.sitting_length = int(time.mktime(date.timetuple())) sitting.recurring_type = None if not is_new: edit_form = EditForm(sitting, request_copy) edit_form.update() if edit_form.errors: continue else: session.merge(edit_form.context) else: session.merge(sitting) self.template_data.append({ "sitting_id": sitting.sitting_id, "action": (is_new and "inserted" or "updated"), "ids": create_id(sitting) }) #delete any sittings outside recurring bounds for del_sibling in siblings[len(dates):]: delete_form = DeleteForm(del_sibling, self.request) delete_form.update() if delete_form.errors: continue else: self.template_data.append({ "sitting_id": del_sibling.sitting_id, "action": "deleted", "ids": create_id(del_sibling) }) else: sitting_id = get_real_id(data["ids"]) parent_id = get_real_id(data["event_pid"]) sitting = self.sittings_container.get(sitting_id) if sitting is None: sitting = self.sittings_container.get(int(parent_id)) edit_form = EditForm(sitting, self.request) edit_form.update() if edit_form.errors: return self.update_sitting_failure_handler(action, data, edit_form.errors ) else: sitting.sitting_length = data.get("event_length") session.merge(sitting) self.template_data.append({ "sitting_id": sitting.sitting_id, "action": "updated", "ids": data["ids"], }) self.request.response.setHeader("Content-type", "text/xml") return self.xml_template()
def handle_insert(self, action, data): session = Session() data["rec_end_date"] = data["end_date"] self.template_data = [] 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(self.sittings_container, 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(self.sittings_container, 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 handle_update(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): # updating recurring events - we assume existing events fall # at the beginning of the sequence and offer in place update. parent_sitting_id = int(data["ids"]) or data["event_pid"] length = data["event_length"] sitting_length = timedelta(seconds=length) base_sitting_length = sitting_length + timedelta(hours=1) siblings = ( session.query(domain.Sitting) .filter( or_( domain.Sitting.recurring_id == parent_sitting_id, domain.Sitting.sitting_id == parent_sitting_id ) ) .order_by(domain.Sitting.sitting_id) .all() ) dates = self.generate_dates(data) current_count = len(siblings) for count, date in enumerate(dates): is_new = not count < current_count if is_new: sitting = domain.Sitting() else: sitting = siblings[count] sitting.start_date = date if not count: sitting.end_date = dates[len(dates) - 1] + base_sitting_length sitting.recurring_type = data.get("rec_type") sitting.recurring_id = 0 sitting.sitting_length = length else: end_date = date + sitting_length sitting.end_date = end_date sitting.sitting_length = int(time.mktime(date.timetuple())) # apply changes to parent and siblings new or existing sitting.short_name = data.get("short_name", None) sitting.venue_id = data["venue"] sitting.language = data["language"] sitting.activity_type = data.get("activity_type", None) sitting.meeting_type = data.get("meeting_type", None) sitting.convocation_type = data.get("convocation_type", None) if is_new: sitting.group_id = trusted.group_id sitting.recurring_id = parent_sitting_id session.add(sitting) session.flush() notify(ObjectCreatedEvent(sitting)) else: session.flush() notify(ObjectModifiedEvent(sitting)) self.template_data.append( { "sitting_id": sitting.sitting_id, "action": (is_new and "inserted" or "updated"), "ids": sitting.sitting_id, } ) # delete any sittings outside recurring bounds for del_sibling in siblings[len(dates) :]: session.delete(del_sibling) del_id = del_sibling.sitting_id notify(ObjectRemovedEvent(del_sibling)) self.template_data.append({"sitting_id": del_id, "action": "deleted", "ids": del_id}) else: sitting_id = int(data["ids"]) parent_id = data["event_pid"] sitting = session.query(domain.Sitting).get(sitting_id) if sitting is None: sitting = session.query(domain.Sitting).get(parent_id) sitting.start_date = data["start_date"].replace(tzinfo=None) sitting.end_date = data["end_date"].replace(tzinfo=None) sitting.sitting_length = data.get("event_length") if "language" in data.keys(): sitting.language = data["language"] if "venue" in data.keys(): sitting.venue_id = data["venue"] sitting.short_name = data.get("short_name", None) sitting.activity_type = data.get("activity_type", None) sitting.meeting_type = data.get("meeting_type", None) sitting.convocation_type = data.get("convocation_type", None) session.flush() notify(ObjectModifiedEvent(sitting)) self.template_data.append({"sitting_id": sitting.sitting_id, "action": "updated", "ids": data["ids"]}) self.request.response.setHeader("Content-type", "text/xml") return self.xml_template()
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"] not in [None, "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 length = data["event_length"] sitting_length = timedelta(seconds=length) base_sitting_length = sitting_length + timedelta(hours=1) initial_sitting = None recurrent_sittings = [] dates = self.generate_dates(data) for count, date in enumerate(dates): sitting = domain.Sitting() sitting.group_id = trusted.group_id sitting.short_name = data.get("short_name", None) sitting.start_date = date sitting.language = data["language"] sitting.venue_id = data["venue"] sitting.activity_type = data.get("activity_type", None) sitting.meeting_type = data.get("meeting_type", None) sitting.convocation_type = data.get("convocation_type", None) if not count: sitting.end_date = dates[len(dates) - 1] + base_sitting_length sitting.recurring_type = data.get("rec_type") sitting.recurring_id = 0 sitting.sitting_length = length session.add(sitting) session.flush() initial_sitting = sitting else: end_date = date + sitting_length sitting.end_date = end_date sitting.sitting_length = int(time.mktime(date.timetuple())) sitting.recurring_id = initial_sitting.sitting_id session.add(sitting) recurrent_sittings.append(sitting) session.flush() for s in [initial_sitting] + recurrent_sittings: notify(ObjectCreatedEvent(s)) self.template_data.append({"sitting_id": s.sitting_id, "action": "inserted", "ids": data["ids"]}) self.request.response.setHeader("Content-type", "text/xml") return self.xml_template() else: sitting = domain.Sitting() sitting.short_name = data.get("short_name", None) sitting.start_date = data["start_date"].replace(tzinfo=None) sitting.end_date = data["end_date"].replace(tzinfo=None) sitting.recurring_type = data["rec_type"] sitting.sitting_length = data.get("event_length") sitting.recurring_id = data.get("event_pid") sitting.group_id = trusted.group_id sitting.language = data["language"] sitting.venue_id = data["venue"] sitting.activity_type = data.get("activity_type", None) sitting.meeting_type = data.get("meeting_type", None) sitting.convocation_type = data.get("convocation_type", None) session.add(sitting) session.flush() notify(ObjectCreatedEvent(sitting)) sitting_action = "inserted" if data["rec_type"] == "none": sitting_action = "deleted" self.template_data.append({"sitting_id": sitting.sitting_id, "action": sitting_action, "ids": data["ids"]}) self.request.response.setHeader("Content-type", "text/xml") return self.xml_template()
def handle_update(self, action, data): session = Session() self.template_data = [] venue_id = unicode(data["venue"]) if data['venue'] else None data["rec_end_date"] = data["end_date"] data["headless"] = 'true' self.request.form["venue_id"] = data["venue_id"] = venue_id self.request.form["headless"] = "true" if ("rec_type" in data.keys()) and (data["rec_type"] is not None): # updating recurring events - we assume existing events fall # at the beginning of the sequence and offer in place update. parent_sitting_id = get_real_id(data["ids"] or data["event_pid"]) length = data["event_length"] sitting_length = timedelta(seconds=length) base_sitting_length = sitting_length + timedelta(hours=1) siblings_filter = or_( domain.Sitting.recurring_id == parent_sitting_id, domain.Sitting.sitting_id == parent_sitting_id) siblings = [ sitting for sitting in self.sittings_container.batch( order_by=(domain.Sitting.sitting_id), limit=None, filter=siblings_filter) ] dates = self.generate_dates(data) current_count = len(siblings) for count, date in enumerate(dates): is_new = not count < current_count 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 if is_new: add_form = AddForm(self.sittings_container, request_copy) add_form.update() if add_form.errors: log.error("Could not add sitting in sequence: %s", sitting_data) continue else: sitting = add_form.created_object sitting.recurring_id = parent_sitting_id else: sitting = siblings[count] if not count: sitting.recurring_end_date = dates[len(dates) - 1] + base_sitting_length sitting.recurring_type = data.get("rec_type") sitting.recurring_id = 0 sitting.sitting_length = length else: sitting.sitting_length = int(time.mktime(date.timetuple())) sitting.recurring_type = None if not is_new: edit_form = EditForm(sitting, request_copy) edit_form.update() if edit_form.errors: continue else: session.merge(edit_form.context) else: session.merge(sitting) self.template_data.append({ "sitting_id": sitting.sitting_id, "action": (is_new and "inserted" or "updated"), "ids": create_id(sitting) }) #delete any sittings outside recurring bounds for del_sibling in siblings[len(dates):]: delete_form = DeleteForm(del_sibling, self.request) delete_form.update() if delete_form.errors: continue else: self.template_data.append({ "sitting_id": del_sibling.sitting_id, "action": "deleted", "ids": create_id(del_sibling) }) else: sitting_id = get_real_id(data["ids"]) parent_id = get_real_id(data["event_pid"]) sitting = self.sittings_container.get(sitting_id) if sitting is None: sitting = self.sittings_container.get(int(parent_id)) edit_form = EditForm(sitting, self.request) edit_form.update() if edit_form.errors: return self.update_sitting_failure_handler( action, data, edit_form.errors) else: sitting.sitting_length = data.get("event_length") session.merge(sitting) self.template_data.append({ "sitting_id": sitting.sitting_id, "action": "updated", "ids": data["ids"], }) self.request.response.setHeader("Content-type", "text/xml") return self.xml_template()
def handle_insert(self, action, data): session = Session() data["rec_end_date"] = data["end_date"] self.template_data = [] 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(self.sittings_container, 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(self.sittings_container, 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 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.short_name = data.get("short_name", None) sitting.start_date = date sitting.end_date = date + sitting_length sitting.language = data["language"] sitting.venue_id = data["venue"] sitting.activity_type = data.get("activity_type", None) sitting.meeting_type = data.get("meeting_type", None) sitting.convocation_type = data.get("convocation_type", None) 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.short_name = data.get("short_name", None) 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"] sitting.activity_type = data.get("activity_type", None) sitting.meeting_type = data.get("meeting_type", None) sitting.convocation_type = data.get("convocation_type", None) 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()