def test13():
p = editor.Property().validate(check)
p(5)
assert (p.input == p() == p.value == 5) and (p.error is None)
def test14():
p = editor.Property().validate(check)
p(15)
assert (p.input == p() == 15) and (p.value is None) and (p.error
== 'invalid')
def test10():
p = editor.Property(5)
assert (p.input == p() == p.value == 5) and (p.error is None)
def test12():
p = editor.Property(15).validate(check)
assert (p.input == p() == p.value == 15) and (p.error is None)
def __init__(self):
"""At this stage, we are using ``editor.Property`` but without
validation functions"""
self.title = editor.Property(None)
self.img = editor.Property(None)
def test9():
p = editor.Property()
assert (p.input is None) and (p() is None) and (p.value is
None) and (p.error is None)
def __init__(self, parent, pattern, batch_size=10):
super(UserBrowser, self).__init__(parent, None, batch_size)
self.pattern = pattern
self.search_field = editor.Property("text")
def __init__(self, parent):
self.parent = parent
self.period_selection = editor.Property(self.LAST_7_DAYS)
self.since_date = editor.Property().validate(validators.date)
def __init__(self, comment):
self.id = comment.id
self.content = editor.Property(comment.content)
self.content_editor = component.Component(
InplaceEditor(self.content, self.commit))
def __init__(self, parent, default_domain=None):
event_management._register_listener(parent, self)
self.domain = editor.Property(default_domain)
self.content = editor.Property('').validate(
validators.non_empty_string)
def reset_fields(self):
user = self.user
uid = user.uid if user else u''
email = user.email if user else u''
firstname = user.firstname if user else u''
lastname = user.lastname if user else u''
fi_uid = user.fi_uid if user else u''
roles = [
role for role in self.assignable_roles if user.has_role(role)
] if user else []
work_phone = (user.work_phone or u'') if user else u''
mobile_phone = (user.mobile_phone or u'') if user else u''
position = user.position if user else u''
corporation_id = (user.corporation_id or u'-1') if user else u'-1'
direction_id = (user.direction_id or u'-1') if user else u'-1'
service_id = (user.service_id or u'-1') if user else u'-1'
site_id = (user.site_id or u'-1') if user else u'-1'
subsite_id = (user.subsite_id or u'-1') if user else u'-1'
enabled = user.enabled if user else True
incorporated = user.incorporated if user else False
self.login = editor.Property(uid).validate(self.validate_login)
self.email = editor.Property(email).validate(self.validate_email)
self.firstname = editor.Property(firstname).validate(
validators.non_empty_string)
self.lastname = editor.Property(lastname).validate(
validators.non_empty_string)
self.fi_uid = editor.Property(fi_uid).validate(
validators.non_empty_string)
self.roles = editor.Property(roles)
self.work_phone = editor.Property(work_phone)
self.mobile_phone = editor.Property(mobile_phone)
self.position = editor.Property(position)
self.corporation_id = editor.Property(corporation_id)
self.direction_id = editor.Property(direction_id)
self.service_id = editor.Property(service_id)
self.site_id = editor.Property(site_id)
self.subsite_id = editor.Property(subsite_id)
self.enabled = editor.Property(enabled)
self.incorporated = editor.Property(incorporated)
def reset(self):
self.delete_reason = editor.Property('').validate(
lambda v: validator.StringValidator(v).shorter_or_equal_than(
150,
_(u"Length must be shorter or equal than %(max)d characters")))
self.show_delete_form = editor.Property(False)
def reset(self):
self.content = editor.Property(u'').validate(non_empty_string)
self.attachment = editor.Property(None).validate(validate_attachment)
def __init__(self, user):
super(MailSettingsEditor, self).__init__(None)
self.uid = user if is_string(user) else user.uid
self.mail_delivery_frequency = editor.Property(
self.user.mail_delivery_frequency)
def __init__(self):
self.title = editor.Property(None)
self.img = editor.Property(None)
self.title.validate(validator.to_string().not_empty().to_string())
self.img.validate(self.validate_img)
def __init__(self, user):
super(AvatarEditor, self).__init__(None)
self.uid = user if is_string(user) else user.uid
self.photo = editor.Property(self.user.photo).validate(
self.validate_img)
def __init__(self, app_title, app_banner, theme, get_user_by_username):
self._get_user_by_username = get_user_by_username
self.username = editor.Property('').validate(self.validate_username)
self.email = editor.Property('').validate(validator.validate_email)
self.header = component.Component(Header(app_title, app_banner, theme))
self.error_message = u''
def __init__(self, idea):
self.idea_id = idea if is_integer(idea) else idea.id
# first form (context)
self.title = editor.Property(self.data.title).validate(
validators.non_empty_string)
self.description = editor.Property(self.data.description).validate(
validators.non_empty_string)
self.impact = editor.Property(self.data.impact).validate(
validators.non_empty_string)
self.benefit_department = editor.Property(self.idea.benefit_department
or '')
# second form (expert)
self.expert_email = editor.Property('').validate(
lambda t: validators.user_email(t, required=True))
self.comment = editor.Property('').validate(
validators.non_empty_string)
# form (evaluation)
if self.data.target_date:
self.target_date = editor.Property(
datetime.strftime(self.data.target_date, '%d/%m/%Y'))
else:
self.target_date = editor.Property('')
self.goal = editor.Property(self.data.goal).validate(
validators.FloatValidator)
self.revenues_first_year = editor.Property(
self.data.revenues_first_year)
self.revenues_first_year_value = editor.Property(
self.data.revenues_first_year_value).validate(
validators.FloatValidator)
self.revenues_second_year = editor.Property(
self.data.revenues_second_year)
self.revenues_second_year_value = editor.Property(
self.data.revenues_second_year_value).validate(
validators.FloatValidator)
self.expenses_first_year = editor.Property(
self.data.expenses_first_year)
self.expenses_first_year_value = editor.Property(
self.data.expenses_first_year_value)
self.expenses_second_year = editor.Property(
self.data.expenses_second_year)
self.expenses_second_year_value = editor.Property(
self.data.expenses_second_year_value)
self.evaluation_impact = editor.Property(self.data.evaluation_impact)
# third form (benefit)
self.financial_gain = editor.Property(self.data.financial_gain)
self.customer_satisfaction = editor.Property(
self.data.customer_satisfaction)
self.process_tier_down = editor.Property(self.data.process_tier_down)
self.public_image = editor.Property(self.data.public_image)
self.environment_improvement = editor.Property(
self.data.environment_improvement)
self.other_impact = editor.Property(self.data.other_impact)
# fourth form (potential)
self.innovation_scale = editor.Property(
self.data.innovation_scale or 1).validate(validators.integer)
self.complexity_scale = editor.Property(
self.data.complexity_scale or 1).validate(validators.integer)
self.duplicate = editor.Property(self.data.duplicate).validate(
validators.integer)
self.localization = editor.Property(self.data.localization).validate(
validators.integer)
self.selected_item = editor.Property('')
def __init__(self, challenge=None, mobile_access=False):
self.id = challenge if (is_integer(challenge)
or challenge is None) else challenge.id
self.challenge_repository = ChallengeRepository()
self.mobile_access = mobile_access
challenge = self.challenge
# properties
self.title = editor.Property(u'').validate(validators.non_empty_string)
self.short_title = editor.Property(u'').validate(
validators.non_empty_string)
self.created_by = editor.Property(u'').validate(
lambda t: validators.user_email(t, True))
self.organization = editor.Property(u'').validate(
validators.non_empty_string)
self.associated_dis = editor.Property(u'').validate(
validators.user_email_list)
self.starting_date = editor.Property(u'').validate(
validators.non_empty_date)
self.ending_date = editor.Property(u'').validate(
validators.non_empty_date)
self.summary = editor.Property(u'').validate(
validators.non_empty_string)
self.description = editor.Property(u'').validate(
validators.non_empty_string)
self.mobile_description = editor.Property(u'')
self.outcome = editor.Property(u'').validate(validators.string)
self.tags = editor.Property(u'').validate(
lambda t: validators.word_list(t, duplicates='remove'))
if challenge:
self.title.set(challenge.title)
self.short_title.set(challenge.short_title)
self.created_by.set(challenge.created_by.email)
self.organization.set(challenge.organization)
associated_dis_email = ','.join(
user.email for user in challenge.associated_dis)
self.associated_dis.set(associated_dis_email)
self.starting_date.set(
challenge.starting_date.date().strftime('%d/%m/%Y'))
self.ending_date.set(
challenge.ending_date.date().strftime('%d/%m/%Y'))
self.summary.set(challenge.summary)
self.description.set(challenge.description)
self.mobile_description.set(challenge.mobile_description)
self.outcome.set(challenge.outcome)
self.tags.set(u', '.join(challenge.tags))
# Because the mobile description is optional in each eureka instance
# and the validator will be triggered if we do this before
self.mobile_description.validate(validators.non_empty_string)
