def checkEmail(self): session = Session() users = session.query(User).filter(User.email==self.email) if users.count() > 1: raise interface.Invalid(_("Email already taken!"),"email") if users.count() == 1 and users.first().user_id != get_db_user().user_id: raise interface.Invalid(_("Email already taken!"),"email")
def create_simple_workflow( ): transitions = [] add = transitions.append add( workflow.Transition( transition_id = 'create', title='Create', trigger = iworkflow.AUTOMATIC, source = None, destination = states.new ) ) add( workflow.Transition( transition_id = 'submit-clerk', title=_(u'Submit to Clerk'), source = states.new, destination = states.pending ) ) add( workflow.Transition( transition_id = 'Schedule', title=_(u'Schedule'), source = states.pending, destination = states.scheduled ) ) return transitions
def title(self): session = Session() context = session.merge(removeSecurityProxy(self.context)) time = context.sitting_time if time is not None: return "%s (%s)" % (_(u"Discussion"), context.sitting_time) return _(u"Discussion")
def description(self): context = _merged(self.context) return "%s %s (%s %s %s)" % (translate_i18n(_(u"Debate record of ")), self.translate(context.sitting, "short_name"), context.sitting.start_date.strftime('%Y-%m-%d %H:%M'), _(u"to"), context.sitting.end_date.strftime('%H:%M'))
def title(self): context = _merged(self.context) return "%s %s, %s %s %s" % (translate_i18n(_(u"Debate Record:")), self.translate(context.sitting, "short_name"), context.sitting.start_date.strftime('%Y-%m-%d, %H:%M'), _(u"to"), context.sitting.end_date.strftime('%H:%M'))
def validate_parliament_dates(action, data, context, container): """Parliaments must not overlap.""" errors = [] if interfaces.IParliament.providedBy(context): parliament = context else: parliament = None results = queries.validate_date_in_interval(parliament, domain.Parliament, data["start_date"]) for result in results: overlaps = result.short_name errors.append(interface.Invalid(_("The start date overlaps with (%s)") % overlaps, "start_date")) if data["end_date"]: results = queries.validate_date_in_interval(parliament, domain.Parliament, data["start_date"]) for result in results: overlaps = result.short_name errors.append(interface.Invalid(_("The end date overlaps with (%s)") % overlaps, "end_date")) results = queries.validate_date_in_interval(parliament, domain.Parliament, data["election_date"]) for result in results: overlaps = result.short_name errors.append(interface.Invalid(_("The election date overlaps with (%s)") % overlaps, "election_date")) if parliament is None: results = queries.validate_open_interval(parliament, domain.Parliament) for result in results: overlaps = result.short_name errors.append( interface.Invalid(_("Another parliament is not yet dissolved (%s)") % overlaps, "election_date") ) return errors
def description(self): session = Session() context = session.merge(removeSecurityProxy(self.context)) text = "%s %s %s" % (translate_i18n(_(u"Submitted by")), context.owner.first_name, context.owner.last_name) if context.notice_date: text += " (%s %s)" % (translate_i18n(_(u"notice given on")), self.formatDate(context.notice_date)) return text + "."
def validate_group_membership_dates(action, data, context, container): """ A User must be member of a group only once at a time """ errors = [] group_id = container.__parent__.group_id if interfaces.IBungeniGroupMembership.providedBy(context): group_membership = context else: group_membership = None #!(murithi, apr-2011) VALIDATION - this may be improved user_id = data.get("user_id", None) if user_id is None: return errors session = Session() if data["start_date"]: for r in queries.validate_membership_in_interval( group_membership, domain.GroupMembership, data["start_date"], user_id, group_id ): overlaps = r.group.short_name errors.append( interface.Invalid(_("The person is a member in (%s) at that date") % overlaps, "start_date", "user_id") ) if data["end_date"]: for r in queries.validate_membership_in_interval( group_membership, domain.GroupMembership, data["end_date"], user_id, group_id ): overlaps = r.group.short_name errors.append( interface.Invalid(_("The person is a member in (%s) at that date") % overlaps, "end_date", "user_id") ) for r in queries.validate_open_membership(group_membership, domain.GroupMembership, user_id, group_id): overlaps = r.group.short_name errors.append( interface.Invalid(_("The person is a member in (%s) at that date") % overlaps, "end_date", "user_id") ) return errors
def validate_party_membership(action, data, context, container): errors = [] parent_id = getattr(container.__parent__, "parent_group_id", None) if interfaces.IPartyMember.providedBy(context): party_member = context user_id = context.user_id else: party_member = None user_id = data["user_id"] if data.get("start_date", None): for r in queries.validate_membership_in_interval( party_member, AllPartyMemberships, data["start_date"], user_id, parent_id=parent_id, with_parent=True ): overlaps = r.short_name errors.append(interface.Invalid(_("The person is a member in (%s) at that date") % overlaps, "start_date")) if data.get("end_date", None): for r in queries.validate_membership_in_interval( party_member, AllPartyMemberships, data["end_date"], user_id, parent_id=parent_id, with_parent=True ): overlaps = r.short_name errors.append(interface.Invalid(_("The person is a member in (%s) at that date") % overlaps, "end_date")) for r in queries.validate_open_membership( party_member, AllPartyMemberships, user_id, parent_id=parent_id, with_parent=True ): overlaps = r.short_name errors.append(interface.Invalid(_("The person is a member in (%s) at that date") % overlaps, "end_date")) return errors
def description(self): context = _merged(self.context) return "%s %s (%s %s %s)" % (translate_i18n(_(u"Sitting scheduled for")), self.translate(context.group, "short_name"), context.start_date.strftime('%Y-%m-%d %H:%M'), _(u"to"), context.end_date.strftime('%H:%M'))
def title(self): session = Session() context = session.merge(removeSecurityProxy(self.context)) return "%s %s, %s %s %s" % (_(u"Sitting:"), self.translate(context.group, "short_name"), context.start_date.strftime('%Y-%m-%d, %H:%M'), _(u"to"), context.end_date.strftime('%H:%M'))
def title(self): if is_translation(self.context): language = get_language_by_name(self.context.language)['name'] return _(u"$language translation", mapping={'language': language}) return _(u"Version $version", mapping={'version': self.context.version_id})
def title(self): session =Session() context = session.merge(removeSecurityProxy(self.context)) time = context.sitting_time if time is not None: return _(u"Discussion ($time)", mapping={'time': context.sitting_time}) return _(u"Discussion")
def description(self): context = _merged(self.context) text = "%s %s %s" % (translate_i18n(_("Submitted by")), context.owner.first_name, context.owner.last_name) if context.group: text += " to %s" % IDCDescriptiveProperties(context.group).title if context.admissible_date: text += " (%s %s)" % (translate_i18n(_(u"Approved on")), self.formatDate(context.admissible_date)) return text + "."
def description(self): session = Session() context = session.merge(removeSecurityProxy(self.context)) return "%s %s (%s %s %s)" % (_(u"Sitting scheduled for"), context.group.short_name, context.start_date.strftime('%Y-%m-%d %H:%M'), _(u"to"), context.end_date.strftime('%H:%M'))
def handle_login(self, action, data): if IUnauthenticatedPrincipal.providedBy(self.request.principal): self.status = _(u"Invalid account credentials") else: site_url = ui_utils.url.absoluteURL(getSite(), self.request) camefrom = self.request.get('camefrom', site_url+'/') self.status = _("You are now logged in") self.request.response.redirect( camefrom )
def title(self): context = _merged(self.context) return "%s %s, %s %s %s" % ( translate_i18n(_(u"Sitting:")), self.translate(context.group, "short_name"), context.start_date.strftime("%Y-%m-%d, %H:%M"), _(u"to"), context.end_date.strftime("%H:%M"), )
def login_exists(login): session = Session() users = session.query(domain.User).filter( domain.User.login==login).all() if len(users) == 0: return False else: print _(u"Error : That login exists already") return True
def description(self): session = Session() context = session.merge(removeSecurityProxy(self.context)) text = "%s %s %s" % (_("Submitted by"), context.owner.first_name, context.owner.last_name) if context.ministry: text += " to %s" % IDCDescriptiveProperties(context.ministry).title if context.admissible_date: text += " (%s %s)" % (_(u"Approved on"), self.formatDate(context.admissible_date)) return text + "."
def __call__(self): if self._data is not None: #session = Session() #parent = session.query(domain.Question).get(self._data) context = removeSecurityProxy (self.context.context) parent = context.getParentQuestion() return _(u"Supplementary Question to: <br/> %s") % parent else: return _(u"Initial Question")
def description(self): session = Session() context = session.merge(removeSecurityProxy(self.context)) text = "%s %s %s" % (_("Submitted by"), context.owner.first_name, context.owner.last_name) if context.publication_date: text += " (%s %s)" % (_(u"published on"), self.formatDate(context.publication_date)) return text + "."
def description(self): session = Session() context = session.merge(removeSecurityProxy(self.context)) return "%s %s (%s %s %s)" % ( translate_i18n(_(u"Sitting scheduled for")), self.translate(context.group, "short_name"), context.start_date.strftime("%Y-%m-%d %H:%M"), _(u"to"), context.end_date.strftime("%H:%M"), )
def save_password(self, action, data): password = data.get("pswd","") confirm_password= data.get("confirm_password","") if password: if password != confirm_password: self.status = _("Password confirmation failed") return self.user._password = password self.status = _("Password changed")
class IChangePasswordForm(interface.Interface): old_password = schema.Password(title=_(u"Old password"), required=True) pswd = schema.Password(title=_(u"Password"), required=True) confirm_password = schema.Password(title=_(u"Confirm password"), required=True) @invariant def checkOldPassword(self): if not get_db_user().checkPassword(self.old_password): raise interface.Invalid(_("Old password incorrect"), 'old_password')
def save_profile(self, action, data): email = data.get("email","") first_name = data.get("first_name","") last_name = data.get("last_name","") middle_name = data.get("middle_name","") description = data.get("description","") gender = data.get("gender","") image = data.get("image","") date_of_birth = data.get("date_of_birth","") birth_nationality = data.get("birth_nationality","") birth_country = data.get("birth_country","") current_nationality = data.get("current_nationality","") if email: users = self.session.query(User).filter(User.email==email) if (users.count() == 1 and users.first().user_id == self.user.user_id) or\ users.count() == 0: self.user.email = email else: self.status = _("Email already taken!") return if first_name: self.user.first_name = first_name if last_name: self.user.last_name = last_name if middle_name: self.user.middle_name = middle_name if description: self.user.description = description if gender: self.user.gender = gender if date_of_birth: self.user.date_of_birth = date_of_birth if image: self.user.image = image if birth_nationality: self.user.birth_nationality = birth_nationality if birth_country: self.user.birth_country = birth_country if current_nationality: self.user.current_nationality = current_nationality self.status = _("Profile data updated")
def main(): check_login = True while check_login: login = raw_input(_("Enter admin login name ")) check_login = login_exists(login) check_pass = False while not check_pass: password = raw_input(_("Enter password ")) confirm_password = raw_input(_("Confirm password ")) check_pass = check_password(password, confirm_password) email_address = raw_input(_("Enter Email Address ")) add_admin(login, password, email_address)
def save_profile(self, action, data): email = data.get("email", "") first_name = data.get("first_name", "") last_name = data.get("last_name", "") middle_name = data.get("middle_name", "") description = data.get("description", "") gender = data.get("gender", "") image = data.get("image", "") date_of_birth = data.get("date_of_birth", "") birth_nationality = data.get("birth_nationality", "") birth_country = data.get("birth_country", "") current_nationality = data.get("current_nationality", "") if email: users = self.session.query(User).filter(User.email == email) if (users.count() == 1 and users.first().user_id == self.user.user_id) or\ users.count() == 0: self.user.email = email else: self.status = _("Email already taken!") return if first_name: self.user.first_name = first_name if last_name: self.user.last_name = last_name if middle_name: self.user.middle_name = middle_name if description: self.user.description = description if gender: self.user.gender = gender if date_of_birth: self.user.date_of_birth = date_of_birth if image: self.user.image = image if birth_nationality: self.user.birth_nationality = birth_nationality if birth_country: self.user.birth_country = birth_country if current_nationality: self.user.current_nationality = current_nationality self.status = _("Profile data updated")
def email_validator(action, data, context, container): session = Session() users = session.query(domain.User)\ .filter(domain.User.email==data.get("email","")) if users.count() > 1: return [interface.Invalid(_(u"Email already taken!"),"email"),] if context: if users.count() == 1 and users.first().user_id != context.user_id: return [interface.Invalid(_(u"Email already taken!"),"email"),] elif users.count() > 0: return [interface.Invalid(_(u"Email already taken!"),"email"),] return []
class IAdvancedSearch(ISearch): language = schema.Choice(title=_("Language"), values=("en", "fr", "pt", "sw", "it", "en-ke"), required=False) content_type = schema.Choice( title=_("Content type"), values=("Question", "MemberOfParliament", "Motion", "Committee", "User", "Parliament", "AgendaItem", "TabledDocument", "PoliticalParty", "Goverment", "Ministry", "Report", "Attachment", "Bill", "Sitting", "PoliticalGroup"), required=False) status_date = schema.Date(title=_("Status date"), required=False)
def verbose_title(self): context = _merged(self.context) sitting_title = _( "verbose_sitting_title", default=u"Sitting of ${group_name} @ ${sitting_venue}", mapping={ "group_name": IDCDescriptiveProperties(context.group).title, "sitting_venue": (IDCDescriptiveProperties(context.venue).title if context.venue else translate_i18n(_(u"no venue"))) }) return translate_i18n(sitting_title)
def verbose_title(self): context = _merged(self.context) sitting_title = _("verbose_sitting_title", default=u"Sitting of ${group_name} @ ${sitting_venue}", mapping = { "group_name": IDCDescriptiveProperties(context.group).title, "sitting_venue": ( IDCDescriptiveProperties(context.venue).title if context.venue else translate_i18n(_(u"no venue")) ) } ) return translate_i18n(sitting_title)
def handle_restore(self, action, data): site_url = ui_utils.url.absoluteURL(getSite(), self.request) login = data.get("login", "") email = data.get("email", "") user = None app = BungeniApp() settings = EmailSettings(app) session = Session() if email: user = session.query(User).filter( User.email==email).first() elif login: user = session.query(User).filter( User.login==login).first() email = user.email if user: link = session.query(PasswordRestoreLink).filter( PasswordRestoreLink.user_id==user.user_id).first() if link: if not link.expired(): self.status = _(u"This user's link is still active!") return else: link = PasswordRestoreLink() link.hash = hashlib.sha224(user.login + SECRET_KEY + str(datetime.datetime.now())).hexdigest() link.expiration_date = datetime.datetime.now() + datetime.timedelta(1) link.user_id = user.user_id session.add(link) mailer = getUtility(ISMTPMailer, name="bungeni.smtp") self.message = _(u"Restore password link: ")\ + "%s/reset_password?key=%s" % (site_url, link.hash) self.message += u"\n\n" self.message += _(u"This link will expire in 24 hours.") text = ViewPageTemplateFile("templates/mail.pt")(self) message = MIMEText(text) message.set_charset("utf-8") message["Subject"] = _(u"Bungeni password restoration") message["From"] = settings.default_sender mailer.send(settings.default_sender, email, str(message)) self.status = _(u"Email was sent!")
def handle_restore(self, action, data): site_url = ui_utils.url.absoluteURL(getSite(), self.request) login = data.get("login", "") email = data.get("email", "") user = None app = BungeniApp() settings = EmailSettings(app) session = Session() if email: user = session.query(User).filter(User.email == email).first() elif login: user = session.query(User).filter(User.login == login).first() email = user.email if user: link = session.query(PasswordRestoreLink).filter( PasswordRestoreLink.user_id == user.user_id).first() if link: if not link.expired(): self.status = _(u"This user's link is still active!") return else: link = PasswordRestoreLink() link.hash = hashlib.sha224( user.login + SECRET_KEY + str(datetime.datetime.now())).hexdigest() link.expiration_date = datetime.datetime.now( ) + datetime.timedelta(1) link.user_id = user.user_id session.add(link) mailer = getUtility(ISMTPMailer, name="bungeni.smtp") self.message = _(u"Restore password link: ")\ + "%s/reset_password?key=%s" % (site_url, link.hash) self.message += u"\n\n" self.message += _(u"This link will expire in 24 hours.") text = ViewPageTemplateFile("templates/mail.pt")(self) message = MIMEText(text) message.set_charset("utf-8") message["Subject"] = _(u"Bungeni password restoration") message["From"] = settings.default_sender mailer.send(settings.default_sender, email, str(message)) self.status = _(u"Email was sent!")
class Login( BaseForm ): form_fields = form.Fields( ILoginForm ) prefix = "" form_name = _(u"Login") @form.action( _(u"Login") ) def handle_login(self, action, data): if IUnauthenticatedPrincipal.providedBy(self.request.principal): self.status = _(u"Invalid account credentials") else: site_url = ui_utils.url.absoluteURL(getSite(), self.request) camefrom = self.request.get('camefrom', site_url+'/') self.status = _("You are now logged in") self.request.response.redirect( camefrom )
def transitions(): return [ workflow.Transition( title="Create", source=None, destination="new", trigger=iworkflow.AUTOMATIC, ), workflow.Transition(title=_(u"Submit to Clerk"), source="new", destination="pending"), workflow.Transition(title=_(u"Schedule"), source="pending", destination="scheduled") ]
def get_js(self): pagedate = datetime.date.today() if self.maxDate < pagedate: pagedate = self.maxDate if ((type(self._data) == datetime.date) or (type(self._data) == datetime.datetime) ): pagedate = self._data calendar = self.request.locale.dates.calendars["gregorian"] month = _(u"Choose Month") year = _(u"Enter Year") submit = _("OK") cancel = _(u"Cancel") invalidYear = _(u"Please enter a valid year") months_short = self.jstr(calendar.getMonthAbbreviations()) months_long = self.jstr(calendar.getMonthNames()) w_day_1char = self.jstr( [dn[:1] for dn in calendar.getDayAbbreviations()]) w_day_short = self.jstr( [dn[:2] for dn in calendar.getDayAbbreviations()]) w_day_medium = self.jstr(calendar.getDayAbbreviations()) w_day_long = self.jstr(calendar.getDayNames()) return self.js_template % { "name": self.field_name, "sel_day": self._day_name, "sel_month": self._month_name, "sel_year": self._year_name, "txt_date": self.date_name, "mindate": self.minDate.strftime("%m/%d/%Y"), "maxdate": self.maxDate.strftime("%m/%d/%Y"), "pagedate": pagedate.strftime("%m/%Y"), "months_short": months_short, "months_long": months_long, "w_day_1char": w_day_1char, "w_day_short": w_day_short, "w_day_medium": w_day_medium, "w_day_long": w_day_long, "month": translate( str(month), domain="bungeni", context=self.request), "year": translate( str(year), domain="bungeni", context=self.request), "submit": translate( str(submit), domain="bungeni", context=self.request), "cancel": translate( str(cancel), domain="bungeni", context=self.request), "invalidYear": translate( str(invalidYear), domain="bungeni", context=self.request) }
def handle_reset(self, action, data): site_url = ui_utils.url.absoluteURL(getSite(), self.request) password = data.get("password", "") confirm_password = data.get("confirm_password", "") if password.__class__ is not object: if password != confirm_password: self.status = _(u"Password confirmation failed!") return if password and password == confirm_password and self.link: if not self.link.expired(): user = self.link.user user._password = password self.link.expiration_date = datetime.datetime.now() self.status = _(u"Password successfully reset!")
class ItemScheduleContainerDeleteForm(DeleteForm): class IDeleteForm(interface.Interface): item_id = schema.Int( title=_(u"Item ID"), required=True ) item_type = schema.TextLine( title=_(u"Item Type"), required=True ) form_fields = form.Fields(IDeleteForm) @form.action(_(u"Delete")) def handle_delete(self, action, data): session = Session() sitting_id = self.context.__parent__.sitting_id sch = session.query(domain.ItemSchedule).filter( sql.and_( model_schema.item_schedule.c.sitting_id == sitting_id, model_schema.item_schedule.c.item_id == data["item_id"], model_schema.item_schedule.c.item_type == data["item_type"] )).all() for i in sch: session.delete(i) self.request.response.redirect(self.next_url)
def handle_search(self, action, data): self.searcher = component.getUtility(interfaces.IIndexSearch)() search_term = data["full_text"] if not search_term: self.status = _(u"Invalid Query") return # Setting FLAG_PARTIAL to search incomplete words if len(search_term) > MINIMAL_PARTIAL_QUERY: self.searcher._qp_flags_base |= _xapian.QueryParser.FLAG_PARTIAL # compose query t = time.time() lang = self.request.locale.getLocaleID() if lang == "en_US": lang = "en" if lang == "en_KE": lang = "en-ke" text_query = self.searcher.query_parse(search_term) lang_query = self.searcher.query_field('language', lang) self.query = self.searcher.query_composite(self.searcher.OP_AND, ( text_query, lang_query, )) self.results = self._results self.search_time = time.time() - t # spelling suggestions suggestion = self.searcher.spell_correct(search_term) self.spelling_suggestion = (search_term != suggestion and suggestion or None)
class SendNotificationToMinistryUponComplete(Notification): """At the same time the question is also forwarded to the ministry.""" component.adapts(interfaces.IQuestionCompleteEvent) body = _('notification_email_to_ministry_upon_complete_question', default=u"Question assigned to ministry") @property def subject(self): return u'Question asked to ministry: %s' % self.context.short_name @property def condition(self): return self.context.ministry_id @property def from_address(self): return prefs.getClerksOfficeEmail() @property def recipient_address(self): session = Session() ministry = session.query(domain.Ministry).get(self.context.ministry_id) return dbutils.getMinsiteryEmails(ministry)
def title_member(self): session = Session() context = session.merge(removeSecurityProxy(self.context)) mp_user = None try: mp_user = session.query(domain.MemberOfParliament).filter( domain.MemberOfParliament.user_id == context.user_id ).one() except NoResultFound: #this user has no associated MP record pass except MultipleResultsFound: # this should not happen log.error("Multiple MP objects found for : %s", context.__str__()) finally: if mp_user is None: return self.title dc_constituency = IDCDescriptiveProperties(mp_user.constituency) return _("member_title_with_constituency", default=u"Member of Parliament for ${constituency} (${member})", mapping = { "constituency": dc_constituency.title, "member": self.title } )
def validate_non_overlapping_sitting(action, data, context, container, *fields): start = data.get('start_date') end = data.get('end_date', None) if not fields: fields = "start_date", "end_date" session = Session() group_id = container.__parent__.group_id group = session.query(domain.Group).get(group_id) sittings = group.sittings for sitting in queries.get_sittings_between(sittings, start, end): if context != sitting: return [ interface.Invalid( _( u"One or more events would be scheduled for $F, which " "overlaps with an existing sitting", mapping={'F': datetimedict.fromdatetime(start)}), *fields) ] return []
def validate_venues(action, data, context, container): """A venue can only be booked for one sitting at once.""" errors = [] if interfaces.IGroupSitting.providedBy(context): sitting = context else: sitting = None venue_id = data.get('venue_id') if venue_id is not None: venue_id = long(venue_id) session = Session() svenue = session.query(domain.Venue).get(venue_id) else: return [] start = data.get('start_date') end = data.get('end_date') if not (start and end): return [] for booking in venue.check_venue_bookings(start, end, svenue, sitting): errors.append( interface.Invalid( _(u'Venue "$venue" already booked in this time slot', mapping={'venue': booking.short_name}), "venue_id")) return errors
def description(self): session =Session() context = session.merge(removeSecurityProxy(self.context)) return _(u"Sitting scheduled for '$group' ($start to $end)", mapping={'group': context.group.short_name, 'start': context.start_date.strftime('%Y-%m-%d %H:%M'), 'end': context.end_date.strftime('%H:%M')})
def handle_search(self, action, data): self.searcher = component.getUtility(interfaces.IIndexSearch)() search_term = data['full_text'] content_type = data['content_type'] lang = data['language'] indexed_field = data.get('field', '') status = data.get('status', '') status_date = data['status_date'] owner = data.get('owner', '') if not lang: lang = 'en' if not search_term: self.status = _(u"Invalid Query") return # compose query t = time.time() if content_type and indexed_field and indexed_field != 'all': text_query = self.searcher.query_field(indexed_field, search_term) lang_query = self.searcher.query_field('language', lang) self.query = self.searcher.query_composite(self.searcher.OP_AND, \ (text_query, lang_query,)) else: text_query = self.searcher.query_parse(search_term) lang_query = self.searcher.query_field('language', lang) self.query = self.searcher.query_composite(self.searcher.OP_AND, \ (text_query, lang_query,)) if content_type: content_type_query = self.searcher.query_field( 'object_type', content_type) self.query = self.searcher.query_composite(self.searcher.OP_AND, \ (self.query, content_type_query,)) if content_type and status: status_query = self.searcher.query_field('status', status) self.query = self.searcher.query_composite(self.searcher.OP_AND, \ (self.query, status_query,)) if status_date: status_date_query = self.searcher.query_field( 'status_date', index.date_value(status_date)) self.query = self.searcher.query_composite(self.searcher.OP_AND, \ (self.query, status_date_query,)) if owner: owner_query = self.searcher.query_field('owner', str(owner)) self.query = self.searcher.query_composite(self.searcher.OP_AND, \ (self.query, owner_query,)) self.results = self._results self.search_time = time.time() - t # spelling suggestions suggestion = self.searcher.spell_correct(search_term) self.spelling_suggestion = (search_term != suggestion and suggestion or None)
def description(self): session = Session() context = session.merge(removeSecurityProxy(self.context)) return u"%s %s to %s" % (translate_i18n(_(u"Covers")), context.start_date.strftime('%Y-%m-%d'), context.end_date.strftime('%Y-%m-%d') )
def validate_venues(action, data, context, container): """A venue can only be booked for one sitting at once.""" errors = [] if interfaces.ISitting.providedBy(context): sitting = context else: sitting = None venue_id = data.get('venue_id') if venue_id is not None: venue_id = long(venue_id) session = Session() svenue = session.query(domain.Venue).get(venue_id) else: return [] start = data.get('start_date') end = data.get('end_date') if not(start and end): return [] for booking in venue.check_venue_bookings( start, end, svenue, sitting): errors.append( interface.Invalid( _(u'Venue "$venue" already booked in this time slot', mapping={'venue': booking.short_name}), "venue_id")) return errors
def search_status(self): return _("Found ${total} results in ${search_time} Seconds", mapping={ "total": self.doc_count, "search_time": format(float(self.search_time), "0.5f") } )
def handle_search(self, action, data): self.searcher = component.getUtility(interfaces.IIndexSearch)() search_term = data['full_text'] if not search_term: self.status = _(u"Invalid Query") return # compose query t = time.time() lang = self.request.locale.getLocaleID() if lang == "en_US": lang = "en" if lang == "en_KE": lang = "en-ke" text_query = self.searcher.query_parse(search_term) lang_query = self.searcher.query_field('language', lang) self.query = self.searcher.query_composite(self.searcher.OP_AND, ( text_query, lang_query, )) self.results = self._results self.search_time = time.time() - t # spelling suggestions suggestion = self.searcher.spell_correct(search_term) self.spelling_suggestion = (search_term != suggestion and suggestion or None)
class SendPasswordRecoveryLinkForm(PageForm): """Form to generate token and send it to the user.""" class IPassRecoveryForm(interface.Interface): login_or_email = schema.TextLine(title=_(u"Login or email"), required=False) form_fields = form.Fields(IPassRecoveryForm) @form.action(_(u"Send")) def handle_send(self, action, data): session = Session() utility = getUtility(IPasswordRecoveryTokenUtility) login_or_email = data.get("login_or_email", "") user = session.query(User).filter(or_(User.login==login_or_email, User.email==login_or_email)).first() if user is not None: token = utility.generate_token(user) base_url = ui_utils.url.absoluteURL(getSite(), self.request) recovery_url = base_url + "/recover-password?token=" + token.token # TODO: Isn't there a way to change this template in an easy way(in # admin maybe? Or as a ZPT) text = "Password recovery link:" + recovery_url msg = MIMEText(text) msg["Subject"] = "Password recovery" # TODO: this must be changed. There must be a global config for info # email. msg["From"] = "*****@*****.**" msg["To"] = user.email print msg dispatch(msg)
def getFieldColumns(self): column_model = [] field_model = [] for field in workspace_fields: coldef = { "key": field.name, "label": translate(_(field.title), context=self.request), "formatter": self.context.__name__ } if column_model == []: column_model.append("""{key:"%(key)s", label:"%(label)s", formatter:"%(formatter)sCustom", sortable:false, minWidth:200, resizeable:true}""" % coldef) else: column_model.append("""{key:"%(key)s", label:"%(label)s", sortable:false, resizeable:true, minWidth:150}""" % coldef) '''if column_model == []: column_model.append( """{label:"%(label)s", key:"sort_%(key)s", formatter:"%(formatter)sCustom", sortable:true, resizeable:true , children: [ { key:"%(key)s", sortable:false}]}""" % coldef ) else: column_model.append( """{label:"%(label)s", key:"sort_%(key)s", sortable:true, resizeable:true, children: [ {key:"%(key)s", sortable:false}] }""" % coldef )''' field_model.append('{key:"%s"}' % (field.name)) return ",".join(column_model), ",".join(field_model)
def must_limit_recurrence(recurring): if recurring.weekdays or recurring.monthly: if recurring.repeat or recurring.repeat_until: return raise interface.Invalid( _(u"Must limit recurrence (by number or date)"), "repeat", "repeat_until")
def description(self): session =Session() context = session.merge(removeSecurityProxy(self.context)) sitting = context.sitting return _(u"Scheduled for sitting ($start to $end)", mapping={'start': sitting.start_date, 'end': sitting.end_date})
def validate_government_dates(action, data, context, container): errors = [] if interfaces.IGovernment.providedBy(context): government = context else: government = None if container.__parent__.end_date is not None: if data['start_date'] > container.__parent__.end_date: errors.append( interface.Invalid( _("Start date cannot be after the parliaments dissolution (%s)" ) % container.__parent__.end_date, "start_date")) if container.__parent__.start_date > data['start_date']: errors.append( interface.Invalid( _("Start date must start after the swearing in of the parliament (%s)" ) % container.__parent__.start_date, "start_date")) results = queries.validate_date_in_interval(government, domain.Government, data['start_date']) for result in results: overlaps = result.short_name errors.append( interface.Invalid( _("The start date overlaps with (%s)") % overlaps, "start_date")) if data['end_date']: results = queries.validate_date_in_interval(government, domain.Government, data['start_date']) for result in results: overlaps = result.short_name errors.append( interface.Invalid( _("The end date overlaps with (%s)") % overlaps, "end_date")) if government is None: results = queries.validate_open_interval(government, domain.Government) for result in results: overlaps = result.short_name errors.append( interface.Invalid( _("Another government is not yet dissolved (%s)") % overlaps, "start_date")) return errors
def description(self): context = _merged(self.context) sitting = context.sitting return _(u"Scheduled for sitting ($start to $end)", mapping={ 'start': sitting.start_date, 'end': sitting.end_date })
def checkEmail(self): session = Session() users = session.query(User).filter(User.email==self.email) message = _("error_profile_email_taken", "Email already taken!") if users.count() > 1: raise interface.Invalid(message,"email") if users.count() == 1 and users.first().user_id != get_db_user().user_id: raise interface.Invalid(message,"email")
class TextDateTimeWidget(TextDateWidget): __call__ = ViewPageTemplateFile("templates/textdatetimewidget.pt") @property def time_name(self): return self.name.replace(".", "__") + "__time" def hasInput(self): return (self.date_name in self.request.form and self.time_name in self.request.form) def _hasPartialInput(self): return (self.date_name in self.request.form or self.time_name in self.request.form) def _getFormInput(self): """extract the input value from the submitted form """ return (self._getFieldInput(self.date_name), self._getFieldInput(self.time_name)) def _toFormValue(self, value): """Convert a field value to a string that can be inserted into the form. """ if (value == self.context.missing_value) and self.required: d = datetime.datetime.now() return (datetime.datetime.strftime(d, "%Y-%m-%d"), datetime.datetime.strftime(d, "%H:%M")) else: try: return (datetime.datetime.strftime(value, "%Y-%m-%d"), datetime.datetime.strftime(value, "%H:%M")) except: return ("", "") def _toFieldValue(self, (date, time)): if (date == self._missing or time == self._missing): if self.required: return self.context.missing_value else: if date + time == self._missing: return None else: return self.context.missing_value else: try: d = datetime.datetime.strptime(date, "%Y-%m-%d") t = datetime.datetime.strptime(time, "%H:%M") return datetime.datetime( year=d.year, month=d.month, day=d.day, hour=t.hour, minute=t.minute, ) except ValueError, e: raise ConversionError( _(u"Incorrect string data for date and time"), e)