# prevent AttributeErrors on first read self.category = None self.persons = None def __repr__(self): """Custom repr to look inside the event for debugging purposes.""" fstr = ("<{0.__class__.__name__}" " datetime='{0.datetime}'" " title={1!r}," " deleted={0.deleted}>") return fstr.format( self, icemac.addressbook.interfaces.ITitle(self, '<unknown>')) event_entity = icemac.addressbook.entities.create_entity( _(u'event'), icemac.ab.calendar.interfaces.IEvent, Event) @grok.adapter(icemac.ab.calendar.interfaces.IEvent) @grok.implementer(icemac.addressbook.interfaces.ITitle) def event_title(event): """Human readable title for an event.""" if event.alternative_title: return event.alternative_title if event.category: return icemac.addressbook.interfaces.ITitle(event.category) return _('event') @grok.adapter(icemac.ab.calendar.interfaces.IEvent) @grok.implementer(icemac.ab.calendar.interfaces.ICalendar)
class SearchTermConcatenationSource( icemac.addressbook.sources.TitleMappingSource): _mapping = collections.OrderedDict( (('and', _(u'search-and', default=u'and')), ('or', _(u'search-or', default=u'or'))))
def _makeMissingTerm(self, value): term = self.terms.getTerm(value) term.title = _(u'Missing: ${value}', mapping=dict(value=term.title)) return term
def __init__(self, address_book): basic_unit, self.count = zope.size.interfaces.ISized( address_book).sizeForSorting() self.notes = zope.i18n.translate( _(u'The users inside this address book will not get deleted.'), context=zope.globalrequest.getRequest())
@time_zone.setter def time_zone(self, value): self._timezone_preference_group.time_zone = value # private @property def _timezone_preference_group(self): default_prefs = zope.component.getUtility( zope.preference.interfaces.IDefaultPreferenceProvider) return default_prefs.getDefaultPreferenceGroup('ab.timeZone') address_book_entity = icemac.addressbook.entities.create_entity( _(u'address book'), icemac.addressbook.interfaces.IAddressBook, AddressBook) @grok.adapter(None) @grok.implementer(icemac.addressbook.interfaces.IAddressBook) def get_address_book(context): """Get the current address book from every context.""" return zope.component.hooks.getSite() def create_and_register(addressbook, attrib_name, class_, interface, name=''): """Create an object on an attribute and register it as local utility.""" obj = getattr(addressbook, attrib_name, None) if obj is not None: return obj
def home_page_address_title(hp): """Title of a home page address.""" title = _('none') if hp.url: title = six.text_type(hp.url) return title
def email_address_title(email): """Title of an e-mail address.""" title = _('none') if email.email: title = email.email return title
def datetime_wrong_type(field, exc): value = exc.args[0] return _( u'${value} is no valid datetime. ' u'Must match to format string "${format}".', mapping=dict(value=value, format=DATETIME_FORMAT))
def int_wrong_type(field, exc): value = exc.args[0] return _(u'${value} is not a valid integer number.', mapping=dict(value=value))
def country_constraint_not_satisfield(field, exc): value = exc.args[0] titles = [x.token for x in field.source.factory.getValues()] return _(u'Value ${value} is not allowed. Allowed values are: ${values}', mapping=dict(value=value, values=', '.join(titles)))
def date_wrong_type(field, exc): value = exc.args[0] return _(u'${value} is no valid date.', mapping=dict(value=value))
def choice_constraint_not_satisfield(field, exc): value = exc.args[0] allowed = [str(x) for x in field.source.factory.getValues()] return _(u'Value ${value} is not allowed. Allowed values are: ${values}', mapping=dict(value=value, values=', '.join(allowed)))
@zope.interface.implementer(icemac.addressbook.interfaces.IKeyword) class Keyword(persistent.Persistent, zope.container.contained.Contained): """A keyword.""" zope.schema.fieldproperty.createFieldProperties( icemac.addressbook.interfaces.IKeyword) def __init__(self, title=None): super(Keyword, self).__init__() if title is not None: self.title = title keyword_entity = icemac.addressbook.entities.create_entity( _(u'keyword'), icemac.addressbook.interfaces.IKeyword, Keyword) @zope.component.adapter(icemac.addressbook.interfaces.IKeyword, zope.lifecycleevent.IObjectModifiedEvent) def changed(obj, event): for desc in event.descriptions: if (desc.interface == icemac.addressbook.interfaces.IKeyword and 'title' in desc.attributes): catalog = zope.component.getUtility( zope.catalog.interfaces.ICatalog) catalog.updateIndex(catalog.get('keywords')) break uniqueTitles = icemac.addressbook.utils.unique_by_attr_factory(
icemac.ab.calendar.eventview.interfaces.IEventViewContainer) class EventViewContainer(zope.container.btree.BTreeContainer): """A container for event view configurations.""" @zope.interface.implementer( icemac.ab.calendar.eventview.interfaces.IEventViewConfiguration) class EventViewConfiguration(persistent.Persistent, zope.container.contained.Contained): """A configuration of an view of events.""" zope.schema.fieldproperty.createFieldProperties( icemac.ab.calendar.eventview.interfaces.IEventViewConfiguration, omit=['categories', 'fields']) categories = gocept.reference.ReferenceCollection('categories', ensure_integrity=True) fields = icemac.ab.calendar.property.AddressBookField('_fields', multiple=True) def __init__(self, *args, **kw): super(EventViewConfiguration, self).__init__(*args, **kw) self.categories = set([]) def __repr__(self): """Human readable representation of the object.""" return u'<EventViewConfiguration title={0!r}>'.format(self.title) unique_titles = icemac.addressbook.utils.unique_by_attr_factory( 'title', _('This title is already used for an event view configuration.'))
def getTitle(self, value): entity, field = untokenize(value) field_title = icemac.addressbook.entities.get_field_label(field) # The titles might be message ids so allow to translate them. return _(u"${prefix} -- ${title}", mapping=dict(prefix=entity.title, title=field_title))
def decimal_wrong_type(field, exc): value = exc.args[0] return _(u'${value} is not a valid decimal number.', mapping=dict(value=value))
@zope.interface.implementer( icemac.addressbook.interfaces.IPostalAddress, icemac.addressbook.interfaces.IMayHaveCustomizedPredfinedFields, ) class PostalAddress(persistent.Persistent, zope.container.contained.Contained): """A postal address.""" zope.schema.fieldproperty.createFieldProperties( icemac.addressbook.interfaces.IPostalAddress) # postal address entity, default_attrib is the name of the attribute # on IPerson which contains the default postal address. postal_address_entity = icemac.addressbook.entities.create_entity( _(u'postal address'), icemac.addressbook.interfaces.IPostalAddress, PostalAddress, default_attrib='default_postal_address') @zope.component.adapter(icemac.addressbook.interfaces.IPostalAddress) @zope.interface.implementer(icemac.addressbook.interfaces.ITitle) def postal_address_title(address): """Title of a postal address.""" title = _('none') values = [ icemac.addressbook.interfaces.ITitle(getattr(address, x)) for x in ('address_prefix', 'street', 'zip', 'city', 'country') if getattr(address, x) ]
def bool_wrong_type(field, exc): value = exc.args[0] return _(u'Value ${value} is not allowed. Allowed values are: ${values}', mapping=dict(value=value, values=', '.join(TRUE_VALUES + FALSE_VALUES)))
def phone_number_title(tel): """Title of a phone number.""" title = _('none') if tel.number: title = tel.number return title
def index_error(field, exc): return _(u'Not enough data fields in row.')
def _handle_action(self): icemac.addressbook.browser.base.delete_persons(self.context, self.context.keys()) self.status = _('Address book contents deleted.') self.redirect_to_next_url('object', 'person-list.html')
class MapFields(z3c.form.group.GroupForm, icemac.ab.importer.browser.wizard.base.FileSessionStorageStep): "Map the fields in the import file to fields in the addressbook." title = label = _(u'Map fields') def __init__(self, *args, **kw): super(MapFields, self).__init__(*args, **kw) session = self.getContent() request = self.request self.groups = [] entities = zope.component.getUtility( icemac.addressbook.interfaces.IEntities) for entity in entities.getMainEntities(): if entity.class_name == 'icemac.addressbook.person.Person': entries_number = 1 main_prefix = '' else: entries_number = session.get('entries_number', 0) main_prefix = _(u'main') for index in range(entries_number): if index == 0: row_title_prefix = main_prefix else: row_title_prefix = _(u'other') title = _('${prefix} ${title}', mapping=dict(prefix=row_title_prefix, title=entity.title)) prefix = '%s-%s' % (entity.name, index) self.groups.append( FieldsGroup(session, request, self, entity, title, prefix)) @property def fields(self): return z3c.form.field.Fields() def update(self): super(MapFields, self).update() icemac.ab.importer.browser.wizard.base.FileSessionStorageStep.update( self) if not self.nextURL: # no redirect to next step, make sure no imported data exists icemac.ab.importer.browser.wizard.base.delete_imported_data(self) def applyChanges(self, data): super(MapFields, self).applyChanges(data) import_object_builder = ImportObjectBuilder( data, icemac.addressbook.interfaces.IAddressBook(self.context), self.getContent()['entries_number']) keyword_builder = KeywordBuilder(data) session = self.getContent() reader = get_reader(session) imported = session['imported'] = [] imported_keywords = session['imported_keywords'] = [] import_errors = session['import_errors'] = {} session['found_errors'] = False for data_row in reader: imported_keywords.extend(x.__name__ for x in keyword_builder.create(data_row)) obj, errors = import_object_builder.create(data_row) imported.append(obj.__name__) import_errors[obj.__name__] = errors if errors: session['found_errors'] = True
def setUpColumns(self): return [z3c.table.column.addColumn( self, icemac.addressbook.browser.table.TitleLinkColumn, 'title', header=_(u'event category'))]
class IDocument(IDocumentBase): """Document storing binary data.""" title = zope.schema.TextLine( title=_(u'document title'), description=_(u'Name which is shown in the list view.'))
omit=['read_only', 'read_write']) read_only = gocept.reference.ReferenceCollection( 'read_only', ensure_integrity=True) read_write = gocept.reference.ReferenceCollection( 'read_write', ensure_integrity=True) def __init__(self, *args, **kw): super(Folder, self).__init__(*args, **kw) self.read_only = set() self.read_write = set() folder_entity = icemac.addressbook.entities.create_entity( _(u'folder'), icemac.ab.document.interfaces.IFolder, Folder) @zope.interface.implementer( icemac.ab.document.interfaces.IDocument, icemac.addressbook.interfaces.IMayHaveCustomizedPredfinedFields) class Document(icemac.addressbook.file.file.BaseFile): """Container containing documents and/or other folders.""" zope.schema.fieldproperty.createFieldProperties( icemac.ab.document.interfaces.IDocument, omit=['data', 'size']) document_entity = icemac.addressbook.entities.create_entity( _(u'document'), icemac.ab.document.interfaces.IDocument, Document)
class MoveUp(MoveBase): """Move entity up in entity order.""" direction = 'up' message = _('Moved ${entity} up.')
class SourceFactoryMissingCollectionTermsSource( z3c.form.term.MissingCollectionTermsSource): """MissingCollectionTermsSource adapted to zc.sourcefactory. We need a zc.sourcefactory as base creating the `ITerms` adapter to be able to `_makeMissingTerm()` properly. """ def _makeMissingTerm(self, value): term = self.terms.getTerm(value) term.title = _(u'Missing: ${value}', mapping=dict(value=term.title)) return term NoLongerAllowedPerson = z3c.form.error.ErrorViewMessage( _('Please deselect the persons prefixed with "Missing:" They are no ' 'longer in the list of available persons. (Maybe reconsider the ' 'following setting: Master Data > Calendar > Settings > ' 'Person keyword)'), error=zope.schema.interfaces.WrongContainedType, field=icemac.ab.calendar.interfaces.IBaseEvent['persons']) class EventFields(object): """Form fields to add or edit an event.""" interface = None @property def fields(self): fields = icemac.addressbook.interfaces.IEntity(self.interface) field_values = [] for name, field in fields.getFields():
class MoveDown(MoveBase): """Move entity down in entity order.""" direction = 'down' message = _('Moved ${entity} down.')
class Field(SessionStorageStep): """Step where the user choosed the field he likes to update.""" interface = IFieldChooser title = label = _(u'Choose field')
def choice_type_needs_values(field): if field.type == u'Choice' and not field.values: raise zope.interface.Invalid( _(u'type "choice" requires at least one field value.'))