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)
