class User(Base): __tablename__ = 'user_' id = Column(Integer, primary_key=True, info={'colanderalchemy': { 'title': 'id пользователя' }}) vk_id = Column( BigInteger, unique=True, nullable=True, info={ 'colanderalchemy': { 'title': 'id вконтакте', # 'widget': deform.widget.TextInputWidget(), # 'missing': colander.drop, # 'missing': colander.null, # 'default': colander.null, 'default': None, 'typ': NullableInt } }) login = Column( Text, unique=True, info={ 'colanderalchemy': { 'title': 'Логин пользователя', 'validator': colander.Regex( '^[a-z0-9_]+$', 'Логин должен содержать только цифры и английские буквы'), 'missing': colander.required } }) name = Column(Text, info={ 'colanderalchemy': { 'title': 'Имя пользователя', 'missing': None, } }) email = Column( Text, info={ 'colanderalchemy': { 'title': 'E-mail', 'validator': colander.Email(), 'missing': colander.required # 'widget': deform.widget.CheckedInputWidget( # subject='E-mail', # confirm_subject='Подтвердите E-mail' # ) } }) group_ = Column(Text, info={'colanderalchemy': { 'title': 'Группа пользователя' }}) email_check_code = Column(Text) email_checked = Column( Boolean, default=False, server_default='false', nullable=False, info={'colanderalchemy': { 'title': 'Почта проверена' }}) active = Column(Boolean, default=False, server_default='false', nullable=False, info={'colanderalchemy': { 'title': 'Аккаунт включен' }}) # stores password hash and salt separated by colon password_hash = Column(Text, info={ 'colanderalchemy': { 'title': 'Пароль', 'widget': deform.widget.CheckedPasswordWidget(), } }) def set_password(self, password): """thx 2 http://pythoncentral.io/hashing-strings-with-python""" salt = create_salt() self.password_hash = create_hashed_password(password, salt) + ':' + salt def check_password(self, user_password): if self.password_hash is None: return False hashed_password_only, salt = self.password_hash.split(':') return hashed_password_only == create_hashed_password( user_password, salt) @staticmethod def get_groups(user_id, request): user = User.by_id(user_id) """:type user:User""" if not user: return [] if user.group_ not in GROUPS: return [] return GROUPS[user.group_] @staticmethod def by_id(user_id: int): """ :return User """ return DBSession.query(User).filter(User.id == user_id).first() @staticmethod # def by_login(user_login: str, filters=None): def by_login(user_login: str, not_id: int = None): """ :return User """ q = DBSession.query(User) \ .filter(User.login == user_login) q = User.filter_not_id(q, not_id) return q.first() @staticmethod def by_vk_id(vk_id: int): """ :return User """ return DBSession.query(User).filter(User.vk_id == vk_id).first() @staticmethod def by_email(email: str, not_id: int = None): """ :return User """ q = DBSession.query(User).filter(User.email == email) q = User.filter_not_id(q, not_id) return q.first() @staticmethod def filter_not_id(query: Query, not_id): if not_id is not None: return query.filter(User.id != not_id) return query @staticmethod def by_any(any): """ :return User """ if isinstance(any, int): user = User.by_vk_id(any) if user: return user else: user = User.by_login(any) if user: return user user = User.by_email(any) if user: return user return None @staticmethod def generate_password(): length = int(helpers.get_setting('generate_password_length', 8)) return helpers.generate_password(length) @staticmethod def generate_email_check_code(): length = int( helpers.get_setting('generate_email_check_code_length', 10)) return helpers.generate_password(length, True) def initiate_email_check(self): self.email_check_code = self.generate_email_check_code() helpers.send_html_mail(self.email, 'email_check_code', {'email_check_code': self.email_check_code}) self.email_checked = False self.active = False def is_admin(self): return self.group_ == ADMIN_GROUP def before_save(self): if not self.name: self.name = self.login @staticmethod def register(self, email, password=None, name=None): raise NotImplementedError()
class PersonSchema(VisualisableElementSchema, UserSchema, SearchableEntitySchema): """Schema for Person""" name = NameSchemaNode(editing=context_is_a_person, ) function = colander.SchemaNode(colander.String(), widget=deform.widget.TextInputWidget(), title=_('Function'), missing='') description = colander.SchemaNode(colander.String(), widget=LimitedTextAreaWidget( rows=5, cols=30, limit=1200, alert_values={'limit': 1200}), title=_("Description"), missing="") tree = colander.SchemaNode( typ=DictSchemaType(), widget=keyword_widget, default=DEFAULT_TREE, missing=DEFAULT_TREE, title=_('Topics of interest'), description= _('Indicate keywords. You can specify a second keyword level for each keyword chosen.' )) email = colander.SchemaNode(colander.String(), validator=colander.All( colander.Email(), email_validator, colander.Length(max=100)), title=_('Login (email)')) picture = colander.SchemaNode( ObjectData(Image), widget=picture_widget, title=_('Picture'), description= _('You see a square on the top left of the image if it exceeds the maximum' ' size allowed. Move and enlarge it if necessary, to determine an area of' ' interest. Several images will be generated from this area.'), required=False, missing=None, ) cover_picture = colander.SchemaNode( ObjectData(File), widget=get_file_widget(file_extensions=['png', 'jpg', 'svg']), title=_('Cover picture'), missing=None, description=_("Only PNG and SVG files are supported."), ) first_name = colander.SchemaNode( colander.String(), title=_('Given name(s)'), description= _("Given name(s), as it(they) appear(s) on your official identity documents" )) last_name = colander.SchemaNode( colander.String(), title=_('Family name(s)'), description= _("Family name(s), as it(they) appear(s) on your official identity documents" )) birth_date = colander.SchemaNode(colander.Date(), title=_('Date of birth')) citizenship = colander.SchemaNode( colander.String(), widget=citizenship_choice, title=_('Citizenship'), description= _('What is the Member State of the European Union of which you are a citizen? Only citizens of the European Union can be members of the CosmoPolitical Cooperative.' ), ) birthplace = colander.SchemaNode( colander.String(), title=_('Place of birth'), description=_( "Place of birth (city or municipality + country if relevant), " "as it appears on your official identity documents")) user_title = colander.SchemaNode( colander.String(), widget=titles_choice, title=_('Title', context='user'), description= _('Please do not select anything if you do not want to communicate this information.' ), missing='') locale = colander.SchemaNode( colander.String(), title=_('Locale'), widget=locale_widget, missing=locale_missing, validator=colander.OneOf(AVAILABLE_LANGUAGES), ) password = colander.SchemaNode( colander.String(), widget=deform.widget.CheckedPasswordWidget(), validator=colander.Length(min=3, max=100), title=_("Password")) organization = colander.SchemaNode( ObjectType(), widget=organization_choice, missing=None, title=_('Organization'), ) pseudonym = colander.SchemaNode( colander.String(), widget=deform.widget.TextInputWidget(item_css_class='pseudonym-input'), validator=colander.All(pseudonym_validator, ), title=_('Pseudonym'), description= _("Please choose the pseudonym that will identify you for the whole duration of your " "activity on the platform. We STRONGLY recommend that you select a pseudonym that makes " "tracking back to your real identity impossible (or extremely difficult). Thereby, you " "protect the confidentiality of your political opinions (i.e. personal data that are the " "purpose of a specific protection under the General Data Protection Regulation - GDPR) " "against any form of external pressure in real life (e.g. by your employer or your customers). " "Be very careful! Once you have chosen it, you will NEVER be able to change this pseudonym afterwards. " "Choose it with care!"), ) accept_conditions = colander.SchemaNode( colander.Boolean(), widget=conditions_widget, label=_('I have read and accept the terms and conditions of use'), title='', missing=False) @invariant def user_invariant(self, appstruct): context = self.bindings['context'] first_name = appstruct.get('first_name', None) last_name = appstruct.get('last_name', None) birth_date = appstruct.get('birth_date', None) birthplace = appstruct.get('birthplace', None) if first_name and last_name and birth_date and birthplace: try: birth_date = colander.iso8601.parse_date(birth_date) birth_date = birth_date.date() except colander.iso8601.ParseError as e: return key = first_name + last_name + birthplace + birth_date.strftime( "%d/%m/%Y") key = normalize_title(key).replace(' ', '') novaideo_catalog = find_catalog('novaideo') identifier_index = novaideo_catalog['identifier'] query = identifier_index.any([key]) users = list(query.execute().all()) if context in users: users.remove(context) if users: raise colander.Invalid(self, _('User already exists'))
class RegistrationSchema(c.Schema): email = c.SchemaNode(c.String(), validator=c.Email())
class RestaurantSchema(colander.MappingSchema): name = colander.SchemaNode(colander.String()) address = colander.SchemaNode(colander.String()) email = colander.SchemaNode(colander.String(), validator=colander.Email(), missing='') description = colander.SchemaNode(colander.String(), missing='', validator=colander.Length(max=TWEET_CHAR_LENGTH)) geolocation = Geolocation()
class NewsletterSubscriptionSchema(CSRFSchema): """Newsletter subscription schema.""" email = colander.Schema(colander.String(), validator=colander.Email()) came_from = colander.Schema(colander.String(), validator=colander.url)
class User(Base): __tablename__ = 'user' __table_args__ = {'schema': _schema} __colanderalchemy_config__ = {'title': _('User'), 'plural': _('Users')} __c2cgeoform_config__ = {'duplicate': True} item_type = Column('type', String(10), nullable=False, info={'colanderalchemy': { 'widget': HiddenWidget() }}) __mapper_args__ = { 'polymorphic_on': item_type, 'polymorphic_identity': 'user', } id = Column(Integer, primary_key=True, info={'colanderalchemy': { 'widget': HiddenWidget() }}) username = Column(Unicode, unique=True, nullable=False, info={'colanderalchemy': { 'title': _('Username') }}) _password = Column('password', Unicode, nullable=False, info={'colanderalchemy': { 'exclude': True }}) temp_password = Column('temp_password', Unicode, nullable=True, info={'colanderalchemy': { 'exclude': True }}) email = Column(Unicode, nullable=False, info={ 'colanderalchemy': { 'title': _('Email'), 'validator': colander.Email() } }) is_password_changed = Column(Boolean, default=False, info={'colanderalchemy': { 'exclude': True }}) role_name = Column(String, info={ 'colanderalchemy': { 'title': _('Role'), 'widget': deform_ext.RelationSelect2Widget( Role, 'name', 'name', order_by='name', default_value=('', _('- Select -'))) } }) _cached_role_name = None # type: str _cached_role = None # type: Optional[Role] last_login = Column(DateTime(timezone=True), info={ 'colanderalchemy': { 'title': _('Last login'), 'missing': colander.drop, 'widget': DateTimeInputWidget(readonly=True) } }) expire_on = Column( DateTime(timezone=True), info={'colanderalchemy': { 'title': _('Expiration date') }}) deactivated = Column(Boolean, default=False, info={'colanderalchemy': { 'title': _('Deactivated') }}) @property def role(self) -> Optional[Role]: if self._cached_role_name == self.role_name: return self._cached_role if self.role_name is None or self.role_name == '': # pragma: no cover self._cached_role_name = self.role_name self._cached_role = None return None result = self._sa_instance_state.session.query(Role).filter( Role.name == self.role_name).all() if len(result) == 0: # pragma: no cover self._cached_role = None else: self._cached_role = result[0] self._cached_role_name = self.role_name return self._cached_role def __init__(self, username: str = '', password: str = '', email: str = '', is_password_changed: bool = False, role: Role = None, expire_on: datetime = None, deactivated: bool = False) -> None: self.username = username self.password = password self.email = email self.is_password_changed = is_password_changed if role is not None: self.role_name = role.name self.expire_on = expire_on self.deactivated = deactivated @property def password(self) -> str: """returns password""" return self._password # pragma: no cover @password.setter def password(self, password: str) -> None: """encrypts password on the fly.""" self._password = self.__encrypt_password(password) def set_temp_password(self, password: str) -> None: """encrypts password on the fly.""" self.temp_password = self.__encrypt_password(password) @staticmethod def __encrypt_password(password: str) -> str: """Hash the given password with SHA1.""" return sha1(password.encode('utf8')).hexdigest() def validate_password(self, passwd: str) -> bool: """Check the password against existing credentials. this method _MUST_ return a boolean. @param passwd: the password that was provided by the user to try and authenticate. This is the clear text version that we will need to match against the (possibly) encrypted one in the database. @type password: string """ if self._password == self.__encrypt_password(passwd): return True if \ self.temp_password is not None and \ self.temp_password != '' and \ self.temp_password == self.__encrypt_password(passwd): self._password = self.temp_password self.temp_password = None self.is_password_changed = False return True return False def expired(self) -> bool: return self.expire_on is not None and self.expire_on < datetime.now( pytz.utc) def update_last_login(self) -> None: self.last_login = datetime.now(pytz.utc) def __unicode__(self) -> str: return self.username or '' # pragma: no cover
def mail_validator(): """ Return an email entry validator with a custom error message """ return colander.Email(MAIL_ERROR_MESSAGE)
class EventSchema(MappingSchema): id = SchemaNode(String(), missing=drop, validator=Length(1, SAFE_MAX_LENGTH)) provider_id = default_schema_node() title = SchemaNode(String(), missing='', validator=Length(1, SAFE_MAX_LENGTH)) email = SchemaNode(String(), validator=colander.Email()) firstname = default_schema_node() lastname = default_schema_node() telephone = default_schema_node() description = SchemaNode(String(), missing='') event_id = default_schema_node() email = SchemaNode(String(), missing='', validator=colander.Email()) firstname = default_schema_node() language = default_schema_node() lastname = default_schema_node() latlong = default_schema_node() price_information = default_schema_node() organiser = default_schema_node() performers = default_schema_node() press_url = SchemaNode(String(), missing='', validator=colander.url) source_id = default_schema_node() source = default_schema_node() target = default_schema_node() telephone = default_schema_node() url = SchemaNode(String(), missing='', validator=colander.url) location_name = default_schema_node() location_address = default_schema_node() location_post_code = default_schema_node() location_town = default_schema_node() location_capacity = default_schema_node() location_country = default_schema_node() start_time = SchemaNode(DateTime(default_tzinfo=None), preparer=remove_timezone) end_time = SchemaNode(DateTime(default_tzinfo=None), missing=None, preparer=remove_timezone) publication_start = SchemaNode(DateTime(default_tzinfo=None), missing=None, preparer=remove_timezone) publication_end = SchemaNode(DateTime(default_tzinfo=None), missing=None, preparer=remove_timezone) press_contact_email = SchemaNode(String(), missing='', validator=colander.Email()) press_contact_name = default_schema_node() press_contact_phone_number = default_schema_node() ticket_contact_email = SchemaNode(String(), missing='', validator=colander.Email()) ticket_contact_name = default_schema_node() ticket_contact_phone_number = default_schema_node() @instantiate(missing=[]) class videos(SequenceSchema): video = MediaSchema() @instantiate(missing=[]) class sounds(SequenceSchema): sound = MediaSchema() @instantiate(missing=[]) class images(SequenceSchema): image = MediaSchema() @instantiate(missing=[]) class tags(SequenceSchema): name = SchemaNode(String(), validator=Length(1, TAG_MAX_LENGTH)) @instantiate(missing=[]) class categories(SequenceSchema): name = SchemaNode(String(), validator=Length(1, TAG_MAX_LENGTH))
class User(colander.MappingSchema): first_name = colander.SchemaNode(colander.String()) last_name = colander.SchemaNode(colander.String()) email = colander.SchemaNode(colander.Email(msg=None)) tickets = colander.SchemaNode(colander.Int())
class UserForm(colander.MappingSchema): email = colander.SchemaNode(colander.String(), validator=colander.Email()) login = colander.SchemaNode(colander.String())
password = property(_get_password, _set_password) Index('ix_users_user_lower_forum_username', func.lower(User.forum_username), unique=True) schema_user = SQLAlchemySchemaNode( User, # whitelisted attributes includes=[ 'id', 'username', 'forum_username', 'name', 'email', 'email_validated', 'moderator' ], overrides={'id': { 'missing': None }}) schema_create_user = SQLAlchemySchemaNode( User, # whitelisted attributes includes=['username', 'forum_username', 'name', 'email', 'lang'], overrides={ 'email': { 'validator': colander.Email() }, 'lang': { 'validator': colander.OneOf(default_langs) } })
class MeetingSchema(colander.Schema): title = colander.SchemaNode( colander.String(), title=_("Title"), description=_( "meeting_title_description", default= "Set a title for the meeting that separates it from previous meetings" ), validator=no_html_validator, ) meeting_mail_name = colander.SchemaNode( colander.String(), title=_("Name of the contact person for this meeting"), default=_deferred_current_fullname, validator=colander.Regex( regex=NAME_PATTERN, msg=_( "name_pattern_error", default= "Must be at least 3 chars + only alphanumeric characters allowed" )), ) meeting_mail_address = colander.SchemaNode( colander.String(), title=_("Contact email for this site"), default=deferred_current_user_mail, validator=colander.All( colander.Email(msg=_("Invalid email address.")), no_html_validator, ), ) description = colander.SchemaNode( colander.String(), title=_("Short description"), description=_( "short_description_text", default= "Shows up in search results and similar. One sentence is enough. " "You don't need to add it if you don't want to."), missing="", validator=no_html_validator) body = colander.SchemaNode( colander.String(), title=_("Participants description"), description= _("meeting_description_description", default= "This is only visible to participants, so don't put information on how to register here. " "Displayed on the first page of the meeting. You can include things " "like information about the meeting, how to contact the moderator and your logo." ), missing="", widget=deform.widget.RichTextWidget(options=(('theme', 'advanced'), )), validator=richtext_validator, ) public_description = colander.SchemaNode( colander.String(), title=_("Public presentation"), description=_( "meeting_public_description_description", default="The public description is visible on the request access " "page and to not yet logged in visitors."), missing="", widget=deform.widget.RichTextWidget(options=(('theme', 'advanced'), )), validator=richtext_validator, ) hide_meeting = colander.SchemaNode( colander.Bool(), title=_("Hide meeting from listings"), description=_( "hide_meeting_description", default= "Users won't be able to find it unless they have a link to it."), tab='advanced', default=False, missing=False) nav_title = colander.SchemaNode( colander.String(), title=_("Navigation bar title"), description=_("In case you want another title in the navigation bar"), missing="", tab='advanced')
class ContactSchema(Schema): title = colander.SchemaNode(colander.String(), title=_('Title', context='contact'), default=default_title) address = colander.SchemaNode(colander.String(), widget=deform.widget.TextAreaWidget(rows=4, cols=60), title=_('Address'), missing="") email = colander.SchemaNode( colander.String(), widget=EmailInputWidget(), missing="", validator=colander.All(colander.Email(), colander.Length(max=100)), ) phone = colander.SchemaNode( colander.String(), validator=colander.All(phone_fax_validator), missing="", widget=TextInputWidget(css_class="contact-phone"), title=_('Phone'), ) surtax = colander.SchemaNode( colander.String(), missing="0", widget=TextInputWidget(item_css_class="hide-bloc"), default="0", title=_('Surcharge'), description= _('Indicate the amount of the surcharge (for the premium-rate number).' ), ) fax = colander.SchemaNode( colander.String(), missing="", title=_('Fax'), ) website = colander.SchemaNode( colander.String(), missing="", title=_('Website'), ) @invariant def contact_invariant(self, appstruct): appstruct_copy = appstruct.copy() appstruct_copy.pop('surtax') if 'title' in appstruct_copy: appstruct_copy.pop('title') if not any(v != "" and v != colander.null for v in list(appstruct_copy.values())): raise colander.Invalid(self, _('One value must be entered.')) if 'phone' in appstruct and appstruct['phone'] and \ ('surtax' not in appstruct or 'surtax' in appstruct and not appstruct['surtax']): raise colander.Invalid(self, _('Surcharge field must be filled in.'))
class ForgotPasswordSchema(CSRFSchema): email = colander.SchemaNode(colander.String(), validator=colander.Email())
class RegisterSchema(colander.MappingSchema): email = colander.SchemaNode(colander.String(), validator=colander.Email())
def emails_validator(node, kw): new_emails = [e for e in kw if isinstance(e, str)] validator = colander.Email() for email in new_emails: validator(node, email)
class Django1_7ConfigurationSchema(colander.MappingSchema): """Configuration schema for Django 1.7.""" ABSOLUTE_URL_OVERRIDES = colander.SchemaNode( colander.Mapping(unknown='preserve'), missing=global_settings.ABSOLUTE_URL_OVERRIDES, default=global_settings.ABSOLUTE_URL_OVERRIDES, ) ADMIN_FOR = colander.SchemaNode( colander.Sequence(), missing=global_settings.ADMIN_FOR, default=global_settings.ADMIN_FOR, children=[ colander.SchemaNode(colander.String()), ] ) ADMINS = colander.SchemaNode( colander.Sequence(), missing=global_settings.ADMINS, default=global_settings.ADMINS, children=[ colander.SchemaNode( colander.Tuple(), children=[ colander.SchemaNode(colander.String()), colander.SchemaNode( colander.String(), validator=colander.Email(), ), ] ), ] ) ALLOWED_HOSTS = colander.SchemaNode( colander.Sequence(), missing=global_settings.ALLOWED_HOSTS, default=global_settings.ALLOWED_HOSTS, children=[ colander.SchemaNode(colander.String()), ] ) ALLOWED_INCLUDE_ROOTS = colander.SchemaNode( colander.Sequence(), missing=global_settings.ALLOWED_INCLUDE_ROOTS, default=global_settings.ALLOWED_INCLUDE_ROOTS, children=[ colander.SchemaNode(colander.String()), ] ) APPEND_SLASH = colander.SchemaNode( colander.Boolean(), missing=global_settings.APPEND_SLASH, default=global_settings.APPEND_SLASH, ) AUTHENTICATION_BACKENDS = colander.SchemaNode( colander.Sequence(), missing=global_settings.AUTHENTICATION_BACKENDS, default=global_settings.AUTHENTICATION_BACKENDS, children=[ colander.SchemaNode(colander.String()), ] ) AUTH_USER_MODEL = colander.SchemaNode( colander.String(), missing=global_settings.AUTH_USER_MODEL, default=global_settings.AUTH_USER_MODEL, ) CACHES = colander.SchemaNode( colander.Mapping(unknown='preserve'), missing=global_settings.CACHES, default=global_settings.CACHES, children=[ colander.SchemaNode( colander.Mapping(unknown='raise'), name='default', missing=colander.drop, children=[ colander.SchemaNode( colander.String(), name='BACKEND', missing=colander.required, default=colander.null, ), colander.SchemaNode( colander.String(), name='KEY_FUNCTION', missing=colander.drop, default='', ), colander.SchemaNode( colander.String(), name='KEY_PREFIX', missing=colander.drop, default='', ), colander.SchemaNode( colander.String(), name='LOCATION', missing=colander.drop, default='', ), colander.SchemaNode( colander.Mapping(unknown='preserve'), name='OPTIONS', missing=colander.drop, default={}, ), colander.SchemaNode( colander.Integer(), name='TIMEOUT', missing=colander.drop, default=300, ), colander.SchemaNode( colander.String(), name='VERSION', missing=colander.drop, default=1, ), ] ), ] ) CACHE_MIDDLEWARE_ALIAS = colander.SchemaNode( colander.String(), missing=global_settings.CACHE_MIDDLEWARE_ALIAS, default=global_settings.CACHE_MIDDLEWARE_ALIAS, ) CACHE_MIDDLEWARE_ANONYMOUS_ONLY = colander.SchemaNode( colander.Boolean(), missing=colander.drop, # Not in django.conf.global_settings. default=False, ) CACHE_MIDDLEWARE_KEY_PREFIX = colander.SchemaNode( colander.String(), missing=global_settings.CACHE_MIDDLEWARE_KEY_PREFIX, default=global_settings.CACHE_MIDDLEWARE_KEY_PREFIX, ) CACHE_MIDDLEWARE_SECONDS = colander.SchemaNode( colander.Integer(), missing=global_settings.CACHE_MIDDLEWARE_SECONDS, default=global_settings.CACHE_MIDDLEWARE_SECONDS, ) COMMENTS_ALLOW_PROFANITIES = colander.SchemaNode( colander.Boolean(), missing=False, default=False, ) CSRF_COOKIE_AGE = colander.SchemaNode( colander.Integer(), missing=global_settings.CSRF_COOKIE_AGE, default=global_settings.CSRF_COOKIE_AGE, ) CSRF_COOKIE_DOMAIN = colander.SchemaNode( colander.String(), missing=global_settings.CSRF_COOKIE_DOMAIN, default=global_settings.CSRF_COOKIE_DOMAIN, ) CSRF_COOKIE_HTTPONLY = colander.SchemaNode( colander.Boolean(), missing=global_settings.CSRF_COOKIE_HTTPONLY, default=global_settings.CSRF_COOKIE_HTTPONLY, ) CSRF_COOKIE_NAME = colander.SchemaNode( colander.String(), missing=global_settings.CSRF_COOKIE_NAME, default=global_settings.CSRF_COOKIE_NAME, ) CSRF_COOKIE_PATH = colander.SchemaNode( colander.String(), missing=global_settings.CSRF_COOKIE_PATH, default=global_settings.CSRF_COOKIE_PATH, ) CSRF_COOKIE_SECURE = colander.SchemaNode( colander.Boolean(), missing=global_settings.CSRF_COOKIE_SECURE, default=global_settings.CSRF_COOKIE_SECURE, ) CSRF_FAILURE_VIEW = colander.SchemaNode( colander.String(), missing=global_settings.CSRF_FAILURE_VIEW, default=global_settings.CSRF_FAILURE_VIEW, ) DATABASES = colander.SchemaNode( colander.Mapping(unknown='preserve'), missing=colander.required, default=colander.null, children=[ colander.SchemaNode( colander.Mapping(unknown='raise'), name='default', missing=None, children=[ # See django.db.utils.ConnectionHandler.ensure_defaults colander.SchemaNode( colander.String(), name='ENGINE', missing=colander.drop, default='', ), colander.SchemaNode( colander.String(), name='HOST', missing=colander.drop, default='', ), colander.SchemaNode( colander.String(), name='NAME', missing=colander.drop, default='', ), colander.SchemaNode( colander.Mapping(unknown='preserve'), name='OPTIONS', missing=colander.drop, default={}, ), colander.SchemaNode( colander.String(), name='PASSWORD', missing=colander.drop, default='', ), colander.SchemaNode( colander.String(), name='PORT', missing=colander.drop, default='', ), colander.SchemaNode( colander.String(), name='USER', missing=colander.drop, default='', ), colander.SchemaNode( colander.Boolean(), name='ATOMIC_REQUESTS', missing=colander.drop, default=False, ), colander.SchemaNode( colander.Boolean(), name='AUTOCOMMIT', missing=colander.drop, default=True, ), colander.SchemaNode( colander.Integer(), name='CONN_MAX_AGE', missing=colander.drop, default=0, ), colander.SchemaNode( colander.Mapping(unknown='raise'), name='default', missing=None, children=[ colander.SchemaNode( colander.String(), name='CHARSET', missing=colander.drop, default=None, ), colander.SchemaNode( colander.String(), name='COLLATION', missing=colander.drop, default=None, ), colander.SchemaNode( colander.Sequence(), name='DEPENDENCIES', missing=colander.drop, default=['default'], children=[ colander.SchemaNode(colander.String()), ] ), colander.SchemaNode( colander.String(), name='MIRROR', missing=colander.drop, default=None, ), colander.SchemaNode( colander.String(), name='NAME', missing=colander.drop, default=None, ), colander.SchemaNode( colander.Boolean(), name='CREATE_DB', missing=colander.drop, default=True, ), colander.SchemaNode( colander.String(), name='USER', missing=colander.drop, default=None, ), colander.SchemaNode( colander.Boolean(), name='CREATE_USER', missing=colander.drop, default=True, ), colander.SchemaNode( colander.String(), name='PASSWORD', missing=colander.drop, default=None, ), colander.SchemaNode( colander.String(), name='TBLSPACE', missing=colander.drop, default=None, ), colander.SchemaNode( colander.String(), name='TBLSPACE_TMP', missing=colander.drop, default=None, ), ] ), ] ), ] ) DATABASE_ROUTERS = colander.SchemaNode( colander.Sequence(), missing=global_settings.DATABASE_ROUTERS, default=global_settings.DATABASE_ROUTERS, children=[ colander.SchemaNode( colander.String(), ), ] ) DATE_FORMAT = colander.SchemaNode( colander.String(), missing=global_settings.DATE_FORMAT, default=global_settings.DATE_FORMAT, ) DATE_INPUT_FORMATS = colander.SchemaNode( colander.Sequence(), missing=global_settings.DATE_INPUT_FORMATS, default=global_settings.DATE_INPUT_FORMATS, children=[ colander.SchemaNode( colander.String(), ), ] ) DATETIME_FORMAT = colander.SchemaNode( colander.String(), missing=global_settings.DATETIME_FORMAT, default=global_settings.DATETIME_FORMAT, ) DATETIME_INPUT_FORMATS = colander.SchemaNode( colander.Sequence(), missing=global_settings.DATETIME_INPUT_FORMATS, default=global_settings.DATETIME_INPUT_FORMATS, children=[ colander.SchemaNode( colander.String(), ), ] ) DEBUG = colander.SchemaNode( colander.Boolean(), missing=global_settings.DEBUG, default=global_settings.DEBUG, ) DEBUG_PROPAGATE_EXCEPTIONS = colander.SchemaNode( colander.Boolean(), missing=global_settings.DEBUG, default=global_settings.DEBUG, ) DECIMAL_SEPARATOR = colander.SchemaNode( colander.String(), missing=global_settings.DECIMAL_SEPARATOR, default=global_settings.DECIMAL_SEPARATOR, ) DEFAULT_CHARSET = colander.SchemaNode( colander.String(), missing=global_settings.DEFAULT_CHARSET, default=global_settings.DEFAULT_CHARSET, ) DEFAULT_CONTENT_TYPE = colander.SchemaNode( colander.String(), missing=global_settings.DEFAULT_CONTENT_TYPE, default=global_settings.DEFAULT_CONTENT_TYPE, ) DEFAULT_EXCEPTION_REPORTER_FILTER = colander.SchemaNode( colander.String(), missing=global_settings.DEFAULT_EXCEPTION_REPORTER_FILTER, default=global_settings.DEFAULT_EXCEPTION_REPORTER_FILTER, ) DEFAULT_FILE_STORAGE = colander.SchemaNode( colander.String(), missing=global_settings.DEFAULT_FILE_STORAGE, default=global_settings.DEFAULT_FILE_STORAGE, ) DEFAULT_FROM_EMAIL = colander.SchemaNode( colander.String(), missing=global_settings.DEFAULT_FROM_EMAIL, default=global_settings.DEFAULT_FROM_EMAIL, validator=colander.Email(), ) DEFAULT_INDEX_TABLESPACE = colander.SchemaNode( colander.String(), missing=global_settings.DEFAULT_INDEX_TABLESPACE, default=global_settings.DEFAULT_INDEX_TABLESPACE, ) DEFAULT_TABLESPACE = colander.SchemaNode( colander.String(), missing=global_settings.DEFAULT_TABLESPACE, default=global_settings.DEFAULT_TABLESPACE, ) DISALLOWED_USER_AGENTS = colander.SchemaNode( colander.Sequence(), missing=global_settings.DISALLOWED_USER_AGENTS, default=global_settings.DISALLOWED_USER_AGENTS, children=[ colander.SchemaNode( colander.String(), ), ] ) EMAIL_BACKEND = colander.SchemaNode( colander.String(), missing=global_settings.EMAIL_BACKEND, default=global_settings.EMAIL_BACKEND, ) EMAIL_FILE_PATH = colander.SchemaNode( colander.String(), missing=colander.drop, # Not in djanco.conf.globalsettings default=colander.null, ) EMAIL_HOST = colander.SchemaNode( colander.String(), missing=global_settings.EMAIL_HOST, default=global_settings.EMAIL_HOST, ) EMAIL_HOST_PASSWORD = colander.SchemaNode( colander.String(), missing=global_settings.EMAIL_HOST_PASSWORD, default=global_settings.EMAIL_HOST_PASSWORD, ) EMAIL_HOST_USER = colander.SchemaNode( colander.String(), missing=global_settings.EMAIL_HOST_USER, default=global_settings.EMAIL_HOST_USER, ) EMAIL_PORT = colander.SchemaNode( colander.Integer(), missing=global_settings.EMAIL_PORT, default=global_settings.EMAIL_PORT, ) EMAIL_SUBJECT_PREFIX = colander.SchemaNode( colander.String(), missing=global_settings.EMAIL_SUBJECT_PREFIX, default=global_settings.EMAIL_SUBJECT_PREFIX, ) EMAIL_USE_TLS = colander.SchemaNode( colander.Boolean(), missing=global_settings.EMAIL_USE_TLS, default=global_settings.EMAIL_USE_TLS, ) EMAIL_USE_SSL = colander.SchemaNode( colander.Boolean(), missing=global_settings.EMAIL_USE_SSL, default=global_settings.EMAIL_USE_SSL, ) FORMAT_MODULE_PATH = colander.SchemaNode( colander.String(), missing=global_settings.FORMAT_MODULE_PATH, default=global_settings.FORMAT_MODULE_PATH, ) FILE_CHARSET = colander.SchemaNode( colander.String(), missing=global_settings.FILE_CHARSET, default=global_settings.FILE_CHARSET, ) FILE_UPLOAD_DIRECTORY_PERMISSIONS = colander.SchemaNode( colander.String(), missing=global_settings.FILE_UPLOAD_DIRECTORY_PERMISSIONS, default=global_settings.FILE_UPLOAD_DIRECTORY_PERMISSIONS, ) FILE_UPLOAD_HANDLERS = colander.SchemaNode( colander.Sequence(), missing=global_settings.FILE_UPLOAD_HANDLERS, default=global_settings.FILE_UPLOAD_HANDLERS, children=[ colander.SchemaNode( colander.String(), ), ] ) FILE_UPLOAD_MAX_MEMORY_SIZE = colander.SchemaNode( colander.Integer(), missing=global_settings.FILE_UPLOAD_MAX_MEMORY_SIZE, default=global_settings.FILE_UPLOAD_MAX_MEMORY_SIZE, ) FILE_UPLOAD_PERMISSIONS = colander.SchemaNode( colander.Integer(), missing=global_settings.FILE_UPLOAD_PERMISSIONS, default=global_settings.FILE_UPLOAD_PERMISSIONS, ) FILE_UPLOAD_TEMP_DIR = colander.SchemaNode( colander.String(), missing=global_settings.FILE_UPLOAD_TEMP_DIR, default=global_settings.FILE_UPLOAD_TEMP_DIR, ) FIRST_DAY_OF_WEEK = colander.SchemaNode( colander.Integer(), missing=global_settings.FIRST_DAY_OF_WEEK, default=global_settings.FIRST_DAY_OF_WEEK, ) FIXTURE_DIRS = colander.SchemaNode( colander.Sequence(), missing=global_settings.FIXTURE_DIRS, default=global_settings.FIXTURE_DIRS, children=[ colander.SchemaNode( colander.String(), ), ] ) FORCE_SCRIPT_NAME = colander.SchemaNode( colander.String(), missing=global_settings.FORCE_SCRIPT_NAME, default=global_settings.FORCE_SCRIPT_NAME, ) IGNORABLE_404_URLS = colander.SchemaNode( colander.Sequence(), missing=global_settings.IGNORABLE_404_URLS, default=global_settings.IGNORABLE_404_URLS, children=[ colander.SchemaNode( colander.String(), ), ] ) INSTALLED_APPS = colander.SchemaNode( colander.Sequence(), missing=colander.required, default=colander.null, children=[ colander.SchemaNode(colander.String()), ] ) INTERNAL_IPS = colander.SchemaNode( colander.Sequence(), missing=global_settings.INTERNAL_IPS, default=global_settings.INTERNAL_IPS, children=[ colander.SchemaNode(colander.String()), ] ) LANGUAGE_CODE = colander.SchemaNode( colander.String(), missing=global_settings.LANGUAGE_CODE, default=global_settings.LANGUAGE_CODE, ) LANGUAGE_COOKIE_AGE = colander.SchemaNode( colander.Integer(), missing=global_settings.LANGUAGE_COOKIE_AGE, default=global_settings.LANGUAGE_COOKIE_AGE, ) LANGUAGE_COOKIE_DOMAIN = colander.SchemaNode( colander.String(), missing=global_settings.LANGUAGE_COOKIE_DOMAIN, default=global_settings.LANGUAGE_COOKIE_DOMAIN, ) LANGUAGE_COOKIE_NAME = colander.SchemaNode( colander.String(), missing=global_settings.LANGUAGE_COOKIE_NAME, default=global_settings.LANGUAGE_COOKIE_NAME, ) LANGUAGE_COOKIE_PATH = colander.SchemaNode( colander.String(), missing=global_settings.LANGUAGE_COOKIE_PATH, default=global_settings.LANGUAGE_COOKIE_PATH, ) LANGUAGES = colander.SchemaNode( colander.Sequence(), missing=global_settings.LANGUAGES, default=global_settings.LANGUAGES, children=[ colander.SchemaNode( colander.Tuple(), children=[ colander.SchemaNode(colander.String()), colander.SchemaNode(colander.String()), ] ), ] ) LANGUAGES_BIDI = colander.SchemaNode( colander.Sequence(), missing=global_settings.LANGUAGES_BIDI, default=global_settings.LANGUAGES_BIDI, children=[ colander.SchemaNode(colander.String()), ] ) LOCALE_PATHS = colander.SchemaNode( colander.Sequence(), missing=global_settings.LOCALE_PATHS, default=global_settings.LOCALE_PATHS, children=[ colander.SchemaNode(colander.String()), ] ) LOGGING = colander.SchemaNode( colander.Mapping(unknown='preserve'), missing=global_settings.LOGGING, default=global_settings.LOGGING, ) LOGGING_CONFIG = colander.SchemaNode( colander.String(), missing=global_settings.LOGGING_CONFIG, default=global_settings.LOGGING_CONFIG, ) LOGIN_REDIRECT_URL = colander.SchemaNode( colander.String(), missing=global_settings.LOGIN_REDIRECT_URL, default=global_settings.LOGIN_REDIRECT_URL, ) LOGIN_URL = colander.SchemaNode( colander.String(), missing=global_settings.LOGIN_URL, default=global_settings.LOGIN_URL, ) LOGOUT_URL = colander.SchemaNode( colander.String(), missing=global_settings.LOGOUT_URL, default=global_settings.LOGOUT_URL, ) MANAGERS = colander.SchemaNode( colander.Sequence(), missing=global_settings.MANAGERS, default=global_settings.MANAGERS, children=[ colander.SchemaNode( colander.Tuple(), children=[ colander.SchemaNode(colander.String()), colander.SchemaNode( colander.String(), validator=colander.Email(), ), ] ), ] ) MEDIA_ROOT = colander.SchemaNode( colander.String(), missing=global_settings.MEDIA_ROOT, default=global_settings.MEDIA_ROOT, ) MEDIA_URL = colander.SchemaNode( colander.String(), missing=global_settings.MEDIA_URL, default=global_settings.MEDIA_URL, ) MESSAGE_LEVEL = colander.SchemaNode( colander.Integer(), missing=colander.drop, # Not in django.conf.global_settings default=messages.INFO, ) MESSAGE_STORAGE = colander.SchemaNode( colander.String(), missing=global_settings.MESSAGE_STORAGE, default=global_settings.MESSAGE_STORAGE, ) MESSAGE_TAGS = colander.SchemaNode( colander.Mapping(unknown='preserve'), missing=colander.drop, # Not in django.conf.global_settings default=messages.DEFAULT_TAGS, children=[ colander.SchemaNode( colander.String(), ), ] ) MIDDLEWARE_CLASSES = colander.SchemaNode( colander.Sequence(), missing=global_settings.MIDDLEWARE_CLASSES, default=global_settings.MIDDLEWARE_CLASSES, children=[ colander.SchemaNode(colander.String()), ] ) MIGRATION_MODULES = colander.SchemaNode( colander.Mapping(unknown='preserve'), missing=global_settings.MIGRATION_MODULES, default=global_settings.MIGRATION_MODULES, ) MONTH_DAY_FORMAT = colander.SchemaNode( colander.String(), missing=global_settings.MONTH_DAY_FORMAT, default=global_settings.MONTH_DAY_FORMAT, ) NUMBER_GROUPING = colander.SchemaNode( colander.Integer(), missing=global_settings.NUMBER_GROUPING, default=global_settings.NUMBER_GROUPING, ) PASSWORD_HASHERS = colander.SchemaNode( colander.Sequence(), missing=global_settings.PASSWORD_HASHERS, default=global_settings.PASSWORD_HASHERS, children=[ colander.SchemaNode( colander.String(), ), ] ) PASSWORD_RESET_TIMEOUT_DAYS = colander.SchemaNode( colander.Integer(), missing=global_settings.PASSWORD_RESET_TIMEOUT_DAYS, default=global_settings.PASSWORD_RESET_TIMEOUT_DAYS, ) PREPEND_WWW = colander.SchemaNode( colander.Boolean(), missing=global_settings.PREPEND_WWW, default=global_settings.PREPEND_WWW, ) PROFANITIES_LIST = colander.SchemaNode( colander.Sequence(), missing=global_settings.PROFANITIES_LIST, default=global_settings.PROFANITIES_LIST, children=[ colander.SchemaNode( colander.String(), ), ] ) RESTRUCTUREDTEXT_FILTER_SETTINGS = colander.SchemaNode( colander.Mapping(unknown='preserve'), missing=colander.drop, # Not in django.conf.global_settings default={}, ) ROOT_URLCONF = colander.SchemaNode( colander.String(), missing=colander.drop, # Not in django.conf.global_settings default=colander.null, ) SECRET_KEY = colander.SchemaNode( colander.String(), missing=colander.required, default=colander.null, ) SECURE_PROXY_SSL_HEADER = colander.SchemaNode( TupleOrNone(), missing=global_settings.SECURE_PROXY_SSL_HEADER, default=global_settings.SECURE_PROXY_SSL_HEADER, children=[ colander.SchemaNode(colander.String()), colander.SchemaNode(colander.String()), ] ) SEND_BROKEN_LINK_EMAILS = colander.SchemaNode( colander.Boolean(), missing=global_settings.SEND_BROKEN_LINK_EMAILS, default=global_settings.SEND_BROKEN_LINK_EMAILS, ) SERIALIZATION_MODULES = colander.SchemaNode( colander.Mapping(unknown='preserve'), missing=colander.drop, default={}, children=[ colander.SchemaNode( colander.String(), ), ] ) SERVER_EMAIL = colander.SchemaNode( colander.String(), missing=global_settings.SERVER_EMAIL, default=global_settings.SERVER_EMAIL, ) SESSION_COOKIE_AGE = colander.SchemaNode( colander.Integer(), missing=global_settings.SESSION_COOKIE_AGE, default=global_settings.SESSION_COOKIE_AGE, ) SESSION_COOKIE_DOMAIN = colander.SchemaNode( colander.String(), missing=global_settings.SESSION_COOKIE_DOMAIN, default=global_settings.SESSION_COOKIE_DOMAIN, ) SESSION_COOKIE_HTTPONLY = colander.SchemaNode( colander.Boolean(), missing=global_settings.SESSION_COOKIE_HTTPONLY, default=global_settings.SESSION_COOKIE_HTTPONLY, ) SESSION_COOKIE_NAME = colander.SchemaNode( colander.String(), missing=global_settings.SESSION_COOKIE_NAME, default=global_settings.SESSION_COOKIE_NAME, ) SESSION_COOKIE_PATH = colander.SchemaNode( colander.String(), missing=global_settings.SESSION_COOKIE_PATH, default=global_settings.SESSION_COOKIE_PATH, ) SESSION_CACHE_ALIAS = colander.SchemaNode( colander.String(), missing=global_settings.SESSION_CACHE_ALIAS, default=global_settings.SESSION_CACHE_ALIAS, ) SESSION_COOKIE_SECURE = colander.SchemaNode( colander.Boolean(), missing=global_settings.SESSION_COOKIE_SECURE, default=global_settings.SESSION_COOKIE_SECURE, ) SESSION_ENGINE = colander.SchemaNode( colander.String(), missing=global_settings.SESSION_ENGINE, default=global_settings.SESSION_ENGINE, ) SESSION_EXPIRE_AT_BROWSER_CLOSE = colander.SchemaNode( colander.Boolean(), missing=global_settings.SESSION_EXPIRE_AT_BROWSER_CLOSE, default=global_settings.SESSION_EXPIRE_AT_BROWSER_CLOSE, ) SESSION_FILE_PATH = colander.SchemaNode( colander.String(), missing=global_settings.SESSION_FILE_PATH, default=global_settings.SESSION_FILE_PATH, ) SESSION_SAVE_EVERY_REQUEST = colander.SchemaNode( colander.Boolean(), missing=global_settings.SESSION_SAVE_EVERY_REQUEST, default=global_settings.SESSION_SAVE_EVERY_REQUEST, ) SESSION_SERIALIZER = colander.SchemaNode( colander.String(), missing=global_settings.SESSION_SERIALIZER, default=global_settings.SESSION_SERIALIZER, ) SHORT_DATE_FORMAT = colander.SchemaNode( colander.String(), missing=global_settings.SHORT_DATE_FORMAT, default=global_settings.SHORT_DATE_FORMAT, ) SHORT_DATETIME_FORMAT = colander.SchemaNode( colander.String(), missing=global_settings.SHORT_DATETIME_FORMAT, default=global_settings.SHORT_DATETIME_FORMAT, ) SIGNING_BACKEND = colander.SchemaNode( colander.String(), missing=global_settings.SIGNING_BACKEND, default=global_settings.SIGNING_BACKEND, ) SILENCED_SYSTEM_CHECKS = colander.SchemaNode( colander.Sequence(), missing=global_settings.SILENCED_SYSTEM_CHECKS, default=global_settings.SILENCED_SYSTEM_CHECKS, children=[ colander.SchemaNode(colander.String()), ] ) SITE_ID = colander.SchemaNode( colander.Integer(), missing=colander.drop, default=colander.null, ) STATIC_ROOT = colander.SchemaNode( colander.String(), missing=global_settings.STATIC_ROOT, default=global_settings.STATIC_ROOT, ) STATIC_URL = colander.SchemaNode( colander.String(), missing=global_settings.STATIC_URL, default=global_settings.STATIC_URL, ) STATICFILES_DIRS = colander.SchemaNode( colander.Sequence(), missing=global_settings.STATICFILES_DIRS, default=global_settings.STATICFILES_DIRS, children=[ colander.SchemaNode(colander.String()), ] ) STATICFILES_FINDERS = colander.SchemaNode( colander.Sequence(), missing=global_settings.STATICFILES_FINDERS, default=global_settings.STATICFILES_FINDERS, children=[ colander.SchemaNode(colander.String()), ] ) STATICFILES_STORAGE = colander.SchemaNode( colander.String(), missing=global_settings.STATICFILES_STORAGE, default=global_settings.STATICFILES_STORAGE, ) TEMPLATE_CONTEXT_PROCESSORS = colander.SchemaNode( colander.Sequence(), missing=global_settings.TEMPLATE_CONTEXT_PROCESSORS, default=global_settings.TEMPLATE_CONTEXT_PROCESSORS, children=[ colander.SchemaNode(colander.String()), ] ) TEMPLATE_DEBUG = colander.SchemaNode( colander.Boolean(), missing=global_settings.TEMPLATE_DEBUG, default=global_settings.TEMPLATE_DEBUG, ) TEMPLATE_DIRS = colander.SchemaNode( colander.Sequence(), missing=global_settings.TEMPLATE_DIRS, default=global_settings.TEMPLATE_DIRS, children=[ colander.SchemaNode(colander.String()), ] ) TEMPLATE_LOADERS = colander.SchemaNode( colander.List(), missing=global_settings.TEMPLATE_LOADERS, default=global_settings.TEMPLATE_LOADERS, children=[ colander.SchemaNode(colander.String()), ] ) TEMPLATE_STRING_IF_INVALID = colander.SchemaNode( colander.String(), missing=global_settings.TEMPLATE_STRING_IF_INVALID, default=global_settings.TEMPLATE_STRING_IF_INVALID, ) TEST_NON_SERIALIZED_APPS = colander.SchemaNode( colander.Sequence(), missing=global_settings.TEST_NON_SERIALIZED_APPS, default=global_settings.TEST_NON_SERIALIZED_APPS, children=[ colander.SchemaNode(colander.String()), ] ) TEST_RUNNER = colander.SchemaNode( colander.String(), missing=global_settings.TEST_RUNNER, default=global_settings.TEST_RUNNER, ) THOUSAND_SEPARATOR = colander.SchemaNode( colander.String(), missing=global_settings.THOUSAND_SEPARATOR, default=global_settings.THOUSAND_SEPARATOR, ) TIME_FORMAT = colander.SchemaNode( colander.String(), missing=global_settings.TIME_FORMAT, default=global_settings.TIME_FORMAT, ) TIME_INPUT_FORMATS = colander.SchemaNode( colander.Sequence(), missing=global_settings.TIME_INPUT_FORMATS, default=global_settings.TIME_INPUT_FORMATS, children=[ colander.SchemaNode(colander.String()), ] ) TIME_ZONE = colander.SchemaNode( colander.String(), missing=global_settings.TIME_ZONE, default=global_settings.TIME_ZONE, ) TRANSACTIONS_MANAGED = colander.SchemaNode( colander.Boolean(), missing=global_settings.TRANSACTIONS_MANAGED, default=global_settings.TRANSACTIONS_MANAGED, ) USE_ETAGS = colander.SchemaNode( colander.Boolean(), missing=global_settings.USE_ETAGS, default=global_settings.USE_ETAGS, ) USE_I18N = colander.SchemaNode( colander.Boolean(), missing=global_settings.USE_I18N, default=global_settings.USE_I18N, ) USE_L10N = colander.SchemaNode( colander.Boolean(), missing=global_settings.USE_L10N, default=global_settings.USE_L10N, ) USE_THOUSAND_SEPARATOR = colander.SchemaNode( colander.Boolean(), missing=global_settings.USE_THOUSAND_SEPARATOR, default=global_settings.USE_THOUSAND_SEPARATOR, ) USE_TZ = colander.SchemaNode( colander.Boolean(), missing=global_settings.USE_TZ, default=global_settings.USE_TZ, ) USE_X_FORWARDED_HOST = colander.SchemaNode( colander.Boolean(), missing=global_settings.USE_X_FORWARDED_HOST, default=global_settings.USE_X_FORWARDED_HOST, ) WSGI_APPLICATION = colander.SchemaNode( colander.String(), missing=global_settings.WSGI_APPLICATION, default=global_settings.WSGI_APPLICATION, ) YEAR_MONTH_FORMAT = colander.SchemaNode( colander.String(), missing=global_settings.YEAR_MONTH_FORMAT, default=global_settings.YEAR_MONTH_FORMAT, ) X_FRAME_OPTIONS = colander.SchemaNode( colander.String(), missing=global_settings.X_FRAME_OPTIONS, default=global_settings.X_FRAME_OPTIONS, )
class MembersSchema(colander.SequenceSchema): members = colander.SchemaNode(colander.String(), title=_(u"Member emails"), description=_(u"Add one address per field"), validator=colander.Email())
class User(Base, BaseMixin, GetByIdMixin): """A class representing a User.""" __tablename__ = 'users' @property def __acl__(self): # only admins can manage admins if self.admin: return [ (Allow, 'g:admins', ALL_PERMISSIONS), DENY_ALL, ] return [] # use UserFactory's acl #: used for logging in and system emails email = Column(String, unique=True, nullable=False, info={ 'colanderalchemy': dict( title='Email', validator=colander.Email(), ) }) #: encrypted with passlib password = Column(Unicode(120), info={ 'colanderalchemy': dict( title='Password', widget=deform.widget.PasswordWidget(size=128), ) }) #: unicode fullname, used in UI and emails fullname = Column(Unicode(120), info={'colanderalchemy': dict(title='Full name', )}) #: email of the affiliate that referred this user affiliate = Column(Unicode(120), info={'colanderalchemy': dict(title='Affiliate', )}) #: (optional) email that is used to make paypal purchases, if different #: than login email billing_email = Column(String, unique=True, info={ 'colanderalchemy': dict( title='Billing Email', validator=colander.Email(), ) }) #: date until user's subscription is valid, after this date the #: :func:`expire_subscriptions #: <pyramid_bimt.scripts.expire_subscriptions.expire_subscriptions>` will #: disable the user valid_to = Column( Date, default=date.today, info={'colanderalchemy': dict(title='Valid To', )}, ) #: (optional) Date on which user made his latest payment last_payment = Column( Date, info={'colanderalchemy': dict(title='Last payment', )}, ) #: shorthand for accessing user's groups groups = relationship('Group', secondary=user_group_table, backref='users') #: shorthand for accessing user's properties properties = relationship('UserProperty', cascade='all,delete-orphan') #: shorthand for accessing user's auditlog entries audit_log_entries = relationship('AuditLogEntry', backref='user') def __repr__(self): """Custom representation of the User object.""" return u'<{}:{} (email={})>'.format(self.__class__.__name__, self.id, repr(self.email)) def has_property(self, key): """True if user has this property set.""" prop = UserProperty.query.filter_by(user_id=self.id, key=key).first() if prop: return True return False def get_property(self, key, default=_marker, secure=False): """Get a User's property by key. :param key: Key by which to find the property. :type key: Unicode :param default: The return value if no property is found. Raises ValueError by default. :type default: anything :param secure: Symetrically encrypt the property before storing to DB. :type secure: bool :return: Value of the property. :rtype: Unicode """ result = UserProperty.query.filter_by(user_id=self.id, key=key) if result.count() < 1: if default == _marker: raise KeyError(u'Property "{}" not found.'.format(key)) else: return default value = result.one().value if secure: return SymmetricEncryption().decrypt(value) else: return value def set_property(self, key, value, strict=False, secure=False): """Set a User's property by key. :param key: Key by which to save the property. :type key: Unicode :param value: Value of the property. :type value: Unicode :param strict: If True, raise an error if property of given key key does not yet exists. In other words, update an existing property or fail. False by default. :type strict: bool """ if secure: value = unicode(SymmetricEncryption().encrypt(value)) result = UserProperty.query.filter_by(user_id=self.id, key=key) if result.count() < 1 and strict: raise KeyError('Property "{}" not found.'.format(key)) elif result.count() < 1 and not strict: self.properties.append(UserProperty(key=key, value=value)) else: result.one().value = value @property def admin(self): """True if User is in 'admins' group, False otherwise.""" return 'admins' in [g.name for g in self.groups] @property def staff(self): """True if User is in 'staff' or 'admins' group, False otherwise.""" return self.admin or 'staff' in [g.name for g in self.groups] @property def trial(self): """True if User is in 'trial' group, False otherwise.""" return 'trial' in [g.name for g in self.groups] @property def product_group(self): """Get the user's group that has product_id set. Can be only one. Groups with group.addon set to True are ignored. """ try: return Group.query\ .filter(Group.users.contains(self))\ .filter(Group.addon == False)\ .filter(Group.product_id != None).one() # noqa except NoResultFound: return None @property def enabled(self): """True if User is in 'enabled' group, False otherwise.""" return 'enabled' in [g.name for g in self.groups] def enable(self): """Enable User by putting it in the 'enabled' group. :return: True if user was enabled, False if nothing changed. :rtype: bool """ if not self.enabled: self.groups.append(Group.by_name('enabled')) return True else: return False def disable(self): """Disable User by removing it from the 'enabled' group. :return: True if user was disabled, False if nothing changed. :rtype: bool """ if self.enabled: self.groups.remove(Group.by_name('enabled')) return True else: return False @property def unsubscribed(self): """True if User is in 'unsubscribed' group, False otherwise.""" return 'unsubscribed' in [g.name for g in self.groups] def subscribe(self): """Subscribe User by removing it from the 'unsubscribed' group. :return: True if user was subscribed, False if nothing changed. :rtype: bool """ if self.unsubscribed: self.groups.remove(Group.by_name('unsubscribed')) return True else: return False def unsubscribe(self): """Unsubscribed User by appending it from the 'unsubscribed' group. :return: True if user was unsubscribed, False if nothing changed. :rtype: bool """ if self.unsubscribed: return False else: self.groups.append(Group.by_name('unsubscribed')) return True @classmethod def by_email(self, email): """Get a User by email.""" return User.query.filter_by(email=email).first() @classmethod def by_billing_email(self, billing_email): """Get a User by billing email.""" return User.query.filter_by(billing_email=billing_email).first() @classmethod def get_all( class_, order_by='email', order_direction='asc', filter_by=None, offset=None, search=None, limit=None, request=None, security=None, ): """Return all users. filter_by: dict -> {'name': 'foo'} By default, order by User.email. """ User = class_ q = Session.query(User) # Set correct order_by for timestamps if order_by == 'modified': order_by = 'm' elif order_by == 'created': order_by = 'c' q = q.order_by('{} {}'.format(order_by, order_direction)) if filter_by: q = q.filter_by(**filter_by) if search: q = q.filter( or_( User.email.ilike(u'%{}%'.format(search)), User.fullname.ilike(u'%{}%'.format(search)), )) if offset: q = q.slice(offset[0], offset[1]) elif limit: q = q.limit(limit) return q @classmethod def get_enabled(self): enabled = Group.by_name('enabled') return User.query.filter(User.groups.contains(enabled)).all()
def validator(node, cstruct): colander.Email()(node, cstruct) if request.user.email != cstruct and User.by_email(cstruct): raise colander.Invalid( node, u'Email {} is already in use by another user.'.format(cstruct))
class NewsletterSend(CSRFSchema): """Send a news letter.""" subject = colander.SchemaNode(colander.String(), title="Newsletter subject") preview = colander.SchemaNode(colander.Boolean(), description="Is this a preview send.", default=True) tags = colander.SchemaNode(colander.String(), title="Tag", description="Tags used for mailgun analytics", default="") tags = colander.SchemaNode( colander.String(), description=""" Specify tag being sent to mailgun analytics (per line) (maximum 3 tags). Default tags are: newsletter, subject line, sending time """, widget=deform.widget.TextAreaWidget(rows=4, cols=120), missing="", ) import_subscribers = colander.SchemaNode(colander.Boolean(), description="Import userbase as new subscribers", default=True) email = colander.SchemaNode(colander.String(), title="Preview email", description="Send preview email to this email address", validator=colander.Email(), missing=colander.null) domain = colander.SchemaNode( colander.String(), missing=colander.null, widget=deform.widget.TextInputWidget(readonly=True), title="Mailgun outbound domain", description="From secrets.ini", ) mailing_list = colander.SchemaNode( colander.String(), missing=colander.null, title="Mailgun mailing list email", widget=deform.widget.TextInputWidget(readonly=True), description="From secrets.ini", ) api_key = colander.SchemaNode( colander.String(), missing=colander.null, widget=deform.widget.TextInputWidget(readonly=True), title="Mailgun API key", description="From secrets.ini", ) def validator(self, node: "NewsletterSend", appstruct: dict): """Custom schema level validation code.""" # appstruct is Colander appstruct after all other validations have passed # Note that this method may not be never reached if appstruct["preview"] and appstruct["email"] == colander.null: # This error message appears at the top of the form raise colander.Invalid(node["email"], "Please fill in email field if you want to send a preview email.")
class Issue(Base): __tablename__ = "issue" __table_args__ = {"schema": schema} __colanderalchemy_config__ = { "title": _("Issue"), "plural": _("Issues"), "widget": FormWidget(fields_template="issue_fields"), } id = Column( Integer, primary_key=True, info={ # the `colanderalchemy` property allows to set a custom title for the # column or to use a specific widget. "colanderalchemy": {"title": _("Identifier"), "widget": HiddenWidget()} }, ) hash = Column( Text, nullable=False, unique=True, default=lambda: str(uuid4()), info={"colanderalchemy": {"exclude": True}, "c2cgeoform": {"duplicate": False}}, ) request_date = Column( Date, nullable=False, server_default=func.now(), info={"colanderalchemy": {"title": _("Request date")}}, ) geometry = Column( geoalchemy2.Geometry("POINT", 4326, management=True), info={ "colanderalchemy": { "title": _("Position"), "typ": colander_ext.Geometry( "POINT", srid=4326, map_srid=_map_config["srid"] ), "widget": deform_ext.MapWidget( map_options=_map_config, item_css_class="item-geometry" ), } }, ) type_id = Column( Integer, ForeignKey("{}.type.id".format(schema)), nullable=False, info={ "colanderalchemy": { "title": _("Type"), "widget": RelationSelectWidget( Type, "id", "label_en", order_by="label_en", default_value=("", _("- Select -")), ), } }, ) type = relationship(Type, info={"colanderalchemy": {"exclude": True}}) status = Column( Enum(*tuple(STATUSES.keys()), native_enum=False, name="status"), nullable=False, default="new", info={ "colanderalchemy": { "title": _("Status"), "widget": SelectWidget( values=list(STATUSES.items()), readonly=True, item_css_class="item-status", ), } }, ) @property def status_de(self): return self.status_i18n("de") @property def status_en(self): return self.status_i18n("en") @property def status_fr(self): return self.status_i18n("fr") def status_i18n(self, locale): localizer = make_localizer(locale, [resource_filename("getitfixed", "locale")]) return localizer.translate(STATUSES[self.status]) description = Column( Text, nullable=False, info={ "colanderalchemy": { "title": _("Description of the problem"), "widget": TextAreaWidget(rows=3), } }, ) localisation = Column( String(254), info={"colanderalchemy": {"title": _("Localisation")}} ) photos = relationship( Photo, cascade="all, delete-orphan", info={"colanderalchemy": {"title": _("Photos")}}, ) firstname = Column(String(100), info={"colanderalchemy": {"title": _("Firstname")}}) lastname = Column(String(100), info={"colanderalchemy": {"title": _("Lastname")}}) phone = Column( String(20), info={"colanderalchemy": {"title": _("Phone"), "widget": TelWidget()}}, ) email = Column( String(254), nullable=False, info={ "colanderalchemy": { "title": _("Email"), "validator": colander.Email(), "description": _( "This field is required to keep you informed about issue events" ), } }, ) private = Column( Boolean, nullable=False, server_default=text("False"), info={"colanderalchemy": {"title": _("Private"), "exclude": True}}, ) events = relationship( "Event", order_by="desc(Event.date)", backref=backref("issue", info={"colanderalchemy": {"exclude": True}}), info={ "colanderalchemy": { "title": _("Events"), "widget": SequenceWidget(readonly=True, item_css_class="item-events"), } }, ) public_events = relationship( "Event", order_by="desc(Event.date)", primaryjoin="and_(Event.issue_id==Issue.id, Event.private==False)", ) category = association_proxy("type", "category") def icon_url(self, request): return self.type.icon_url(request) if self.type else default_icon_url(request) def full_name(self): return "{} {}".format(self.firstname or "", self.lastname or "").strip()
class ExcavationPermission(Base): __tablename__ = 'excavations' __colanderalchemy_config__ = { 'title': _('Application form for permission to carry out excavation work') } id = Column( Integer, primary_key=True, info={ # the `colanderalchemy` property allows to set a custom title for the # column or to use a specific widget. 'colanderalchemy': { 'title': _('Permission Number'), 'widget': deform.widget.HiddenWidget(), # if the `admin_list` property is enabled for a column on the main # model, then this column will be shown in the admin list grid. 'admin_list': True } }) # the hash column is required for all main models hash = Column(Text, unique=True) reference_number = Column( Text, nullable=True, info={'colanderalchemy': { 'title': _('Reference Number') }}) request_date = Column(Date, nullable=True, info={ 'colanderalchemy': { 'title': _('Request Date'), 'admin_list': True } }) description = Column(Text, nullable=True, info={ 'colanderalchemy': { 'title': _('Description of the Work'), 'widget': deform.widget.TextAreaWidget(rows=3), } }) motif = Column(Text, nullable=True, info={ 'colanderalchemy': { 'title': _('Motive for the Work'), 'widget': deform.widget.TextAreaWidget(rows=3), } }) situations = relationship( SituationForPermission, # by setting the `cascade` property to 'delete-orphan', situation # entities are deleted when they are removed from the relation. cascade="all, delete-orphan", info={ 'colanderalchemy': { 'title': _('Situation'), # this widget type shows a select widget where the values are # loaded from a database table. in this case the select options # are generated from the Situation table. 'widget': deform_ext.RelationSelect2Widget(Situation, 'id', 'name', order_by='name', multiple=True) } }) # by default a Deform sequence widget is used for relationship columns, # which, for example, allows to create new contact persons in a sub-form. contact_persons = relationship( ContactPerson, # make sure persons are deleted when removed from the relation cascade="all, delete-orphan", info={'colanderalchemy': { 'title': _('Contact Persons') }}) location_district_id = Column( Integer, ForeignKey('district.id'), info={ 'colanderalchemy': { 'title': _('District'), 'widget': deform_ext.RelationSelect2Widget( District, 'id', # if the name for the options should be internationalized, one # can create columns like 'name_fr' and 'name_de' in the table # 'District'. then in the translation files, the column name # can be "translated" (e.g. the French "translation" for the # column name would be 'name_fr'). to apply the translation use # the label `_('name'))` instead of `name`. 'name', order_by='name', default_value=('', _('- Select -')), ) } }) location_street = Column(Text, nullable=False, info={'colanderalchemy': { 'title': _('Street') }}) location_postal_code = Column( Text, nullable=False, info={'colanderalchemy': { 'title': _('Postal Code') }}) location_town = Column(Text, nullable=False, info={'colanderalchemy': { 'title': _('Town') }}) # this is a search field to search for an address address_id = Column( Integer, ForeignKey('address.id'), info={ 'colanderalchemy': { 'title': _('Address'), 'widget': deform_ext.RelationSearchWidget( url=lambda request: request.route_url('addresses'), model=Address, min_length=1, id_field='id', label_field='label') } }) # to show a map for a geometry column, the column has to be defined as # follows. location_position = Column(geoalchemy2.Geometry('POINT', 4326, management=True), info={ 'colanderalchemy': { 'title': _('Position'), 'typ': colander_ext.Geometry('POINT', srid=4326, map_srid=3857), 'widget': deform_ext.MapWidget() } }) # Person in Charge for the Work responsible_title = Column( Text, nullable=True, info={ 'colanderalchemy': { 'title': _('Title'), 'validator': colander.OneOf(['mr', 'mrs']), 'widget': deform.widget.SelectWidget(values=(('', _('- Select -')), ('mr', _('Mr.')), ('mrs', _('Mrs.')))) } }) responsible_name = Column( Text, nullable=True, info={'colanderalchemy': { 'title': _('Name'), 'admin_list': True }}) responsible_first_name = Column(Text, nullable=True, info={ 'colanderalchemy': { 'title': _('First Name'), 'admin_list': True } }) responsible_mobile = Column( Text, nullable=True, info={'colanderalchemy': { 'title': _('Mobile Phone') }}) responsible_mail = Column(Text, nullable=True, info={ 'colanderalchemy': { 'title': _('Mail'), 'validator': colander.Email() } }) responsible_company = Column( Text, nullable=True, info={'colanderalchemy': { 'title': _('Company') }}) validated = Column(Boolean, info={ 'colanderalchemy': { 'title': _('Validation'), 'label': _('Validated') } }) # Work footprint work_footprint = Column(geoalchemy2.Geometry('MULTIPOLYGON', 4326, management=True), info={ 'colanderalchemy': { 'title': _('Footprint for the Work'), 'typ': colander_ext.Geometry('MULTIPOLYGON', srid=4326, map_srid=3857), 'widget': deform_ext.MapWidget() } }) # Photo photos = relationship(Photo, cascade="all, delete-orphan", info={'colanderalchemy': { 'title': _('Photo') }})
class User(Base): __tablename__ = 'user' __table_args__ = {'schema': _schema} __colanderalchemy_config__ = { 'title': _('User'), 'plural': _('Users') } __c2cgeoform_config__ = { 'duplicate': True } item_type = Column('type', String(10), nullable=False, info={ 'colanderalchemy': { 'widget': HiddenWidget() } }) __mapper_args__ = { 'polymorphic_on': item_type, 'polymorphic_identity': 'user', } id = Column(Integer, primary_key=True, info={ 'colanderalchemy': { 'widget': HiddenWidget() } }) username = Column(Unicode, unique=True, nullable=False, info={ 'colanderalchemy': { 'title': _('Username') } }) _password = Column('password', Unicode, nullable=False, info={'colanderalchemy': {'exclude': True}}) temp_password = Column('temp_password', Unicode, nullable=True, info={'colanderalchemy': {'exclude': True}}) email = Column(Unicode, nullable=False, info={ 'colanderalchemy': { 'title': _('Email'), 'validator': colander.Email() } }) is_password_changed = Column(Boolean, default=False, info={'colanderalchemy': {'exclude': True}}) settings_role_id = Column(Integer, info={ 'colanderalchemy': { 'title': _('Settings from role'), 'description': 'Only used for settings not for permissions', 'widget': deform_ext.RelationSelect2Widget( Role, 'id', 'name', order_by='name', default_value=('', _('- Select -')) ) } }) settings_role = relationship( Role, foreign_keys='User.settings_role_id', primaryjoin='Role.id==User.settings_role_id', info={ 'colanderalchemy': { 'title': _('Settings role'), 'exclude': True } }) roles = relationship( Role, secondary=user_role, secondaryjoin=Role.id == user_role.c.role_id, backref=backref('users', info={'colanderalchemy': {'exclude': True}}), info={ 'colanderalchemy': { 'title': _('Roles'), 'exclude': True } } ) last_login = Column(DateTime(timezone=True), info={ 'colanderalchemy': { 'title': _('Last login'), 'missing': colander.drop, 'widget': DateTimeInputWidget(readonly=True) } }) expire_on = Column(DateTime(timezone=True), info={ 'colanderalchemy': { 'title': _('Expiration date') } }) deactivated = Column(Boolean, default=False, info={ 'colanderalchemy': { 'title': _('Deactivated') } }) def __init__( self, username: str = '', password: str = '', email: str = '', is_password_changed: bool = False, settings_role: Role = None, roles: List[Role] = [], expire_on: datetime = None, deactivated: bool = False ) -> None: self.username = username self.password = password self.email = email self.is_password_changed = is_password_changed if settings_role: self.settings_role = settings_role self.roles = roles self.expire_on = expire_on self.deactivated = deactivated @property def password(self) -> str: """returns password""" return self._password # pragma: no cover @password.setter def password(self, password: str) -> None: """encrypts password on the fly.""" self._password = self.__encrypt_password(password) def set_temp_password(self, password: str) -> None: """encrypts password on the fly.""" self.temp_password = self.__encrypt_password(password) @staticmethod def __encrypt_password_legacy(password: str) -> str: """Hash the given password with SHA1.""" return sha1(password.encode('utf8')).hexdigest() @staticmethod def __encrypt_password(password: str) -> str: # TODO: remove pylint disable when https://github.com/PyCQA/pylint/issues/3047 is fixed return crypt.crypt(password, crypt.METHOD_SHA512) # pylint: disable=E1101 def validate_password(self, passwd: str) -> bool: """Check the password against existing credentials. this method _MUST_ return a boolean. @param passwd: the password that was provided by the user to try and authenticate. This is the clear text version that we will need to match against the (possibly) encrypted one in the database. """ if self._password.startswith('$'): # new encryption method if compare_hash(self._password, crypt.crypt(passwd, self._password)): return True else: # legacy encryption method if compare_hash(self._password, self.__encrypt_password_legacy(passwd)): # convert to the new encryption method self._password = self.__encrypt_password(passwd) return True if \ self.temp_password is not None and \ self.temp_password != '' and \ compare_hash(self.temp_password, crypt.crypt(passwd, self.temp_password)): self._password = self.temp_password self.temp_password = None self.is_password_changed = False return True return False def expired(self) -> bool: return self.expire_on is not None and self.expire_on < datetime.now(pytz.utc) def update_last_login(self) -> None: self.last_login = datetime.now(pytz.utc) def __unicode__(self) -> str: return self.username or '' # pragma: no cover
class EmailNode(BaseNode): title = 'Email' schema_type = colander.String validator = colander.All(colander.Length(max=250), colander.Email())
class NewsletterSubscriptionSchema(CSRFSchema): email = colander.Schema(colander.String(), validator=colander.Email())
def __call__(self, node, value): email_val = colander.Email() email_val(node, value) if self.context['users'].get_user_by_email(value) is not None: raise colander.Invalid(node, _("Already registered. You may recover your password if you've lost it."))
class AccountRegister(colander.MappingSchema): fullname = colander.SchemaNode(colander.String()) email = colander.SchemaNode(colander.String(), validator=colander.Email()) terms = colander.SchemaNode(colander.Bool())
#TODO: move these to a separate module class SignupSchema(colander.MappingSchema): """ Signup form schema for creation and validation. """ username = colander.SchemaNode(colander.String(), validator=colander.Regex(usernameregex, msg)) firstname = colander.SchemaNode(colander.String()) lastname = colander.SchemaNode(colander.String()) password = colander.SchemaNode(colander.String(), validator=colander.Length(min=5, max=100), widget=widget.CheckedPasswordWidget(size=20), description='Enter a password') email = colander.SchemaNode(colander.String(), validator=colander.Email()) gender = colander.SchemaNode(colander.String(), widget=widget.RadioChoiceWidget(values=(('male', 'Male'), ('female', 'Female'),('other', 'Other'))), title='Choose your gender', description='Select a gender', validator=colander.OneOf(('male', 'female', 'other'))) interestedin = colander.SchemaNode(Set(), widget=widget.CheckboxChoiceWidget(values=(('men', 'Men'), ('women', 'Women')))) lookingfor =colander.SchemaNode(Set(), widget=widget.CheckboxChoiceWidget(values=looking_fors)) age = colander.SchemaNode(colander.String(), widget=widget.SelectWidget(values=ages)) class EditSchema(colander.MappingSchema): """
def emails_validator(node, value): value = value.lower() for email in value.splitlines(): colander.Email()(node, email)