code
stringlengths 501
5.19M
| package
stringlengths 2
81
| path
stringlengths 9
304
| filename
stringlengths 4
145
|
|---|---|---|---|
from datetime import datetime
from member.conf import settings
from django.db import models
from hashlib import md5
from django.http import HttpRequest
from django.contrib.sessions.models import Session
from django.contrib.auth import logout
import os
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
from django.dispatch import receiver
from django.contrib.sites.models import Site
import pygeoip
from .managers import ProfileManager
from importlib import import_module
class Profile(models.Model):
"""
A user profile. Complementary data of standard Django `auth.user`.
"""
class Meta:
verbose_name = 'Profil'
verbose_name_plural = 'Profils'
permissions = (
("moderation", u"Moderate membre"),
("show_ip", u"Show member's Ip Adress"),
)
# Link with standard user is a simple one-to-one link, as recommended in official documentation.
# See https://docs.djangoproject.com/en/1.6/topics/auth/customizing/#extending-the-existing-user-model
user = models.OneToOneField(
User,
verbose_name='User',
related_name="profile")
last_ip_address = models.CharField(
'IP Adress',
max_length=39,
blank=True,
null=True)
site = models.CharField('Web site', max_length=2000, blank=True)
show_email = models.BooleanField('Show email adress on public',
default=False)
avatar_url = models.CharField(
'Avatar url', max_length=2000, null=True, blank=True
)
biography = models.TextField('Biography', blank=True)
karma = models.IntegerField('Karma', default=0)
sign = models.TextField('Sign', max_length=250, blank=True)
show_sign = models.BooleanField('Show signs', default=True)
# TODO: Change this name. This is a boolean: "true" is "hover" or "click" ?!
hover_or_click = models.BooleanField('Hover or clic ?', default=False)
email_for_answer = models.BooleanField('Envoyer pour les réponse MP', default=False)
can_read = models.BooleanField('Possibilité de lire', default=True)
end_ban_read = models.DateTimeField(
'Fin d\'interdiction de lecture',
null=True,
blank=True)
can_write = models.BooleanField('Possibilité d\'écrire', default=True)
end_ban_write = models.DateTimeField(
'Fin d\'interdiction d\'ecrire',
null=True,
blank=True)
last_visit = models.DateTimeField(
'Date de dernière visite',
null=True,
blank=True)
objects = ProfileManager()
_permissions = {}
def __unicode__(self):
return self.user.username
def is_private(self):
"""
Check if the user belong to the bot's group or not
:return: ``True`` if user belong to the bot's group, ``False`` else.
:rtype: bool
"""
user_groups = self.user.groups.all()
user_group_names = [g.name for g in user_groups]
return settings.ZDS_MEMBER['bot_group'] in user_group_names
def get_absolute_url(self):
"""Absolute URL to the profile page."""
return reverse('member-detail', kwargs={'user_name': self.user.username})
def get_city(self):
"""
Uses geo-localization to get physical localization of a profile through its last IP address.
This works relatively good with IPv4 addresses (~city level), but is very imprecise with IPv6 or exotic internet
providers.
:return: The city and the country name of this profile.
:rtype: str
"""
# FIXME: this test to differentiate IPv4 and IPv6 addresses doesn't work, as IPv6 addresses may have length < 16
# Example: localhost ("::1"). Real test: IPv4 addresses contains dots, IPv6 addresses contains columns.
if len(self.last_ip_address) <= 16:
gic = pygeoip.GeoIP(
os.path.join(
settings.GEOIP_PATH,
'GeoLiteCity.dat'))
else:
gic = pygeoip.GeoIP(
os.path.join(
settings.GEOIP_PATH,
'GeoLiteCityv6.dat'))
geo = gic.record_by_addr(self.last_ip_address)
if geo is not None:
return u'{0}, {1}'.format(geo['city'], geo['country_name'])
return ''
def get_avatar_url(self):
"""Get the avatar URL for this profile.
If the user has defined a custom URL, use it.
If not, use Gravatar.
:return: The avatar URL for this profile
:rtype: str
"""
if self.avatar_url:
current_site = Site.objects.get_current()
if self.avatar_url.startswith(settings.MEDIA_URL):
return u"{}{}".format(current_site.domain, self.avatar_url)
else:
return self.avatar_url
else:
return 'https://secure.gravatar.com/avatar/{0}?d=identicon'.format(
md5(self.user.email.lower().encode("utf-8")).hexdigest())
def can_read_now(self):
"""
Check if you can read a web site content as user.
If you can't read, you can't login on website.
This happens when you have been banned (temporarily or definitively)
:return: ``False`` if you are banned, ``True`` else.
:rtype: bool
"""
if self.user.is_authenticated:
if self.user.is_active:
if self.end_ban_read:
return self.can_read or (
self.end_ban_read < datetime.now())
else:
return self.can_read
else:
return False
def can_write_now(self):
"""
Check if you can write something on a web site as user.
This happens when you have been reading only (temporarily or definitively)
:return: ``False`` if you are read only, ``True`` else.
:rtype: bool
"""
if self.user.is_active:
if self.end_ban_write:
return self.can_write or (self.end_ban_write < datetime.now())
else:
return self.can_write
else:
return False
@receiver(models.signals.post_delete, sender=User)
def auto_delete_token_on_unregistering(sender, instance, **kwargs):
"""
This signal receiver deletes forgotten password tokens and registering tokens for the un-registering user;
"""
TokenForgotPassword.objects.filter(user=instance).delete()
TokenRegister.objects.filter(user=instance).delete()
class TokenForgotPassword(models.Model):
"""
When a user forgot its password, the website sends it an email with a token (embedded in a URL).
If the user has the correct token, it can choose a new password on the dedicated page.
This model stores the tokens for the users that have forgot their passwords, with an expiration date.
"""
class Meta:
verbose_name = 'Token de mot de passe oublié'
verbose_name_plural = 'Tokens de mots de passe oubliés'
user = models.ForeignKey(User, verbose_name='Utilisateur', db_index=True)
token = models.CharField(max_length=100, db_index=True)
date_end = models.DateTimeField('Date de fin')
def get_absolute_url(self):
"""
:return: The absolute URL of the "New password" page, including the correct token.
"""
return reverse('member.views.new_password') + '?token={0}'.format(self.token)
def __unicode__(self):
return u"{0} - {1}".format(self.user.username, self.date_end)
class TokenRegister(models.Model):
"""
On registration, a token is send by mail to the user. It must use this token (by clicking on a link) to activate its
account (and prove the email address is correct) and connect itself.
This model stores the registration token for each user, with an expiration date.
"""
class Meta:
verbose_name = 'Token d\'inscription'
verbose_name_plural = 'Tokens d\'inscription'
user = models.ForeignKey(User, verbose_name='Utilisateur', db_index=True)
token = models.CharField(max_length=100, db_index=True)
date_end = models.DateTimeField('Date de fin')
def get_absolute_url(self):
"""
:return: the absolute URL of the account validation page, including the token.
"""
return reverse('member.views.active_account') + '?token={0}'.format(self.token)
def __unicode__(self):
return u"{0} - {1}".format(self.user.username, self.date_end)
class Ban(models.Model):
"""
This model stores all sanctions (not only bans).
It stores sanctioned user, the moderator, the type of sanctions, the reason and the date.
Note this stores also un-sanctions.
"""
class Meta:
verbose_name = 'Sanction'
verbose_name_plural = 'Sanctions'
user = models.ForeignKey(User, verbose_name='Sanctionné', db_index=True)
moderator = models.ForeignKey(User, verbose_name='Moderateur',
related_name='bans', db_index=True)
type = models.CharField('Type', max_length=80, db_index=True)
text = models.TextField('Explication de la sanction')
pubdate = models.DateTimeField(
'Date de publication',
blank=True,
null=True, db_index=True)
def __unicode__(self):
return u"{0} - ban : {1} ({2}) ".format(self.user.username, self.text, self.pubdate)
class KarmaNote(models.Model):
"""
A karma note is a tool for staff to store data about a member.
Data are:
- A note (negative values are bad)
- A comment about the member
- A date
This helps the staff to react and stores history of stupidities of a member.
"""
class Meta:
verbose_name = 'Note de karma'
verbose_name_plural = 'Notes de karma'
user = models.ForeignKey(User, related_name='karmanote_user', db_index=True)
# TODO: coherence, "staff" is called "moderator" in Ban model.
staff = models.ForeignKey(User, related_name='karmanote_staff', db_index=True)
# TODO: coherence, "comment" is called "text" in Ban model.
comment = models.CharField('Commentaire', max_length=150)
value = models.IntegerField('Valeur')
# TODO: coherence, "create_at" is called "pubdate" in Ban model.
create_at = models.DateTimeField('Date d\'ajout', auto_now_add=True)
def __unicode__(self):
return u"{0} - note : {1} ({2}) ".format(self.user.username, self.comment, self.create_at)
def logout_user(username):
"""
Logout the member.
:param username: the name of the user to logout.
"""
now = datetime.now()
request = HttpRequest()
sessions = Session.objects.filter(expire_date__gt=now)
user = User.objects.get(username=username)
for session in sessions:
user_id = session.get_decoded().get('_auth_user_id')
if user.id == user_id:
engine = import_module(settings.SESSION_ENGINE)
request.session = engine.SessionStore(session.session_key)
logout(request)
break | zds-member | /zds-member-0.1.5.tar.gz/zds-member-0.1.5/member/models.py | models.py |
from django import forms
from django.contrib.auth import authenticate
from django.contrib.auth.models import User, Group
from django.core.urlresolvers import reverse
from django.db.models import Q
from django.utils.translation import ugettext_lazy as _
from crispy_forms.bootstrap import StrictButton
from crispy_forms.helper import FormHelper
from crispy_forms.layout import HTML, Layout, \
Submit, Field, ButtonHolder, Hidden, Div
from member.models import Profile, KarmaNote
from member.validators import ProfileUsernameValidator, ProfileEmailValidator
# Max password length for the user.
# Unlike other fields, this is not the length of DB field
MAX_PASSWORD_LENGTH = 76
# Min password length for the user.
MIN_PASSWORD_LENGTH = 6
class LoginForm(forms.Form):
"""
The login form, including the "remember me" checkbox.
"""
username = forms.CharField(
label=_(u"Nom d'utilisateur"),
max_length=User._meta.get_field('username').max_length,
required=True,
widget=forms.TextInput(
attrs={
'autofocus': ''
}
)
)
password = forms.CharField(
label=_(u'Mot de passe'),
max_length=MAX_PASSWORD_LENGTH,
min_length=MIN_PASSWORD_LENGTH,
required=True,
widget=forms.PasswordInput,
)
remember = forms.BooleanField(
label=_(u'Se souvenir de moi'),
initial=True,
)
def __init__(self, next=None, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_action = reverse('member.views.login_view')
self.helper.form_method = 'post'
self.helper.form_class = 'content-wrapper'
self.helper.layout = Layout(
Field('username'),
Field('password'),
Field('remember'),
HTML('{% csrf_token %}'),
ButtonHolder(
StrictButton(_(u'Se connecter'), type='submit'),
)
)
class RegisterForm(forms.Form, ProfileUsernameValidator, ProfileEmailValidator):
"""
Form to register a new member.
"""
email = forms.EmailField(
label=_(u'Adresse courriel'),
max_length=User._meta.get_field('email').max_length,
required=True,
)
username = forms.CharField(
label=_(u'Nom d\'utilisateur'),
max_length=User._meta.get_field('username').max_length,
required=True,
)
password = forms.CharField(
label=_(u'Mot de passe'),
max_length=MAX_PASSWORD_LENGTH,
min_length=MIN_PASSWORD_LENGTH,
required=True,
widget=forms.PasswordInput
)
password_confirm = forms.CharField(
label=_(u'Confirmation du mot de passe'),
max_length=MAX_PASSWORD_LENGTH,
min_length=MIN_PASSWORD_LENGTH,
required=True,
widget=forms.PasswordInput
)
def __init__(self, *args, **kwargs):
super(RegisterForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_class = 'content-wrapper'
self.helper.form_method = 'post'
self.helper.layout = Layout(
Field('username'),
Field('password'),
Field('password_confirm'),
Field('email'),
ButtonHolder(
Submit('submit', _(u'Valider mon inscription')),
))
def clean(self):
"""
Cleans the input data and performs following checks:
- Both passwords are the same
- Username doesn't exist in database
- Username is not empty
- Username doesn't contain any comma (this will break the personal message system)
- Username doesn't begin or ends with spaces
- Password is different of username
- Email address is unique through all users
- Email provider is not a forbidden one
Forbidden email providers are stored in `forbidden_email_providers.txt` on project root.
:return: Cleaned data, and the error messages if they exist.
"""
cleaned_data = super(RegisterForm, self).clean()
# Check that the password and it's confirmation match
password = cleaned_data.get('password')
password_confirm = cleaned_data.get('password_confirm')
if not password_confirm == password:
msg = _(u'Les mots de passe sont différents')
self._errors['password'] = self.error_class([msg])
self._errors['password_confirm'] = self.error_class([msg])
if 'password' in cleaned_data:
del cleaned_data['password']
if 'password_confirm' in cleaned_data:
del cleaned_data['password_confirm']
# Check that the user doesn't exist yet
username = cleaned_data.get('username')
self.validate_username(username)
if username is not None:
# Check that password != username
if password == username:
msg = _(u'Le mot de passe doit être différent du pseudo')
self._errors['password'] = self.error_class([msg])
if 'password' in cleaned_data:
del cleaned_data['password']
if 'password_confirm' in cleaned_data:
del cleaned_data['password_confirm']
email = cleaned_data.get('email')
self.validate_email(email)
return cleaned_data
def throw_error(self, key=None, message=None):
self._errors[key] = self.error_class([message])
class MiniProfileForm(forms.Form):
"""
Updates some profile data: biography, website, avatar URL, signature.
"""
biography = forms.CharField(
label=_('Biographie'),
required=False,
widget=forms.Textarea(
attrs={
'placeholder': _(u'Votre biographie au format Markdown.'),
'class': 'md-editor'
}
)
)
site = forms.CharField(
label='Site internet',
required=False,
max_length=Profile._meta.get_field('site').max_length,
widget=forms.TextInput(
attrs={
'placeholder': _(u'Lien vers votre site internet '
u'personnel (ne pas oublier le http:// ou https:// devant).')
}
)
)
avatar_url = forms.CharField(
label='Avatar',
required=False,
max_length=Profile._meta.get_field('avatar_url').max_length,
widget=forms.TextInput(
attrs={
'placeholder': _(u'Lien vers un avatar externe '
u'(laissez vide pour utiliser Gravatar).')
}
)
)
sign = forms.CharField(
label='Signature',
required=False,
max_length=Profile._meta.get_field('sign').max_length,
widget=forms.TextInput(
attrs={
'placeholder': _(u'Elle apparaitra dans les messages de forums. ')
}
)
)
def __init__(self, *args, **kwargs):
super(MiniProfileForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_class = 'content-wrapper'
self.helper.form_method = 'post'
self.helper.layout = Layout(
Field('biography'),
Field('site'),
Field('avatar_url'),
Field('sign'),
ButtonHolder(
StrictButton(_(u'Enregistrer'), type='submit'),
))
class ProfileForm(MiniProfileForm):
"""
Updates main profile rules:
- Display email address to everybody
- Display signatures
- Display menus on hover
- Receive an email when receiving a personal message
"""
options = forms.MultipleChoiceField(
label='',
required=False,
choices=(
('show_email', _(u"Afficher mon adresse courriel publiquement")),
('show_sign', _(u"Afficher les signatures")),
('hover_or_click', _(u"Cochez pour dérouler les menus au survol")),
('email_for_answer', _(u'Recevez un courriel lorsque vous '
u'recevez une réponse à un message privé')),
),
widget=forms.CheckboxSelectMultiple,
)
def __init__(self, *args, **kwargs):
super(ProfileForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_class = 'content-wrapper'
self.helper.form_method = 'post'
# to get initial value form checkbox show email
initial = kwargs.get('initial', {})
self.fields['options'].initial = ''
if 'show_email' in initial and initial['show_email']:
self.fields['options'].initial += 'show_email'
if 'show_sign' in initial and initial['show_sign']:
self.fields['options'].initial += 'show_sign'
if 'hover_or_click' in initial and initial['hover_or_click']:
self.fields['options'].initial += 'hover_or_click'
if 'email_for_answer' in initial and initial['email_for_answer']:
self.fields['options'].initial += 'email_for_answer'
self.helper.layout = Layout(
Field('biography'),
Field('site'),
Field('avatar_url'),
Field('sign'),
Field('options'),
ButtonHolder(
StrictButton(_(u'Enregistrer'), type='submit'),
))
class ChangeUserForm(forms.Form, ProfileUsernameValidator, ProfileEmailValidator):
"""
Update username and email
"""
username = forms.CharField(
label=_(u'Nouveau pseudo'),
max_length=User._meta.get_field('username').max_length,
min_length=1,
required=False,
widget=forms.TextInput(
attrs={
'placeholder': _(u'Ne mettez rien pour conserver l\'ancien')
}
)
)
email = forms.EmailField(
label=_(u'Nouvelle adresse courriel'),
max_length=User._meta.get_field('email').max_length,
required=False,
widget=forms.TextInput(
attrs={
'placeholder': _(u'Ne mettez rien pour conserver l\'ancien')
}
),
error_messages={'invalid': _(u'Veuillez entrer une adresse email valide.'), }
)
def __init__(self, *args, **kwargs):
super(ChangeUserForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_class = 'content-wrapper'
self.helper.form_method = 'post'
self.helper.layout = Layout(
Field('username'),
Field('email'),
ButtonHolder(
StrictButton(_(u'Enregistrer'), type='submit'),
),
)
def clean(self):
cleaned_data = super(ChangeUserForm, self).clean()
username_new = cleaned_data.get('username')
if username_new is not None:
self.validate_username(username_new)
email_new = cleaned_data.get('email')
if email_new is not None:
self.validate_email(email_new)
return cleaned_data
def throw_error(self, key=None, message=None):
self._errors[key] = self.error_class([message])
# TODO: Updates the password --> requires a better name
class ChangePasswordForm(forms.Form):
password_new = forms.CharField(
label=_(u'Nouveau mot de passe'),
max_length=MAX_PASSWORD_LENGTH,
min_length=MIN_PASSWORD_LENGTH,
widget=forms.PasswordInput,
)
password_old = forms.CharField(
label=_(u'Mot de passe actuel'),
widget=forms.PasswordInput,
)
password_confirm = forms.CharField(
label=_(u'Confirmer le nouveau mot de passe'),
max_length=MAX_PASSWORD_LENGTH,
min_length=MIN_PASSWORD_LENGTH,
widget=forms.PasswordInput,
)
def __init__(self, user, *args, **kwargs):
super(ChangePasswordForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_class = 'content-wrapper'
self.helper.form_method = 'post'
self.user = user
self.helper.layout = Layout(
Field('password_old'),
Field('password_new'),
Field('password_confirm'),
ButtonHolder(
StrictButton(_(u'Enregistrer'), type='submit'),
)
)
def clean(self):
cleaned_data = super(ChangePasswordForm, self).clean()
password_old = cleaned_data.get('password_old')
password_new = cleaned_data.get('password_new')
password_confirm = cleaned_data.get('password_confirm')
# TODO: mutualizes these rules with registration ones?
# Check if the actual password is not empty
if password_old:
user_exist = authenticate(
username=self.user.username, password=password_old
)
# Check if the user exist with old informations.
if not user_exist and password_old != "":
self._errors['password_old'] = self.error_class(
[_(u'Mot de passe incorrect.')])
if 'password_old' in cleaned_data:
del cleaned_data['password_old']
# Check that the password and it's confirmation match
if not password_confirm == password_new:
msg = _(u'Les mots de passe sont différents.')
self._errors['password_new'] = self.error_class([msg])
self._errors['password_confirm'] = self.error_class([msg])
if 'password_new' in cleaned_data:
del cleaned_data['password_new']
if 'password_confirm' in cleaned_data:
del cleaned_data['password_confirm']
# Check that password != username
if password_new == self.user.username:
msg = _(u'Le mot de passe doit être différent de votre pseudo')
self._errors['password_new'] = self.error_class([msg])
if 'password_new' in cleaned_data:
del cleaned_data['password_new']
if 'password_confirm' in cleaned_data:
del cleaned_data['password_confirm']
return cleaned_data
class UsernameAndEmailForm(forms.Form):
username = forms.CharField(
label=_(u'Nom d\'utilisateur'),
required=False
)
email = forms.CharField(
label=_(u'Adresse de courriel'),
required=False
)
def __init__(self, *args, **kwargs):
super(UsernameAndEmailForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_class = 'content-wrapper'
self.helper.form_method = 'post'
self.helper.layout = Layout(
Div(
Field('username'),
ButtonHolder(
StrictButton(_(u'Envoyer'), type='submit'),
),
css_id='form-username'
),
Div(
Field('email'),
ButtonHolder(
StrictButton(_(u'Envoyer'), type='submit'),
),
css_id='form-email'
)
)
def clean(self):
cleaned_data = super(UsernameAndEmailForm, self).clean()
# Clean data
username = cleaned_data.get('username')
email = cleaned_data.get('email')
# Check that the username or the email is filled
if (username and email) or (not username and not email):
if username and email:
self._errors['username'] = self.error_class([_(u'Les deux champs ne doivent pas être rempli. '
u'Remplissez soit l\'adresse de courriel soit le '
u'nom d\'utilisateur')])
else:
self._errors['username'] = self.error_class([_(u'Il vous faut remplir au moins un des deux champs')])
else:
# Check if the user exist
if username:
if User.objects.filter(Q(username=username)).count() == 0:
self._errors['username'] = self.error_class([_(u'Ce nom d\'utilisateur n\'existe pas')])
if email:
if User.objects.filter(Q(email=email)).count() == 0:
self._errors['email'] = self.error_class([_(u'Cette adresse de courriel n\'existe pas')])
return cleaned_data
class NewPasswordForm(forms.Form):
"""
Defines a new password (when the current one has been forgotten)
"""
password = forms.CharField(
label=_(u'Mot de passe'),
max_length=MAX_PASSWORD_LENGTH,
min_length=MIN_PASSWORD_LENGTH,
widget=forms.PasswordInput
)
password_confirm = forms.CharField(
label=_(u'Confirmation'),
max_length=MAX_PASSWORD_LENGTH,
min_length=MIN_PASSWORD_LENGTH,
widget=forms.PasswordInput
)
def __init__(self, identifier, *args, **kwargs):
super(NewPasswordForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_class = 'content-wrapper'
self.helper.form_method = 'post'
self.username = identifier
self.helper.layout = Layout(
Field('password'),
Field('password_confirm'),
ButtonHolder(
StrictButton(_(u'Envoyer'), type='submit'),
)
)
def clean(self):
cleaned_data = super(NewPasswordForm, self).clean()
# Check that the password and it's confirmation match
password = cleaned_data.get('password')
password_confirm = cleaned_data.get('password_confirm')
# TODO: mutualizes these rules with registration ones?
if not password_confirm == password:
msg = _(u'Les mots de passe sont différents')
self._errors['password'] = self.error_class([''])
self._errors['password_confirm'] = self.error_class([msg])
if 'password' in cleaned_data:
del cleaned_data['password']
if 'password_confirm' in cleaned_data:
del cleaned_data['password_confirm']
# Check that password != username
if password == self.username:
msg = _(u'Le mot de passe doit être différent de votre pseudo')
self._errors['password'] = self.error_class([msg])
if 'password' in cleaned_data:
del cleaned_data['password']
if 'password_confirm' in cleaned_data:
del cleaned_data['password_confirm']
return cleaned_data
class PromoteMemberForm(forms.Form):
"""
Promotes a user to an arbitrary group
"""
groups = forms.ModelMultipleChoiceField(
label=_(u"Groupe de l'utilisateur"),
queryset=Group.objects.all(),
required=False,
)
superuser = forms.BooleanField(
label=_(u"Super-user"),
required=False,
)
activation = forms.BooleanField(
label=_(u"Compte actif"),
required=False,
)
def __init__(self, *args, **kwargs):
super(PromoteMemberForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_class = 'content-wrapper'
self.helper.form_method = 'post'
self.helper.layout = Layout(
Field('groups'),
Field('superuser'),
Field('activation'),
StrictButton(_(u'Valider'), type='submit'),
)
class KarmaForm(forms.Form):
warning = forms.CharField(
label=_(u"Commentaire"),
max_length=KarmaNote._meta.get_field('comment').max_length,
widget=forms.TextInput(
attrs={
'placeholder': u'Commentaire sur le comportement de ce membre'
}),
required=True,
)
points = forms.IntegerField(
max_value=100,
min_value=-100,
initial=0,
required=False,
)
def __init__(self, profile, *args, **kwargs):
super(KarmaForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_action = reverse('member.views.modify_karma')
self.helper.form_method = 'post'
self.helper.layout = Layout(
Field('warning'),
Field('points'),
Hidden('profile_pk', '{{ profile.pk }}'),
ButtonHolder(
StrictButton(u'Valider', type='submit'),
),
) | zds-member | /zds-member-0.1.5.tar.gz/zds-member-0.1.5/member/forms.py | forms.py |
from __future__ import unicode_literals
from django.db import models, migrations
from member.conf import settings
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='Ban',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('type', models.CharField(max_length=80, verbose_name=b'Type', db_index=True)),
('text', models.TextField(verbose_name=b'Explication de la sanction')),
('pubdate', models.DateTimeField(db_index=True, null=True, verbose_name=b'Date de publication', blank=True)),
('moderator', models.ForeignKey(related_name='bans', verbose_name=b'Moderateur', to=settings.AUTH_USER_MODEL)),
('user', models.ForeignKey(verbose_name=b'Sanctionn\xc3\xa9', to=settings.AUTH_USER_MODEL)),
],
options={
'verbose_name': 'Sanction',
'verbose_name_plural': 'Sanctions',
},
bases=(models.Model,),
),
migrations.CreateModel(
name='KarmaNote',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('comment', models.CharField(max_length=150, verbose_name=b'Commentaire')),
('value', models.IntegerField(verbose_name=b'Valeur')),
('create_at', models.DateTimeField(auto_now_add=True, verbose_name=b"Date d'ajout")),
('staff', models.ForeignKey(related_name='karmanote_staff', to=settings.AUTH_USER_MODEL)),
('user', models.ForeignKey(related_name='karmanote_user', to=settings.AUTH_USER_MODEL)),
],
options={
'verbose_name': 'Note de karma',
'verbose_name_plural': 'Notes de karma',
},
bases=(models.Model,),
),
migrations.CreateModel(
name='Profile',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('last_ip_address', models.CharField(max_length=39, null=True, verbose_name=b'Adresse IP', blank=True)),
('site', models.CharField(max_length=128, verbose_name=b'Site internet', blank=True)),
('show_email', models.BooleanField(default=False, verbose_name=b'Afficher adresse mail publiquement')),
('avatar_url', models.CharField(max_length=128, null=True, verbose_name=b"URL de l'avatar", blank=True)),
('biography', models.TextField(verbose_name=b'Biographie', blank=True)),
('karma', models.IntegerField(default=0, verbose_name=b'Karma')),
('sign', models.TextField(max_length=250, verbose_name=b'Signature', blank=True)),
('show_sign', models.BooleanField(default=True, verbose_name=b'Voir les signatures')),
('hover_or_click', models.BooleanField(default=False, verbose_name=b'Survol ou click ?')),
('email_for_answer', models.BooleanField(default=False, verbose_name=b'Envoyer pour les r\xc3\xa9ponse MP')),
('sdz_tutorial', models.TextField(null=True, verbose_name=b'Identifiant des tutos SdZ', blank=True)),
('can_read', models.BooleanField(default=True, verbose_name=b'Possibilit\xc3\xa9 de lire')),
('end_ban_read', models.DateTimeField(null=True, verbose_name=b"Fin d'interdiction de lecture", blank=True)),
('can_write', models.BooleanField(default=True, verbose_name=b"Possibilit\xc3\xa9 d'\xc3\xa9crire")),
('end_ban_write', models.DateTimeField(null=True, verbose_name=b"Fin d'interdiction d'ecrire", blank=True)),
('last_visit', models.DateTimeField(null=True, verbose_name=b'Date de derni\xc3\xa8re visite', blank=True)),
('user', models.OneToOneField(related_name='profile', verbose_name=b'Utilisateur', to=settings.AUTH_USER_MODEL)),
],
options={
'verbose_name': 'Profil',
'verbose_name_plural': 'Profils',
'permissions': (('moderation', 'Mod\xe9rer un membre'), ('show_ip', "Afficher les IP d'un membre")),
},
bases=(models.Model,),
),
migrations.CreateModel(
name='TokenForgotPassword',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('token', models.CharField(max_length=100, db_index=True)),
('date_end', models.DateTimeField(verbose_name=b'Date de fin')),
('user', models.ForeignKey(verbose_name=b'Utilisateur', to=settings.AUTH_USER_MODEL)),
],
options={
'verbose_name': 'Token de mot de passe oubli\xe9',
'verbose_name_plural': 'Tokens de mots de passe oubli\xe9s',
},
bases=(models.Model,),
),
migrations.CreateModel(
name='TokenRegister',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('token', models.CharField(max_length=100, db_index=True)),
('date_end', models.DateTimeField(verbose_name=b'Date de fin')),
('user', models.ForeignKey(verbose_name=b'Utilisateur', to=settings.AUTH_USER_MODEL)),
],
options={
'verbose_name': "Token d'inscription",
'verbose_name_plural': "Tokens d'inscription",
},
bases=(models.Model,),
),
] | zds-member | /zds-member-0.1.5.tar.gz/zds-member-0.1.5/member/migrations/0001_initial.py | 0001_initial.py |
from __future__ import unicode_literals
from django.db import migrations, models
from django.conf import settings
class Migration(migrations.Migration):
dependencies = [
('member', '0002_auto_20150601_1144'),
]
operations = [
migrations.AlterModelOptions(
name='profile',
options={'verbose_name': 'Profil', 'verbose_name_plural': 'Profils', 'permissions': (('moderation', 'Moderate membre'), ('show_ip', "Show member's Ip Adress"))},
),
migrations.RemoveField(
model_name='profile',
name='sdz_tutorial',
),
migrations.AlterField(
model_name='profile',
name='avatar_url',
field=models.CharField(max_length=2000, null=True, verbose_name=b'Avatar url', blank=True),
),
migrations.AlterField(
model_name='profile',
name='biography',
field=models.TextField(verbose_name=b'Biography', blank=True),
),
migrations.AlterField(
model_name='profile',
name='hover_or_click',
field=models.BooleanField(default=False, verbose_name=b'Hover or clic ?'),
),
migrations.AlterField(
model_name='profile',
name='last_ip_address',
field=models.CharField(max_length=39, null=True, verbose_name=b'IP Adress', blank=True),
),
migrations.AlterField(
model_name='profile',
name='show_email',
field=models.BooleanField(default=False, verbose_name=b'Show email adress on public'),
),
migrations.AlterField(
model_name='profile',
name='show_sign',
field=models.BooleanField(default=True, verbose_name=b'Show signs'),
),
migrations.AlterField(
model_name='profile',
name='sign',
field=models.TextField(max_length=250, verbose_name=b'Sign', blank=True),
),
migrations.AlterField(
model_name='profile',
name='site',
field=models.CharField(max_length=2000, verbose_name=b'Web site', blank=True),
),
migrations.AlterField(
model_name='profile',
name='user',
field=models.OneToOneField(related_name='profile', verbose_name=b'User', to=settings.AUTH_USER_MODEL),
),
] | zds-member | /zds-member-0.1.5.tar.gz/zds-member-0.1.5/member/migrations/0003_auto_20151022_0719.py | 0003_auto_20151022_0719.py |
from datetime import timedelta
from django import template
from django.contrib.humanize.templatetags.humanize import naturaltime
from django.template.defaultfilters import date
from django.utils.datetime_safe import datetime
from django.utils.tzinfo import LocalTimezone
register = template.Library()
"""
Define a filter to format date.
"""
# Date formatting constants
__DATE_FMT_FUTUR = "Dans le futur"
__ABS_DATE_FMT_SMALL = r'd/m/y à H\hi' # Small format
__ABS_DATE_FMT_NORMAL = r'l d F Y à H\hi' # Normal format
__ABS_HUMAN_TIME_FMT = "%d %b %Y, %H:%M:%S"
def date_formatter(value, tooltip, small):
"""
Format a date to an human readable string.
:param value: Date to format.
:param bool tooltip: if `True`, format date to a tooltip label.
:param bool small: if `True`, create a shorter string.
:return:
"""
try:
value = datetime(value.year, value.month, value.day,
value.hour, value.minute, value.second)
except (AttributeError, ValueError):
# todo : Check why not raise template.TemplateSyntaxError() ?
return value
if getattr(value, 'tzinfo', None):
now = datetime.now(LocalTimezone(value))
else:
now = datetime.now()
now = now - timedelta(microseconds=now.microsecond)
if value > now:
return __DATE_FMT_FUTUR
else:
delta = now - value
# Natural time for today, absolute date after.
# Reverse if in tooltip
if (delta.days == 0) != tooltip:
return naturaltime(value)
else:
return date(value, __ABS_DATE_FMT_SMALL if small else __ABS_DATE_FMT_NORMAL)
@register.filter
def format_date(value, small=False):
"""Format a date to an human readable string."""
return date_formatter(value, tooltip=False, small=small)
@register.filter
def tooltip_date(value):
"""Format a date to an human readable string. To be used in tooltip."""
return date_formatter(value, tooltip=True, small=False)
@register.filter
def humane_time(timestamp, tz_offset=0):
"""Render time (number of second from epoch) to an human readable string"""
return format_date(datetime.utcfromtimestamp(timestamp - tz_offset)) | zds-member | /zds-member-0.1.5.tar.gz/zds-member-0.1.5/member/templatetags/date.py | date.py |
from django import template
from django.utils.safestring import mark_safe
from django.utils.translation import ugettext_lazy as _
from markdown import Markdown
from markdown.extensions.zds import ZdsExtension
from member.templatetags.smileys_def import smileys
register = template.Library()
"""
Markdown related filters.
"""
# Constant strings
__MD_ERROR_PARSING = _(u'Une erreur est survenue dans la génération de texte Markdown. Veuillez rapporter le bug.')
def get_markdown_instance(inline=False, js_support=False):
"""
Provide a pre-configured markdown parser.
:param bool inline: If `True`, configure parser to parse only inline content.
:return: A ZMarkdown parser.
"""
zdsext = ZdsExtension(inline=inline, emoticons=smileys, js_support=js_support)
# Generate parser
markdown = Markdown(
extensions=(zdsext,),
safe_mode='escape', # Protect use of html by escape it
inline=inline, # Parse only inline content.
enable_attributes=False, # Disable the conversion of attributes.
# This could potentially allow an untrusted user to inject JavaScript into documents.
tab_length=4, # Length of tabs in the source (default value).
output_format='html5', # HTML5 output (default value).
smart_emphasis=True, # Enable smart emphasis for underscore syntax
lazy_ol=True, # Enable smart ordered list start support
)
return markdown
def render_markdown(text, inline=False, js_support=False):
"""
Render a markdown text to html.
:param str text: Text to render.
:param bool inline: If `True`, parse only inline content.
:param bool js_support: Enable JS in generated html.
:return: Equivalent html string.
:rtype: str
"""
return get_markdown_instance(inline=inline, js_support=js_support).convert(text).encode('utf-8').strip()
@register.filter(needs_autoescape=False)
def emarkdown(text, use_jsfiddle=''):
"""
Filter markdown text and render it to html.
:param str text: Text to render.
:return: Equivalent html string.
:rtype: str
"""
is_js = (use_jsfiddle == 'js')
try:
return mark_safe(render_markdown(text, inline=False, js_support=is_js))
except:
return mark_safe(u'<div class="error ico-after"><p>{}</p></div>'.format(__MD_ERROR_PARSING))
@register.filter(needs_autoescape=False)
def emarkdown_inline(text):
"""
Filter markdown text and render it to html. Only inline elements will be parsed.
:param str text: Text to render.
:return: Equivalent html string.
:rtype: str
"""
try:
return mark_safe(render_markdown(text, inline=True))
except:
return mark_safe(u'<p>{}</p>'.format(__MD_ERROR_PARSING)) | zds-member | /zds-member-0.1.5.tar.gz/zds-member-0.1.5/member/templatetags/emarkdown.py | emarkdown.py |
from rest_framework import filters
from rest_framework import status
from rest_framework.generics import ListCreateAPIView, RetrieveUpdateAPIView, RetrieveAPIView, get_object_or_404
from rest_framework.permissions import IsAuthenticatedOrReadOnly, AllowAny, IsAuthenticated
from rest_framework.response import Response
from rest_framework_extensions.cache.decorators import cache_response
from rest_framework_extensions.etag.decorators import etag
from rest_framework_extensions.key_constructor import bits
from rest_framework_extensions.key_constructor.constructors import DefaultKeyConstructor
from member.utils.api.DJRF3xPaginationKeyBit import DJRF3xPaginationKeyBit
from member.api.serializers import ProfileListSerializer, ProfileCreateSerializer, \
ProfileDetailSerializer, ProfileValidatorSerializer
from member.api.permissions import IsOwnerOrReadOnly
from member.api.generics import CreateDestroyMemberSanctionAPIView
from member.commons import TemporaryReadingOnlySanction, ReadingOnlySanction, \
DeleteReadingOnlySanction, TemporaryBanSanction, BanSanction, DeleteBanSanction, \
ProfileCreate, TokenGenerator
from member.models import Profile
class PagingSearchListKeyConstructor(DefaultKeyConstructor):
pagination = DJRF3xPaginationKeyBit()
search = bits.QueryParamsKeyBit(['search'])
list_sql_query = bits.ListSqlQueryKeyBit()
unique_view_id = bits.UniqueViewIdKeyBit()
class DetailKeyConstructor(DefaultKeyConstructor):
format = bits.FormatKeyBit()
language = bits.LanguageKeyBit()
retrieve_sql_query = bits.RetrieveSqlQueryKeyBit()
unique_view_id = bits.UniqueViewIdKeyBit()
class MyDetailKeyConstructor(DefaultKeyConstructor):
format = bits.FormatKeyBit()
language = bits.LanguageKeyBit()
class MemberListAPI(ListCreateAPIView, ProfileCreate, TokenGenerator):
"""
Profile resource to list and register.
"""
queryset = Profile.objects.all_members_ordered_by_date_joined()
filter_backends = (filters.SearchFilter,)
search_fields = ('user__username',)
list_key_func = PagingSearchListKeyConstructor()
@etag(list_key_func)
@cache_response(key_func=list_key_func)
def get(self, request, *args, **kwargs):
"""
Lists all users in the system.
---
parameters:
- name: page
description: Displays users of the page given.
required: false
paramType: query
- name: page_size
description: Sets size of the pagination.
required: false
paramType: query
- name: search
description: Makes a search on the username.
required: false
paramType: query
responseMessages:
- code: 404
message: Not found
"""
return self.list(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
"""
Registers a new user in the system. The user must confirm its registration.
---
responseMessages:
- code: 400
message: Bad Request
"""
self.permission_classes = (AllowAny,)
serializer = self.get_serializer_class()(data=request.data)
serializer.is_valid(raise_exception=True)
profile = serializer.save()
token = self.generate_token(profile.user)
self.send_email(token, profile.user)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
def get_serializer_class(self):
if self.request.method == 'GET':
return ProfileListSerializer
elif self.request.method == 'POST':
return ProfileCreateSerializer
class MemberMyDetailAPI(RetrieveAPIView):
"""
Profile resource to display details of the member.
"""
obj_key_func = MyDetailKeyConstructor()
permission_classes = (IsAuthenticated,)
serializer_class = ProfileDetailSerializer
@etag(obj_key_func)
@cache_response(key_func=obj_key_func)
def get(self, request, *args, **kwargs):
"""
Gets information of his account.
---
parameters:
- name: Authorization
description: Bearer token to make a authenticated request.
required: true
paramType: header
responseMessages:
- code: 401
message: Not authenticated
"""
profile = self.get_object()
serializer = self.get_serializer(profile,
show_email=True,
is_authenticated=True)
return Response(serializer.data)
def get_object(self):
return get_object_or_404(Profile, user=self.request.user)
class MemberDetailAPI(RetrieveUpdateAPIView):
"""
Profile resource to display or update details of a member.
"""
queryset = Profile.objects.all()
obj_key_func = DetailKeyConstructor()
@etag(obj_key_func)
@cache_response(key_func=obj_key_func)
def get(self, request, *args, **kwargs):
"""
Gets a user given by its identifier.
---
parameters:
- name: Authorization
description: Bearer token to make a authenticated request.
required: false
paramType: header
responseMessages:
- code: 404
message: Not found
"""
profile = self.get_object()
serializer = self.get_serializer(profile,
show_email=profile.show_email,
is_authenticated=self.request.user.is_authenticated())
return Response(serializer.data)
@etag(obj_key_func, rebuild_after_method_evaluation=True)
def put(self, request, *args, **kwargs):
"""
Updates a user given by its identifier.
---
parameters:
- name: Authorization
description: Bearer token to make a authenticated request.
required: true
paramType: header
responseMessages:
- code: 400
message: Bad Request
- code: 401
message: Not authenticated
- code: 403
message: Insufficient rights to call this procedure. Source and target user must to be equals.
- code: 404
message: Not found
"""
self.permission_classes = (IsAuthenticatedOrReadOnly, IsOwnerOrReadOnly)
return self.update(request, *args, **kwargs)
def get_serializer_class(self):
if self.request.method == 'GET':
return ProfileDetailSerializer
elif self.request.method == 'PUT':
return ProfileValidatorSerializer
class MemberDetailReadingOnly(CreateDestroyMemberSanctionAPIView):
"""
Profile resource to apply or remove read only sanction.
"""
def post(self, request, *args, **kwargs):
"""
Applies a read only sanction at a user given.
---
parameters:
- name: Authorization
description: Bearer token to make a authenticated request.
required: true
paramType: header
- name: ls-jrs
description: Number of days for the sanction.
required: false
paramType: form
- name: ls-text
description: Description of the sanction.
required: false
paramType: form
omit_parameters:
- body
responseMessages:
- code: 401
message: Not authenticated
- code: 403
message: Insufficient rights to call this procedure. Must to be a staff user.
- code: 404
message: Not found
"""
return super(MemberDetailReadingOnly, self).post(request, args, kwargs)
def delete(self, request, *args, **kwargs):
"""
Removes a read only sanction at a user given.
---
parameters:
- name: Authorization
description: Bearer token to make a authenticated request.
required: true
paramType: header
responseMessages:
- code: 401
message: Not authenticated
- code: 403
message: Insufficient rights to call this procedure. Must to be a staff user.
- code: 404
message: Not found
"""
return super(MemberDetailReadingOnly, self).delete(request, args, kwargs)
def get_state_instance(self, request):
if request.method == 'POST':
if 'ls-jrs' in request.POST:
return TemporaryReadingOnlySanction(request.POST)
else:
return ReadingOnlySanction(request.POST)
elif request.method == 'DELETE':
return DeleteReadingOnlySanction(request.POST)
raise ValueError('Method {0} is not supported in this route of the API.'.format(request.method))
class MemberDetailBan(CreateDestroyMemberSanctionAPIView):
"""
Profile resource to apply or remove ban sanction.
"""
def post(self, request, *args, **kwargs):
"""
Applies a ban sanction at a user given.
---
parameters:
- name: Authorization
description: Bearer token to make a authenticated request.
required: true
paramType: header
- name: ban-jrs
description: Number of days for the sanction.
required: false
paramType: form
- name: ban-text
description: Description of the sanction.
required: false
paramType: form
omit_parameters:
- body
responseMessages:
- code: 401
message: Not authenticated
- code: 403
message: Insufficient rights to call this procedure. Must to be a staff user.
- code: 404
message: Not found
"""
return super(MemberDetailBan, self).post(request, args, kwargs)
def delete(self, request, *args, **kwargs):
"""
Removes a ban sanction at a user given.
---
parameters:
- name: Authorization
description: Bearer token to make a authenticated request.
required: true
paramType: header
responseMessages:
- code: 401
message: Not authenticated
- code: 403
message: Insufficient rights to call this procedure. Must to be a staff user.
- code: 404
message: Not found
"""
return super(MemberDetailBan, self).delete(request, args, kwargs)
def get_state_instance(self, request):
if request.method == 'POST':
if 'ban-jrs' in request.POST:
return TemporaryBanSanction(request.POST)
else:
return BanSanction(request.POST)
elif request.method == 'DELETE':
return DeleteBanSanction(request.POST)
raise ValueError('Method {0} is not supported in this route of the API.'.format(request.method)) | zds-member | /zds-member-0.1.5.tar.gz/zds-member-0.1.5/member/api/views.py | views.py |
from member.conf import settings
from rest_framework import status
from rest_framework.generics import CreateAPIView, DestroyAPIView
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from member.api.permissions import IsStaffUser
from member.api.serializers import ProfileSanctionSerializer
from member.models import Profile
class CreateDestroyMemberSanctionAPIView(CreateAPIView, DestroyAPIView):
"""
Generic view used by the API about sanctions.
"""
queryset = Profile.objects.all()
serializer_class = ProfileSanctionSerializer
permission_classes = (IsAuthenticated, IsStaffUser)
def post(self, request, *args, **kwargs):
return self.process_request(request)
def delete(self, request, *args, **kwargs):
return self.process_request(request)
def process_request(self, request):
instance = self.get_object()
serializer = self.serializer_class(instance, data=request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
state = self.get_state_instance(request)
ban = state.get_sanction(request.user, instance.user)
if ban.user == ban.moderator:
return Response({u'detail': u'Sanction can not be applied to yourself.'},
status=status.HTTP_403_FORBIDDEN)
try:
state.apply_sanction(instance, ban)
except ValueError:
return Response({u'detail': u'Sanction could not be applied with received data.'},
status=status.HTTP_400_BAD_REQUEST)
msg = state.get_message_sanction() \
.format(ban.user,
ban.moderator,
ban.type,
state.get_detail(),
ban.text,
settings.APP_SITE['litteral_name'])
state.notify_member(ban, msg)
return Response(serializer.data)
def get_state_instance(self, request):
raise NotImplementedError('`get_state_instance()` must be implemented.') | zds-member | /zds-member-0.1.5.tar.gz/zds-member-0.1.5/member/api/generics.py | generics.py |
from django.contrib.auth.models import User
from rest_framework import serializers
from member.commons import ProfileCreate
from member.models import Profile
from member.validators import ProfileUsernameValidator, ProfileEmailValidator
class UserListSerializer(serializers.ModelSerializer):
"""
Serializers of a user object.
"""
class Meta:
model = User
fields = ('id', 'username', 'is_active', 'date_joined')
class ProfileListSerializer(serializers.ModelSerializer):
"""
Serializers of a user object.
"""
username = serializers.CharField(source='user.username')
is_active = serializers.BooleanField(source='user.is_active')
date_joined = serializers.DateTimeField(source='user.date_joined')
class Meta:
model = Profile
fields = ('pk', 'username', 'is_active', 'date_joined')
class ProfileCreateSerializer(serializers.ModelSerializer, ProfileCreate, ProfileUsernameValidator,
ProfileEmailValidator):
"""
Serializers of a user object to create one.
"""
username = serializers.CharField(source='user.username')
email = serializers.EmailField(source='user.email')
password = serializers.CharField(source='user.password')
class Meta:
model = Profile
fields = ('pk', 'username', 'email', 'password')
write_only_fields = ('password')
def create(self, validated_data):
profile = self.create_profile(validated_data.get('user'))
self.save_profile(profile)
return profile
def throw_error(self, key=None, message=None):
raise serializers.ValidationError(message)
class ProfileDetailSerializer(serializers.ModelSerializer):
"""
Serializers of a profile object.
"""
username = serializers.CharField(source='user.username')
email = serializers.EmailField(source='user.email')
is_active = serializers.BooleanField(source='user.is_active')
date_joined = serializers.DateTimeField(source='user.date_joined')
avatar_url = serializers.CharField(source='get_avatar_url')
class Meta:
model = Profile
fields = ('pk', 'username', 'email', 'is_active', 'date_joined',
'site', 'avatar_url', 'biography', 'sign', 'show_email',
'show_sign', 'hover_or_click', 'email_for_answer', 'last_visit')
def __init__(self, *args, **kwargs):
"""
Create the serializer with or without email field, depending on the show_email argument.
"""
show_email = kwargs.pop('show_email', False)
is_authenticated = kwargs.pop('is_authenticated', False)
super(ProfileDetailSerializer, self).__init__(*args, **kwargs)
if not show_email or not is_authenticated:
# Drop email field.
self.fields.pop('email')
class ProfileValidatorSerializer(serializers.ModelSerializer, ProfileUsernameValidator, ProfileEmailValidator):
"""
Serializers of a profile object used to update a member.
"""
username = serializers.CharField(source='user.username', required=False, allow_blank=True)
email = serializers.EmailField(source='user.email', required=False, allow_blank=True)
is_active = serializers.BooleanField(source='user.is_active', required=False)
date_joined = serializers.DateTimeField(source='user.date_joined', required=False)
class Meta:
model = Profile
fields = ('pk', 'username', 'email', 'is_active', 'date_joined',
'site', 'avatar_url', 'biography', 'sign', 'show_email',
'show_sign', 'hover_or_click', 'email_for_answer', 'last_visit')
read_only_fields = ('is_active', 'date_joined', 'last_visit',)
def update(self, instance, validated_data):
"""
Update and return an existing `Profile` instance, given the validated data.
"""
if validated_data.get('user') is not None:
instance.user.username = validated_data.get('user').get('username', instance.user.username)
instance.user.email = validated_data.get('user').get('email', instance.user.email)
instance.site = validated_data.get('site', instance.site) or instance.site
instance.avatar_url = validated_data.get('avatar_url', instance.avatar_url) or instance.avatar_url
instance.biography = validated_data.get('biography', instance.biography) or instance.biography
instance.sign = validated_data.get('sign', instance.sign) or instance.sign
if validated_data.get('show_email', instance.show_email) != instance.show_email:
instance.show_email = validated_data.get('show_email', instance.show_email)
if validated_data.get('show_sign', instance.show_sign) != instance.show_sign:
instance.show_sign = validated_data.get('show_sign', instance.show_sign)
if validated_data.get('hover_or_click', instance.hover_or_click) != instance.hover_or_click:
instance.hover_or_click = validated_data.get('hover_or_click', instance.hover_or_click)
if validated_data.get('email_for_answer', instance.email_for_answer) != instance.email_for_answer:
instance.email_for_answer = validated_data.get('email_for_answer', instance.email_for_answer)
instance.user.save()
instance.save()
return instance
def throw_error(self, key=None, message=None):
raise serializers.ValidationError(message)
class ProfileSanctionSerializer(serializers.ModelSerializer):
"""
Serializers of a profile object to set the user in reading only access.
"""
username = serializers.ReadOnlyField(source='user.username')
email = serializers.ReadOnlyField(source='user.email')
class Meta:
model = Profile
fields = ('pk', 'username', 'email', 'can_write', 'end_ban_write', 'can_read', 'end_ban_read')
read_only_fields = ('can_write', 'end_ban_write', 'can_read', 'end_ban_read') | zds-member | /zds-member-0.1.5.tar.gz/zds-member-0.1.5/member/api/serializers.py | serializers.py |
from django.views.generic import ListView
from django.views.generic.list import MultipleObjectMixin
from django.core.paginator import Paginator, EmptyPage
from django.http import Http404
from member.conf import settings
ZDS_MEMBER = settings.ZDS_MEMBER
ZDS_MEMBER_SETTINGS = settings.ZDS_MEMBER_SETTINGS
class ZdSPagingListView(ListView):
paginator = None
page = 1
def get_context_data(self, **kwargs):
"""
Get the context for this view. This method is surcharged to modify the paginator
and information given at the template.
"""
queryset = kwargs.pop('object_list', self.object_list)
page_size = self.get_paginate_by(queryset)
context_object_name = self.get_context_object_name(queryset)
self.paginator, self.page, queryset, is_paginated = self.paginate_queryset(queryset, page_size)
if page_size:
context = {
'paginator': self.paginator,
'page_obj': self.page,
'is_paginated': is_paginated,
'object_list': queryset,
'pages': paginator_range(self.page.number, self.paginator.num_pages),
}
else:
context = {
'paginator': None,
'page_obj': None,
'is_paginated': False,
'object_list': queryset,
'pages': [],
}
if context_object_name is not None:
context[context_object_name] = queryset
context.update(kwargs)
return super(MultipleObjectMixin, self).get_context_data(**context)
def build_list_with_previous_item(self, queryset):
"""
For some list paginated, we would like to display the last item of the previous page.
This function returns the list paginated with this previous item.
"""
original_list = queryset.all()
items_list = []
# If necessary, add the last item in the previous page.
if self.page.number != 1:
last_page = self.paginator.page(self.page.number - 1).object_list
last_item = (last_page)[len(last_page) - 1]
items_list.append(last_item)
# Adds all items of the list paginated.
for item in original_list:
items_list.append(item)
return items_list
def paginator_range(current, stop, start=1):
assert current <= stop
# Basic case when no folding
if stop - start <= ZDS_MEMBER_SETTINGS['paginator']['folding_limit']:
return range(start, stop + 1)
# Complex case when folding
lst = []
for page_number in range(start, stop + 1):
# Bounds
if page_number == start or page_number == stop:
lst.append(page_number)
if page_number == start and current - start > 2:
lst.append(None)
# Neighbors
elif abs(page_number - current) == 1:
lst.append(page_number)
if page_number - current > 0 and stop - page_number > 2:
lst.append(None)
# Current
elif page_number == current:
lst.append(page_number)
# Put some
elif page_number == stop - 1 and current == stop - 3:
lst.append(page_number)
# And ignore all other numbers
return lst
def make_pagination(
context, request, queryset_objs, page_size, context_list_name='object_list', with_previous_item=False):
"""This function will fill the context to use it for the paginator template, usefull if you cannot use
`ZdSPagingListView`.
Note that `/templates/misc/paginator.html` expect the following variables to be defined:
- `paginator`: a valid `Paginator` object
- `page_obj` : `QuerySet` object, portion of the `object_list`
- `pages`: results from `paginator_range()`
:param context: context
:param request: page request
:param queryset_objs: objects to paginate
:param page_size: number of objects in a pages (last one from previous page not included!)
:param context_list_name: control the name of the list object in the context
:param with_previous_item: if `True`, will include the last object of the previous page to the list of shown objects
"""
paginator = Paginator(queryset_objs, page_size)
# retrieve page number
if "page" in request.GET and request.GET["page"].isdigit():
page_number = int(request.GET["page"])
elif "page" not in request.GET:
page_number = 1
else:
raise Http404
try:
page_obj = paginator.page(page_number)
except EmptyPage:
raise Http404
page_objects_list = page_obj.object_list
if page_number != 1 and with_previous_item:
new_list = []
last_page = paginator.page(page_obj.number - 1).object_list
last_item = last_page[len(last_page) - 1]
new_list.append(last_item)
for item in page_objects_list:
new_list.append(item)
page_objects_list = new_list
# fill context
context['paginator'] = paginator
context['page_obj'] = page_obj
context['pages'] = paginator_range(page_number, paginator.num_pages)
context[context_list_name] = page_objects_list | zds-member | /zds-member-0.1.5.tar.gz/zds-member-0.1.5/member/utils/paginator.py | paginator.py |
====================================
ZDS-Schema - Schema-generatietooling
====================================
ZDS-Schema voorziet een generieke API schema-generatiestrategie die gedeeld
wordt tussen verschillende componenten betrokken in zaakgericht werken.
.. contents::
.. section-numbering::
Features
========
* Centraal beheer van cosntanten die de verschillende componenten overstijgen
* GeoJSON OpenAPI definities
* Support voor Geo CRS negotation
* Ingebouwde support voor nested viewsets met declaratievere syntax voor
registratie
* Vaak voorkomende validators:
* RSIN/BSN validator
* Numerieke waarde validator
* Niet-negatieve waarde validator
* Alfanumerieke waarde (zonder diacritics)
* URL-validator (test dat URL bestaat) met pluggable link-checker
* ``UntilNowValidator`` - valideer datetimes tot en met *nu*.
* ``UniekeIdentificatieValidator`` (in combinatie met organisatie)
* ``InformatieObjectUniqueValidator`` om te valideren dat M2M entries
slechts eenmalig voorkomen
* ``ObjectInformatieObjectValidator`` om te valideren dat de synchronisatie
van een object-informatieobject relatie pas kan nadat deze relatie in het
DRC gemaakt is
* ``IsImmutableValidator`` - valideer dat bepaalde velden niet gewijzigd
worden bij een (partial) update, maar wel mogen gezet worden bij een create
* ``ResourceValidator`` - valideer dat een URL een bepaalde resource ontsluit
* Custom inspectors voor drf-yasg:
* Support voor ``rest_framework_gis`` ``GeometryField``
* SUpport voor ``django-extra-fields`` ``Base64FieldMixin``
* URL-based related resource filtering (``django-filter`` support)
* verzameling van mogelijke error-responses per operation
* Management command ``generate_swagger`` overloaded
* neemt default versie mee en maakt server-informatie domein-agnostisch
* optie om informatiemodel-resources naar markdown te renderen met backlinks
naar gemmaonline.nl
* Support voor ISO 8601 durations
* Custom model fields:
* ``RSINField``
* ``BSNField``
* ``LanguageField``
* ``VertrouwelijkheidsAanduidingField``
* ``DaysDurationField``
* Mocks voor de validators die netwerk IO hebben, eenvoudig via
``@override_settings`` toe te passen
Installatie
===========
Benodigdheden
-------------
* Python 3.6 of hoger
* setuptools 30.3.0 of higher
Installeren
-----------
.. code-block:: bash
pip install zds_schema
Gebruik
=======
Zie de referentie-implementaties voor `ZRC`_, `DRC`_, `BRC`_ en `ZTC`_.
.. _ZRC: https://github.com/VNG-Realisatie/gemma-zaakregistratiecomponent
.. _DRC: https://github.com/VNG-Realisatie/gemma-documentregistratiecomponent
.. _ZTC: https://github.com/VNG-Realisatie/gemma-zaaktypecatalogus
.. _BRC: https://github.com/VNG-Realisatie/gemma-besluitregistratiecomponent
| zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/README.rst | README.rst |
import logging
from typing import Union
from django.conf import settings
from django.utils.functional import cached_property
from django.utils.translation import ugettext as _
import jwt
from rest_framework.exceptions import PermissionDenied
from rest_framework.response import Response
from .constants import VERSION_HEADER
from .models import JWTSecret
from .scopes import Scope
logger = logging.getLogger(__name__)
EMPTY_PAYLOAD = {
'scopes': [],
'zaaktypes': [],
}
class JWTPayload:
def __init__(self, encoded: str=None):
self.encoded = encoded
def __repr__(self):
return "<%s: payload=%r>" % (self.__class__.__name__, self.payload)
def __getitem__(self, key):
return self.payload[key]
def get(self, attr, *args, **kwargs):
return self.payload.get(attr, *args, **kwargs)
@cached_property
def payload(self) -> dict:
if self.encoded is None:
return EMPTY_PAYLOAD
try:
header = jwt.get_unverified_header(self.encoded)
except jwt.DecodeError:
logger.info("Invalid JWT encountered")
raise PermissionDenied(
_('JWT could not be decoded. Possibly you made a copy-paste mistake.'),
code='jwt-decode-error'
)
try:
jwt_secret = JWTSecret.objects.get(identifier=header['client_identifier'])
except (JWTSecret.DoesNotExist, KeyError):
raise PermissionDenied(
'Client credentials zijn niet aanwezig',
code='missing-client-identifier'
)
else:
key = jwt_secret.secret
# the jwt package does verification against tampering (TODO: unit test)
try:
payload = jwt.decode(self.encoded, key, algorithms='HS256')
except jwt.InvalidSignatureError as exc:
logger.exception("Invalid signature - possible payload tampering?")
raise PermissionDenied(
'Client credentials zijn niet geldig',
code='invalid-jwt-signature'
)
return payload.get('zds', EMPTY_PAYLOAD)
def has_scopes(self, scopes: Union[Scope, None]) -> bool:
"""
Check whether all of the expected scopes are present or not.
"""
if scopes is None:
# TODO: should block instead of allow it - we'll gradually introduce this
return True
scopes_provided = self.payload['scopes']
# simple form - needs a more complex setup if a scope 'bundles'
# other scopes
return scopes.is_contained_in(scopes_provided)
class AuthMiddleware:
header = 'HTTP_AUTHORIZATION'
auth_type = 'Bearer'
def __init__(self, get_response=None):
self.get_response = get_response
def __call__(self, request):
self.extract_jwt_payload(request)
return self.get_response(request) if self.get_response else None
def extract_jwt_payload(self, request):
authorization = request.META.get(self.header, '')
prefix = f"{self.auth_type} "
if authorization.startswith(prefix):
# grab the actual token
encoded = authorization[len(prefix):]
else:
encoded = None
request.jwt_payload = JWTPayload(encoded)
class APIVersionHeaderMiddleware:
"""
Include a header specifying the API-version
"""
def __init__(self, get_response=None):
self.get_response = get_response
def __call__(self, request):
if self.get_response is None:
return None
response = self.get_response(request)
# not an API response, exit early
if not isinstance(response, Response):
return response
# set the header
response[VERSION_HEADER] = settings.API_VERSION
return response | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/middleware.py | middleware.py |
import re
from urllib.parse import urlparse
from zds_client.client import UUID_PATTERN
class Response:
def __init__(self, status_code: int=200):
self.status_code = status_code
def json(self) -> dict:
return {}
def link_fetcher_404(url: str, *args, **kwargs):
return Response(status_code=404)
def link_fetcher_200(url: str, *args, **kwargs):
return Response(status_code=200)
class MockClient:
data = {}
@classmethod
def from_url(cls, detail_url: str):
clients = {
'ztc': ZTCMockClient,
'drc': DRCMockClient,
}
parsed_url = urlparse(detail_url)
if ':' in parsed_url.netloc:
host, port = parsed_url.netloc.split(':')
else:
host = parsed_url.netloc
# Try mock client based on host.
if host in clients:
return clients[host]()
# Try mock client based first element of the path.
first_path_element = parsed_url.path.strip('/').split('/', 1)[0]
if first_path_element in clients:
return clients[first_path_element]()
raise ValueError('Cannot determine service based on url: %s', detail_url)
def request(self, path: str, operation: str, method='GET', **kwargs):
bits = path.rsplit('/', 2)
# Match UUIDs and simple numbers that are most likely used for testing.
if re.match(r'^({}|[0-9]+)$'.format(UUID_PATTERN), bits[-1]):
resource = bits[-2]
uuid = bits[-1]
else:
resource = bits[-1]
uuid = None
# Should the mock client really consult an OAS to figure out the
# operation? Workaround for now is to strip off plural forms ("n", "s",
# "sen").
if resource not in self.data:
if resource[0:-1] in self.data:
resource = resource[0:-1]
elif resource[0:-3] in self.data:
resource = resource[0:-3]
if method == 'GET' and not uuid:
return self.list(resource)
return self.retrieve(resource, uuid=uuid)
def list(self, resource: str, *args, **kwargs):
return self.data.get(resource, [])
def retrieve(self, resource: str, *args, **kwargs):
try:
index = int(kwargs.get('uuid', 1)) - 1
except ValueError:
index = 0
# result = copy.deepcopy(self.data.get(resource)[index])
# result['url'] = result['url'].format(**kwargs)
return self.data.get(resource)[index]
class ZTCMockClient(MockClient):
data = {
'statustype': [{
'url': 'https://ztc/api/v1/catalogussen/{catalogus_uuid}/zaaktypen/{zaaktype_uuid}/statustypen/{uuid}',
'volgnummer': 1,
'isEindstatus': False,
}, {
'url': 'https://ztc/api/v1/catalogussen/{catalogus_uuid}/zaaktypen/{zaaktype_uuid}/statustypen/{uuid}',
'volgnummer': 2,
'isEindstatus': True,
}],
}
class DRCMockClient(MockClient):
data = {
'objectinformatieobject': [{
'url': 'https://mock/objectinformatieobjecten/1234',
'informatieobject': '',
'object': '',
'objectType': '',
'titel': '',
'beschrijving': '',
'registratiedatum': '',
}]
}
class ObjectInformatieObjectClient(DRCMockClient):
"""
Kept for backwards compatability.
"""
@classmethod
def from_url(cls, *args, **kwargs):
return cls()
def list(self, resource, *args, **kwargs):
assert resource == 'objectinformatieobject'
return self.data[resource] | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/mocks.py | mocks.py |
from django.utils.translation import ugettext_lazy as _
from djchoices import ChoiceItem, DjangoChoices
BSN_LENGTH = 9
RSIN_LENGTH = 9
VERSION_HEADER = 'API-version'
class VertrouwelijkheidsAanduiding(DjangoChoices):
openbaar = ChoiceItem('openbaar', 'OPENBAAR')
beperkt_openbaar = ChoiceItem('beperkt openbaar', 'BEPERKT OPENBAAR')
intern = ChoiceItem('intern', 'INTERN')
zaakvertrouwelijk = ChoiceItem('zaakvertrouwelijk', 'ZAAKVERTROUWELIJK')
vertrouwelijk = ChoiceItem('vertrouwelijk', 'VERTROUWELIJK')
confidentieel = ChoiceItem('confidentieel', 'CONFIDENTIEEL')
geheim = ChoiceItem('geheim', 'GEHEIM')
zeer_geheim = ChoiceItem('zeer geheim', 'ZEER GEHEIM')
class RolOmschrijving(DjangoChoices):
adviseur = ChoiceItem(
'Adviseur', 'Adviseur',
description='Kennis in dienst stellen van de behandeling van (een deel van) een zaak.'
)
behandelaar = ChoiceItem(
'Behandelaar', 'Behandelaar',
description='De vakinhoudelijke behandeling doen van (een deel van) een zaak.'
)
belanghebbende = ChoiceItem(
'Belanghebbende', 'Belanghebbende',
description='Vanuit eigen en objectief belang rechtstreeks betrokken '
'zijn bij de behandeling en/of de uitkomst van een zaak.'
)
beslisser = ChoiceItem(
'Beslisser', 'Beslisser',
description='Nemen van besluiten die voor de uitkomst van een zaak noodzakelijk zijn.'
)
initiator = ChoiceItem(
'Initiator', 'Initiator',
description='Aanleiding geven tot de start van een zaak ..'
)
klantcontacter = ChoiceItem(
'Klantcontacter', 'Klantcontacter',
description='Het eerste aanspreekpunt zijn voor vragen van burgers en bedrijven ..'
)
zaakcoordinator = ChoiceItem(
'Zaakcoördinator', 'Zaakcoördinator',
description='Er voor zorg dragen dat de behandeling van de zaak in samenhang '
'uitgevoerd wordt conform de daarover gemaakte afspraken.'
)
medeinitiator = ChoiceItem(
'Mede-initiator', 'Mede-initiator',
description=''
)
class RolTypes(DjangoChoices):
natuurlijk_persoon = ChoiceItem('Natuurlijk persoon', "Natuurlijk persoon")
niet_natuurlijk_persoon = ChoiceItem('Niet-natuurlijk persoon', "Niet-natuurlijk persoon")
vestiging = ChoiceItem('Vestiging', "Vestiging")
organisatorische_eenheid = ChoiceItem('Organisatorische eenheid', "Organisatorische eenheid")
medewerker = ChoiceItem('Medewerker', "Medewerker")
class ObjectTypes(DjangoChoices):
besluit = ChoiceItem('besluit', _("Besluit"))
zaak = ChoiceItem('zaak', _("Zaak"))
class Archiefnominatie(DjangoChoices):
blijvend_bewaren = ChoiceItem(
'blijvend_bewaren',
_("Het zaakdossier moet bewaard blijven en op de Archiefactiedatum overgedragen worden naar een "
"archiefbewaarplaats.")
)
vernietigen = ChoiceItem(
'vernietigen',
_("Het zaakdossier moet op of na de Archiefactiedatum vernietigd worden.")
)
class Archiefstatus(DjangoChoices):
nog_te_archiveren = ChoiceItem(
'nog_te_archiveren',
_("De zaak cq. het zaakdossier is nog niet als geheel gearchiveerd.")
)
gearchiveerd = ChoiceItem(
'gearchiveerd',
_("De zaak cq. het zaakdossier is als geheel niet-wijzigbaar bewaarbaar gemaakt.")
)
gearchiveerd_procestermijn_onbekend = ChoiceItem(
'gearchiveerd_procestermijn_onbekend',
_("De zaak cq. het zaakdossier is als geheel niet-wijzigbaar bewaarbaar gemaakt maar de vernietigingsdatum "
"kan nog niet bepaald worden.")
)
# After deliberation this element was removed because "vernietigd" means
# it's really gone and the status wouldn't make sense:
#
# vernietigd = ChoiceItem('vernietigd',
# _("De zaak cq. het zaakdossier is vernietigd.")
# )
overgedragen = ChoiceItem(
'overgedragen',
_("De zaak cq. het zaakdossier is overgebracht naar een archiefbewaarplaats.")
)
class BrondatumArchiefprocedureAfleidingswijze(DjangoChoices):
afgehandeld = ChoiceItem(
'afgehandeld', _("Afgehandeld"),
description=_("De termijn start op de datum waarop de zaak is "
"afgehandeld (ZAAK.Einddatum in het RGBZ).")
)
ander_datumkenmerk = ChoiceItem(
'ander_datumkenmerk', _("Ander datumkenmerk"),
description=_("De termijn start op de datum die is vastgelegd in een "
"ander datumveld dan de datumvelden waarop de overige "
"waarden (van deze attribuutsoort) betrekking hebben. "
"`Objecttype`, `Registratie` en `Datumkenmerk` zijn niet "
"leeg.")
)
eigenschap = ChoiceItem(
'eigenschap', _("Eigenschap"),
description=_("De termijn start op de datum die vermeld is in een "
"zaaktype-specifieke eigenschap (zijnde een `datumveld`). "
"`ResultaatType.ZaakType` heeft een `Eigenschap`; "
"`Objecttype`, en `Datumkenmerk` zijn niet leeg.")
)
gerelateerde_zaak = ChoiceItem(
'gerelateerde_zaak', _("Gerelateerde zaak"),
description=_("De termijn start op de datum waarop de gerelateerde "
"zaak is afgehandeld (`ZAAK.Einddatum` of "
"`ZAAK.Gerelateerde_zaak.Einddatum` in het RGBZ). "
"`ResultaatType.ZaakType` heeft gerelateerd `ZaakType`")
)
hoofdzaak = ChoiceItem(
'hoofdzaak', _("Hoofzaak"),
description=_("De termijn start op de datum waarop de gerelateerde "
"zaak is afgehandeld, waarvan de zaak een deelzaak is "
"(`ZAAK.Einddatum` van de hoofdzaak in het RGBZ). "
"ResultaatType.ZaakType is deelzaaktype van ZaakType.")
)
ingangsdatum_besluit = ChoiceItem(
'ingangsdatum_besluit', _("Ingangsdatum besluit"),
description=_("De termijn start op de datum waarop het besluit van "
"kracht wordt (`BESLUIT.Ingangsdatum` in het RGBZ). "
"ResultaatType.ZaakType heeft relevant BesluitType")
)
termijn = ChoiceItem(
'termijn', _("Termijn"),
description=_("De termijn start een vast aantal jaren na de datum "
"waarop de zaak is afgehandeld (`ZAAK.Einddatum` in het "
"RGBZ).")
)
vervaldatum_besluit = ChoiceItem(
'vervaldatum_besluit', _("Vervaldatum besluit"),
description=_("De termijn start op de dag na de datum waarop het "
"besluit vervalt (`BESLUIT.Vervaldatum` in het RGBZ). "
"ResultaatType.ZaakType heeft relevant BesluitType")
)
zaakobject = ChoiceItem(
'zaakobject', _("Zaakobject"),
description=_("De termijn start op de einddatum geldigheid van het "
"zaakobject waarop de zaak betrekking heeft "
"(bijvoorbeeld de overlijdendatum van een Persoon). "
"M.b.v. de attribuutsoort `Objecttype` wordt vastgelegd "
"om welke zaakobjecttype het gaat; m.b.v. de "
"attribuutsoort `Datumkenmerk` wordt vastgelegd welke "
"datum-attribuutsoort van het zaakobjecttype het betreft.")
)
class ZaakobjectTypes(DjangoChoices):
verblijfs_object = ChoiceItem('VerblijfsObject', 'Verblijfsobject')
melding_openbare_ruimte = ChoiceItem('MeldingOpenbareRuimte', "Melding openbare ruimte")
avg_inzage_verzoek = ChoiceItem('InzageVerzoek', "Inzage verzoek in het kader van de AVG") | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/constants.py | constants.py |
from urllib.parse import urlencode, urlparse
from django.conf import settings
from django.core.exceptions import ValidationError
from django.db import models
from django.forms.widgets import URLInput
from django.http import QueryDict
from django.utils.translation import ugettext_lazy as _
from django_filters import fields, filters
from django_filters.constants import EMPTY_VALUES
from django_filters.rest_framework import DjangoFilterBackend
from djangorestframework_camel_case.parser import CamelCaseJSONParser
from djangorestframework_camel_case.render import CamelCaseJSONRenderer
from djangorestframework_camel_case.util import underscoreize
from rest_framework.request import Request
from rest_framework.views import APIView
from .search import is_search_view
from .utils import get_resource_for_path
from .validators import validate_rsin
class Backend(DjangoFilterBackend):
# Taken from drf_yasg.inspectors.field.CamelCaseJSONFilter
def _is_camel_case(self, view):
return (
any(issubclass(parser, CamelCaseJSONParser) for parser in view.parser_classes) or
any(issubclass(renderer, CamelCaseJSONRenderer) for renderer in view.renderer_classes)
)
def _transform_query_params(self, view, query_params: QueryDict) -> QueryDict:
if not self._is_camel_case(view):
return query_params
# data can be a regular dict if it's coming from a serializer
if hasattr(query_params, 'lists'):
data = dict(query_params.lists())
else:
data = query_params
transformed = underscoreize(data)
return QueryDict(urlencode(transformed, doseq=True))
def get_filterset_kwargs(self, request: Request, queryset: models.QuerySet, view: APIView):
"""
Get the initialization parameters for the filterset.
* filter on request.data if request.query_params is empty
* do the camelCase transformation of filter parameters
"""
kwargs = super().get_filterset_kwargs(request, queryset, view)
filter_parameters = request.query_params if not is_search_view(view) else request.data
query_params = self._transform_query_params(view, filter_parameters)
kwargs['data'] = query_params
return kwargs
class URLModelChoiceField(fields.ModelChoiceField):
widget = URLInput
def url_to_pk(self, url: str):
parsed = urlparse(url)
path = parsed.path
if settings.FORCE_SCRIPT_NAME and path.startswith(settings.FORCE_SCRIPT_NAME):
path = path[len(settings.FORCE_SCRIPT_NAME):]
instance = get_resource_for_path(path)
model = self.queryset.model
if not isinstance(instance, model):
raise ValidationError(_("Invalid resource type supplied, expected %r") % model, code='invalid-type')
return instance.pk
def to_python(self, value: str):
# TODO: validate that it's proper URL input
if value:
try:
value = self.url_to_pk(value)
except models.ObjectDoesNotExist:
raise ValidationError(_("Invalid resource URL supplied"), code='invalid')
return super().to_python(value)
class URLModelChoiceFilter(filters.ModelChoiceFilter):
field_class = URLModelChoiceField
class RSINFilter(filters.CharFilter):
def __init__(self, *args, **kwargs):
kwargs.setdefault('validators', [validate_rsin])
super().__init__(*args, **kwargs)
class WildcardFilter(filters.CharFilter):
"""
Filters the queryset based on a string and optionally allows wildcards in
the query parameter.
"""
wildcard = '*'
def __init__(self, *args, **kwargs):
kwargs['lookup_expr'] = 'iregex'
super().__init__(*args, **kwargs)
def filter(self, qs, value):
if value in EMPTY_VALUES:
return qs
value = r'^{}$'.format(value.replace(self.wildcard, '.*'))
return super().filter(qs, value) | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/filters.py | filters.py |
import json
import logging
from typing import Callable
from django.conf import settings
from django.core.exceptions import ValidationError
from django.core.validators import RegexValidator
from django.utils import timezone
from django.utils.deconstruct import deconstructible
from django.utils.module_loading import import_string
from django.utils.translation import ugettext_lazy as _
import requests
from rest_framework import serializers, validators
from unidecode import unidecode
from .constants import RSIN_LENGTH
from .oas import fetcher, obj_has_shape
logger = logging.getLogger(__name__)
@deconstructible
class AlphanumericExcludingDiacritic:
"""
Alle alfanumerieke tekens m.u.v. diacrieten.
"""
def __init__(self, start=0):
self.start = start
def __call__(self, value):
stripped_value = value[self.start:]
non_diactric = unidecode(stripped_value)
non_diactric.encode('ascii')
if stripped_value != non_diactric:
raise ValidationError(
'Waarde "{0}" mag geen diakrieten of non-ascii tekens bevatten{1}'.format(
value, ' na de eerste {0} karakters'.format(self.start) if self.start else ''
)
)
def __eq__(self, other):
return isinstance(other, AlphanumericExcludingDiacritic) and self.start == other.start
# Default validator for entire string.
alphanumeric_excluding_diacritic = AlphanumericExcludingDiacritic()
def validate_non_negative_string(value):
"""
Validate a string containing a integer to be non-negative.
"""
error = False
try:
n = int(value)
except ValueError:
error = True
if error or n < 0:
raise ValidationError('De waarde moet een niet-negatief getal zijn.')
validate_digits = RegexValidator(
regex='^[0-9]+$', message='Waarde moet numeriek zijn.',
code='only-digits'
)
def validate_rsin(value):
"""
Validates that a string value is a valid RSIN number by applying the
'11-proef' checking.
:param value: String object representing a presumably good RSIN number.
"""
# Initial sanity checks.
validate_digits(value)
if len(value) != RSIN_LENGTH:
raise ValidationError(
'RSIN moet %s tekens lang zijn.' % RSIN_LENGTH,
code='invalid-length'
)
# 11-proef check.
total = 0
for multiplier, char in enumerate(reversed(value), start=1):
if multiplier == 1:
total += -multiplier * int(char)
else:
total += multiplier * int(char)
if total % 11 != 0:
raise ValidationError('Onjuist RSIN nummer.', code='invalid')
class URLValidator:
"""
Validate that the URL actually resolves to a HTTP 200
Any extra init kwargs are passed down to the underlying ``link_fetcher``
:param get_auth: a callable returning appropriate headers to authenticate
against the remote.
"""
message = _('The URL {url} responded with HTTP {status_code}. Please provide a valid URL.')
code = 'bad-url'
def __init__(self, get_auth: Callable=None, **extra):
self.get_auth = get_auth
self.extra = extra
def __call__(self, value: str):
link_fetcher = import_string(settings.LINK_FETCHER)
extra = self.extra.copy()
# Handle auth for the remote URL
if self.get_auth:
auth_headers = self.get_auth(value)
if 'headers' not in self.extra:
extra['headers'] = {}
extra['headers'].update(auth_headers)
try:
response = link_fetcher(value, **extra)
except Exception as exc:
raise serializers.ValidationError(
_('The URL {url} could not be fetched. Exception: {exc}').format(
url=value, exc=exc
),
code=self.code,
)
if response.status_code != 200:
raise serializers.ValidationError(
self.message.format(status_code=response.status_code, url=value),
code=self.code
)
# return the response for post-processing
return response
class ResourceValidator(URLValidator):
"""
Validate that the URL resolves to an instance of the external resource.
:param resource: name of the resource, e.g. 'zaak'
:param oas_schema: URL to the schema to validate the response object shape
against. Must be a YAML OAS 3.0.x spec.
"""
message = _('The URL {url} resource did not look like a(n) `{resource}`. Please provide a valid URL.')
code = 'invalid-resource'
def __init__(self, resource: str, oas_schema: str, *args, **kwargs):
self.resource = resource
self.oas_schema = oas_schema
super().__init__(*args, **kwargs)
def __call__(self, url: str):
response = super().__call__(url)
# at this point, we know the URL actually exists
try:
obj = response.json()
except json.JSONDecodeError as exc:
logger.info("URL %s doesn't seem to point to a JSON endpoint", url, exc_info=1)
raise serializers.ValidationError(
self.message.format(url=url, resource=self.resource),
code=self.code
)
# check if the shape matches
schema = fetcher.fetch(self.oas_schema)
if not obj_has_shape(obj, schema, self.resource):
logger.info("URL %s doesn't seem to point to a valid shape", url, exc_info=1)
raise serializers.ValidationError(
self.message.format(url=url, resource=self.resource),
code=self.code
)
class InformatieObjectUniqueValidator(validators.UniqueTogetherValidator):
def __init__(self, parent_field, field: str):
self.parent_field = parent_field
self.field = field
super().__init__(None, (parent_field, field))
def set_context(self, serializer_field):
serializer = serializer_field.parent
super().set_context(serializer)
self.queryset = serializer.Meta.model._default_manager.all()
self.parent_object = serializer.context['parent_object']
def __call__(self, informatieobject: str):
attrs = {
self.parent_field: self.parent_object,
self.field: informatieobject,
}
super().__call__(attrs)
class ObjectInformatieObjectValidator:
"""
Validate that the INFORMATIEOBJECT is linked already in the DRC.
"""
message = _('Het informatieobject is in het DRC nog niet gerelateerd aan dit object.')
code = 'inconsistent-relation'
def set_context(self, serializer):
"""
This hook is called by the serializer instance,
prior to the validation call being made.
"""
self.parent_object = serializer.context['parent_object']
self.request = serializer.context['request']
def __call__(self, informatieobject: str):
object_url = self.parent_object.get_absolute_api_url(self.request)
# dynamic so that it can be mocked in tests easily
Client = import_string(settings.ZDS_CLIENT_CLASS)
client = Client.from_url(informatieobject)
try:
oios = client.list('objectinformatieobject', query_params={
'informatieobject': informatieobject,
'object': object_url,
})
except requests.HTTPError as exc:
raise serializers.ValidationError(
exc.args[0],
code='relation-validation-error'
) from exc
if len(oios) == 0:
raise serializers.ValidationError(self.message, code=self.code)
@deconstructible
class UntilNowValidator:
"""
Validate a datetime to not be in the future.
This means that `now` is included.
"""
message = _("Ensure this value is not in the future.")
code = 'future_not_allowed'
@property
def limit_value(self):
return timezone.now()
def __call__(self, value):
if value > self.limit_value:
raise ValidationError(self.message, code=self.code)
def __eq__(self, other):
return (
isinstance(other, self.__class__) and
self.message == other.message and
self.code == other.code
)
class UntilTodayValidator(UntilNowValidator):
@property
def limit_value(self):
limit_value = super().limit_value
return limit_value.date()
class UniekeIdentificatieValidator:
"""
Valideer dat de identificatie binnen de organisatie uniek is.
Indien de identificatie niet expliciet opgegeven is, wordt ervan uitgegaan
dat de identificatie-generator uniciteit garandeert.
:param organisatie_field: naam van het veld dat de organisatie RSIN bevat
:param identificatie_field: naam van het veld dat de identificatie bevat
"""
message = _('Deze identificatie bestaat al binnen de organisatie')
code = 'identificatie-niet-uniek'
def __init__(self, organisatie_field: str, identificatie_field='identificatie'):
self.organisatie_field = organisatie_field
self.identificatie_field = identificatie_field
def set_context(self, serializer):
"""
This hook is called by the serializer instance,
prior to the validation call being made.
"""
# Determine the existing instance, if this is an update operation.
self.instance = getattr(serializer, 'instance', None)
self.model = serializer.Meta.model
def __call__(self, attrs: dict):
identificatie = attrs.get(self.identificatie_field)
if not identificatie:
# identification is being generated, and the generation checks for
# uniqueness
return
organisatie = attrs.get(self.organisatie_field)
pk = self.instance.pk if self.instance else None
# if we're updating an instance, setting the current values will not
# trigger an error because the instance-to-be-updated is excluded from
# the queryset. If either bronorganisatie or identificatie changes,
# and it already exists, it will raise a validation error
combination_exists = (
self.model.objects
# in case of an update, exclude the current object. for a create, this
# will be None
.exclude(pk=pk)
.filter(**{
self.organisatie_field: organisatie,
self.identificatie_field: identificatie
})
.exists()
)
if combination_exists:
raise serializers.ValidationError(
{self.identificatie_field: self.message},
code=self.code
)
class IsImmutableValidator:
"""
Valideer dat de waarde van het veld niet wijzigt bij een update actie.
"""
message = _('Dit veld mag niet gewijzigd worden.')
code = 'wijzigen-niet-toegelaten'
def set_context(self, serializer_field):
"""
This hook is called by the serializer instance,
prior to the validation call being made.
"""
# Determine the existing instance, if this is an update operation.
self.serializer_field = serializer_field
self.instance = getattr(serializer_field.parent, 'instance', None)
def __call__(self, new_value):
# no instance -> it's not an update
if not self.instance:
return
current_value = getattr(self.instance, self.serializer_field.field_name)
if new_value != current_value:
raise serializers.ValidationError(self.message, code=self.code) | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/validators.py | validators.py |
import json
import logging
import os
from urllib.parse import urlsplit
from django.conf import settings
from drf_yasg import openapi
from drf_yasg.codecs import yaml_sane_dump, yaml_sane_load
from drf_yasg.generators import (
OpenAPISchemaGenerator as _OpenAPISchemaGenerator
)
from drf_yasg.renderers import SwaggerJSONRenderer, SwaggerYAMLRenderer
from drf_yasg.views import get_schema_view
from rest_framework import permissions
from rest_framework.response import Response
logger = logging.getLogger(__name__)
class OpenAPISchemaGenerator(_OpenAPISchemaGenerator):
def get_path_parameters(self, path, view_cls):
"""Return a list of Parameter instances corresponding to any templated path variables.
:param str path: templated request path
:param type view_cls: the view class associated with the path
:return: path parameters
:rtype: list[openapi.Parameter]
"""
parameters = super().get_path_parameters(path, view_cls)
# see if we can specify UUID a bit more
for parameter in parameters:
# the most pragmatic of checks
if not parameter.name.endswith('_uuid'):
continue
parameter.format = openapi.FORMAT_UUID
parameter.description = "Unieke resource identifier (UUID4)"
return parameters
DefaultSchemaView = get_schema_view(
# validators=['flex', 'ssv'],
generator_class=OpenAPISchemaGenerator,
public=True,
permission_classes=(permissions.AllowAny,),
)
class OpenAPIV3RendererMixin:
def render(self, data, media_type=None, renderer_context=None):
if 'openapi' in data or 'swagger' in data:
if self.format == '.yaml':
return yaml_sane_dump(data, False)
elif self.format == '.json':
return json.dumps(data)
return super().render(data, media_type=media_type, renderer_context=renderer_context)
SPEC_RENDERERS = (
type(
'SwaggerYAMLRenderer',
(OpenAPIV3RendererMixin, SwaggerYAMLRenderer),
{},
),
type(
'SwaggerJSONRenderer',
(OpenAPIV3RendererMixin, SwaggerJSONRenderer),
{},
),
)
class SchemaView(DefaultSchemaView):
@property
def _is_openapi_v3(self) -> bool:
version = self.request.GET.get('v', '')
return version.startswith('3')
def get_renderers(self):
if not self._is_openapi_v3:
return super().get_renderers()
return [renderer() for renderer in SPEC_RENDERERS]
def get(self, request, *args, **kwargs):
response = super().get(request, *args, **kwargs)
if not self._is_openapi_v3:
return response
# serve the staticically included V3 schema
SCHEMA_PATH = os.path.join(settings.BASE_DIR, 'src', 'openapi.yaml')
with open(SCHEMA_PATH, 'r') as infile:
schema = yaml_sane_load(infile)
# fix the servers
for server in schema['servers']:
split_url = urlsplit(server['url'])
if split_url.netloc:
continue
prefix = settings.FORCE_SCRIPT_NAME or ''
if prefix.endswith('/'):
prefix = prefix[:-1]
server_path = f"{prefix}{server['url']}"
server['url'] = request.build_absolute_uri(server_path)
return Response(
data=schema,
headers={'X-OAS-Version': schema['openapi']}
) | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/schema.py | schema.py |
import logging
import uuid
from collections import OrderedDict
from typing import List, Union
from django.core.exceptions import PermissionDenied
from django.http import Http404
from django.urls import reverse
from rest_framework import exceptions
from .serializers import FoutSerializer, ValidatieFoutSerializer
from .utils import underscore_to_camel
logger = logging.getLogger(__name__)
ErrorSerializer = Union[FoutSerializer, ValidatieFoutSerializer]
STATUS_TO_TITLE = {} # TODO
def _translate_exceptions(exc):
# Taken from DRF default exc handler
if isinstance(exc, Http404):
exc = exceptions.NotFound()
elif isinstance(exc, PermissionDenied):
exc = exceptions.PermissionDenied()
return exc
def get_validation_errors(validation_errors: dict):
for field_name, error_list in validation_errors.items():
# nested validation - recursively call the function
if isinstance(error_list, dict):
for err in get_validation_errors(error_list):
err['name'] = f"{underscore_to_camel(field_name)}.{err['name']}"
yield err
continue
if isinstance(error_list, exceptions.ErrorDetail):
error_list = [error_list]
for error in error_list:
yield OrderedDict([
# see https://tools.ietf.org/html/rfc7807#section-3.1
# ('type', 'about:blank'),
('name', underscore_to_camel(field_name)),
('code', error.code),
('reason', str(error)),
])
class HandledException:
def __init__(self, exc: exceptions.APIException, response, request=None):
self.exc = exc
assert 400 <= response.status_code < 600, "Unsupported status code"
self.response = response
self.request = request
self._exc_id = str(uuid.uuid4())
@property
def _error_detail(self) -> str:
if isinstance(self.exc, exceptions.ValidationError):
# ErrorDetail from DRF is a str subclass
data = getattr(self.response, 'data', {})
return data.get('detail', '')
# any other exception -> return the raw ErrorDetails object so we get
# access to the code later
return self.exc.detail
@classmethod
def as_serializer(cls, exc: exceptions.APIException, response, request=None) -> ErrorSerializer:
"""
Return the appropriate serializer class instance.
"""
exc = _translate_exceptions(exc)
self = cls(exc, response, request)
self.log()
if isinstance(exc, exceptions.ValidationError):
serializer_class = ValidatieFoutSerializer
else:
serializer_class = FoutSerializer
return serializer_class(instance=self)
def log(self):
logger.exception("Exception %s ocurred", self._exc_id)
@property
def type(self) -> str:
exc_detail_url = reverse(
'zds_schema:error-detail',
kwargs={'exception_class': self.exc.__class__.__name__}
)
if self.request is not None:
exc_detail_url = self.request.build_absolute_uri(exc_detail_url)
return exc_detail_url
@property
def code(self) -> str:
if isinstance(self.exc, exceptions.ValidationError):
return self.exc.default_code
return self._error_detail.code if self._error_detail else ''
@property
def title(self) -> str:
"""
Return the generic message for this type of exception.
"""
default_title = getattr(self.exc, 'default_detail', str(self._error_detail))
title = STATUS_TO_TITLE.get(self.response.status_code, default_title)
return title
@property
def status(self) -> int:
return self.response.status_code
@property
def detail(self) -> str:
return str(self._error_detail)
@property
def instance(self) -> str:
return f"urn:uuid:{self._exc_id}"
@property
def invalid_params(self) -> Union[None, List]:
return [
error for error in
get_validation_errors(self.exc.detail)
] | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/exception_handling.py | exception_handling.py |
from collections import OrderedDict
from django.http import Http404
from django.views.generic import TemplateView
from rest_framework import exceptions as drf_exceptions
from rest_framework.views import exception_handler as drf_exception_handler
from . import exceptions
from .exception_handling import HandledException
from .scopes import SCOPE_REGISTRY
ERROR_CONTENT_TYPE = 'application/problem+json'
def exception_handler(exc, context):
"""
Transform 4xx and 5xx errors into DSO-compliant shape.
"""
response = drf_exception_handler(exc, context)
if response is None:
return
request = context.get('request')
serializer = HandledException.as_serializer(exc, response, request)
response.data = OrderedDict(serializer.data.items())
# custom content type
response['Content-Type'] = ERROR_CONTENT_TYPE
return response
class ErrorDetailView(TemplateView):
template_name = 'zds_schema/error_detail.html'
def _get_exception_klass(self):
klass = self.kwargs['exception_class']
for module in [exceptions, drf_exceptions]:
exc_klass = getattr(module, klass, None)
if exc_klass is not None:
return exc_klass
else:
raise Http404("Unknown exception class '{}'".format(klass))
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
exc_klass = self._get_exception_klass()
context.update({
'type': exc_klass.__name__,
'status_code': exc_klass.status_code,
'default_detail': exc_klass.default_detail,
'default_code': exc_klass.default_code,
})
return context
class ScopesView(TemplateView):
template_name = 'zds_schema/scopes.html'
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['scopes'] = sorted(
(scope for scope in SCOPE_REGISTRY if not scope.children),
key=lambda s: s.label
)
return context | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/views.py | views.py |
import re
from typing import Union
from django.db import models
from django.http import HttpRequest
from django.urls import Resolver404, get_resolver
try:
from djangorestframework_camel_case.util import underscore_to_camel as _underscore_to_camel
except ImportError:
from djangorestframework_camel_case.util import underscoreToCamel as _underscore_to_camel
RE_UNDERSCORE = re.compile(r"[a-z]_[a-z]")
def lookup_kwargs_to_filters(lookup_kwargs: dict, kwargs: dict) -> dict:
"""
Using the lookup_kwargs map and the view kwargs, construct the queryset
filter dict.
"""
filters = {}
for kwarg, field_name in lookup_kwargs.items():
if kwarg not in kwargs:
continue
filters[field_name] = kwargs[kwarg]
return filters
def get_viewset_for_path(path: str) -> 'rest_framework.viewsets.ViewSet':
"""
Look up which viewset matches a path.
"""
# NOTE: this doesn't support setting a different urlconf on the request
resolver = get_resolver()
try:
resolver_match = resolver.resolve(path)
except Resolver404 as exc:
raise models.ObjectDoesNotExist("URL did not resolve") from exc
callback, callback_args, callback_kwargs = resolver_match
assert hasattr(callback, 'cls'), "Callback doesn't appear to be from a viewset"
viewset = callback.cls(**callback.initkwargs)
viewset.action_map = callback.actions
viewset.request = HttpRequest()
viewset.args = callback_args
viewset.kwargs = callback_kwargs
return viewset
def get_resource_for_path(path: str) -> models.Model:
"""
Retrieve the API instance belonging to a (detail) path.
"""
viewset = get_viewset_for_path(path)
# See rest_framework.mixins.RetieveModelMixin.get_object()
lookup_url_kwarg = viewset.lookup_url_kwarg or viewset.lookup_field
filter_kwargs = {viewset.lookup_field: viewset.kwargs[lookup_url_kwarg]}
return viewset.get_queryset().get(**filter_kwargs)
def underscore_to_camel(input_: Union[str, int]) -> str:
"""
Convert a string from under_score to camelCase.
"""
if not isinstance(input_, str):
return input_
return re.sub(RE_UNDERSCORE, _underscore_to_camel, input_) | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/utils.py | utils.py |
from typing import Union
import requests
import yaml
from drf_yasg import openapi
TYPE_MAP = {
openapi.TYPE_OBJECT: dict,
openapi.TYPE_STRING: str,
openapi.TYPE_NUMBER: (float, int),
openapi.TYPE_INTEGER: int,
openapi.TYPE_BOOLEAN: bool,
openapi.TYPE_ARRAY: list,
}
class SchemaFetcher:
def __init__(self):
self.cache = {}
def fetch(self, url: str):
"""
Fetch a YAML-based OAS 3.0.x schema.
"""
if url in self.cache:
return self.cache[url]
response = requests.get(url)
response.raise_for_status()
spec = yaml.safe_load(response.content)
spec_version = response.headers.get('X-OAS-Version', spec.get('openapi', spec.get('swagger', '')))
if not spec_version.startswith('3.0'):
raise ValueError("Unsupported spec version: {}".format(spec_version))
self.cache[url] = spec
return spec
def obj_has_shape(obj: Union[list, dict], schema: dict, resource: str) -> bool:
"""
Compare an instance of an object with the expected shape from an OAS 3 schema.
..todo:: doesn't handle references and nested schema's yet.
:param obj: the value retrieved from the endpoint, json-decoded to a dict or list
:param schema: the OAS 3.0.x schema to test against, yaml-decoded to dict
:param resource: the name of the resource to test the schape against
"""
obj_schema = schema['components']['schemas'][resource]
required = obj_schema.get('required', [])
for prop, prop_schema in obj_schema['properties'].items():
if prop in required and prop not in obj:
# missing required prop -> can't match the schema
return False
# can't compare something that isn't there...
if prop not in obj:
continue
value = obj[prop]
expected_type = TYPE_MAP[prop_schema['type']]
# type mismatch -> not what we're looking for
if not isinstance(value, expected_type):
return False
return True
fetcher = SchemaFetcher() | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/oas.py | oas.py |
import datetime
from django.db import transaction
import isodate
from djchoices import DjangoChoices
from rest_framework import fields, serializers
from .descriptors import GegevensGroepType
class DurationField(fields.DurationField):
def to_internal_value(self, value):
if isinstance(value, datetime.timedelta):
return value
try:
parsed = isodate.parse_duration(str(value))
except isodate.ISO8601Error:
self.fail('invalid', format='P(n)Y(n)M(n)D')
else:
assert isinstance(parsed, datetime.timedelta)
return parsed
def to_representation(self, value):
return isodate.duration_isoformat(value)
class FieldValidationErrorSerializer(serializers.Serializer):
"""
Formaat van validatiefouten.
"""
name = serializers.CharField(help_text="Naam van het veld met ongeldige gegevens")
code = serializers.CharField(help_text="Systeemcode die het type fout aangeeft")
reason = serializers.CharField(help_text="Uitleg wat er precies fout is met de gegevens")
class FoutSerializer(serializers.Serializer):
"""
Formaat van HTTP 4xx en 5xx fouten.
"""
type = serializers.CharField(
help_text="URI referentie naar het type fout, bedoeld voor developers",
required=False, allow_blank=True
)
# not according to DSO, but possible for programmatic checking
code = serializers.CharField(help_text="Systeemcode die het type fout aangeeft")
title = serializers.CharField(help_text="Generieke titel voor het type fout")
status = serializers.IntegerField(help_text="De HTTP status code")
detail = serializers.CharField(help_text="Extra informatie bij de fout, indien beschikbaar")
instance = serializers.CharField(
help_text="URI met referentie naar dit specifiek voorkomen van de fout. Deze kan "
"gebruikt worden in combinatie met server logs, bijvoorbeeld."
)
class ValidatieFoutSerializer(FoutSerializer):
pass
# can't declare stuff with dashes and DSO prescribes dashed key...
ValidatieFoutSerializer._declared_fields['invalid-params'] = \
FieldValidationErrorSerializer(source='invalid_params', many=True)
def add_choice_values_help_text(choices: DjangoChoices) -> str:
displays = "\n".join([
f"* `{value}` - {display}"
for value, display in choices.choices
])
return f"De mapping van waarden naar weergave is als volgt:\n\n{displays}"
class GegevensGroepSerializerMetaclass(serializers.SerializerMetaclass):
def __new__(cls, name, bases, attrs):
Meta = attrs.get('Meta')
if Meta:
assert hasattr(Meta, 'model'), "The 'model' class must be defined on the Meta."
assert hasattr(Meta, 'gegevensgroep'), "The 'gegevensgroep' name must be defined on the Meta."
gegevensgroep = getattr(Meta.model, Meta.gegevensgroep)
Meta.fields = []
extra_kwargs = {}
for field_name, model_field in gegevensgroep.mapping.items():
Meta.fields.append(field_name)
# the field is always required and may not be empty in any form
default_extra_kwargs = {
'source': model_field.name,
'required': field_name not in gegevensgroep.optional,
'allow_null': False,
'allow_blank': field_name in gegevensgroep.optional,
}
internal_type = model_field.get_internal_type()
if internal_type not in ['CharField', 'TextField']:
del default_extra_kwargs['allow_blank']
if internal_type == 'BooleanField':
del default_extra_kwargs['allow_null']
extra_kwargs[field_name] = default_extra_kwargs
declared_extra_kwargs = getattr(Meta, 'extra_kwargs', {}).get(field_name)
if declared_extra_kwargs:
extra_kwargs[field_name].update(declared_extra_kwargs)
Meta.extra_kwargs = extra_kwargs
return super().__new__(cls, name, bases, attrs)
class GegevensGroepSerializer(serializers.ModelSerializer, metaclass=GegevensGroepSerializerMetaclass):
"""
Generate a serializer out of a GegevensGroepType.
Usage::
>>> class VerlengingSerializer(GegevensGroepSerializer):
... class Meta:
... model = Zaak
... gegevensgroep = 'verlenging'
>>>
Where ``Zaak.verlenging`` is a :class:``GegevensGroepType``.
"""
def to_representation(self, instance) -> dict:
"""
Output the result of accessing the descriptor.
"""
return instance
def to_internal_value(self, data):
"""
Pass through the original keys instead of reverse-mapping the source attrs.
"""
value = super().to_internal_value(data)
ret = {}
for name, field in self.fields.items():
if field not in self._writable_fields:
continue
if field.source not in value:
continue
ret[name] = value[field.source]
return ret
class NestedGegevensGroepMixin:
"""
Set gegevensgroepdata from validated nested data.
Usage: include the mixin on the ModelSerializer that has gegevensgroepen.
"""
def _is_gegevensgroep(self, name: str):
attr = getattr(self.Meta.model, name)
return isinstance(attr, GegevensGroepType)
@transaction.atomic
def create(self, validated_data):
"""
Handle nested writes.
"""
gegevensgroepen = {}
for name in list(validated_data.keys()):
if not self._is_gegevensgroep(name):
continue
gegevensgroepen[name] = validated_data.pop(name)
# perform the default create
obj = super().create(validated_data)
for name, gegevensgroepdata in gegevensgroepen.items():
setattr(obj, name, gegevensgroepdata)
obj.save()
return obj
def update(self, instance, validated_data):
"""
Handle nested writes.
"""
for name in list(validated_data.keys()):
if not self._is_gegevensgroep(name):
continue
setattr(instance, name, validated_data.pop(name))
return super().update(instance, validated_data) | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/serializers.py | serializers.py |
from typing import Dict
from django.db import models
class GegevensGroepType:
"""
Structure a body of data from flat model fields.
All keys are always truthy for a value.
:param mapping: dict, mapping simple keys to model fields
:param optional: iterable of fields that are NOT required.
:param none_for_empty: convert 'empty' values to None, such as empty
strings. Booleans are left untouched
"""
name = None
model = None
def __init__(self, mapping: Dict[str, models.Field], optional: tuple=None, none_for_empty=False):
self.mapping = mapping
self.optional = optional or ()
self.none_for_empty = none_for_empty
all_fields_known = set(self.optional).issubset(set(mapping.keys()))
assert all_fields_known, "The fields in 'optional' must be a subset of the mapping keys"
# check if it's optional or not
self.required = any(field.blank is False for field in self.mapping.values())
def __repr__(self):
fields = ", ".join([
field if field not in self.optional else f"{field} (optional)"
for field in self.mapping.keys()
])
return "<GegevensGroepType: fields=%r required=%r>" % (fields, self.required)
def __get__(self, obj, type=None):
if obj is None: # accessed through the owner, i.e. the model -> introspection
return self
def _value_getter(attr):
val = getattr(obj, attr)
if not self.none_for_empty:
return val
if isinstance(val, bool):
return val
# 'empty'-ish value check
if not val:
return None
return val
return {
key: _value_getter(field.name)
for key, field in self.mapping.items()
}
def __set__(self, obj, value: dict):
# value can be empty, if that's the case, empty all model fields
if not value:
if self.required:
raise ValueError("A non-empty value is required")
for field in self.mapping.values():
empty_value = None if field.null else ''
default_value = field.default if field.default != models.NOT_PROVIDED else empty_value
setattr(obj, field.name, default_value)
return
# map the values
for key, field in self.mapping.items():
setattr(obj, field.name, value[key])
if key not in self.optional:
assert getattr(obj, field.name, None), f"Empty '{key}' not allowed" | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/descriptors.py | descriptors.py |
from urllib.parse import urlsplit, urlunsplit
from django.db import models
from django.db.models.functions import Length
from django.utils.translation import ugettext_lazy as _
from rest_framework.reverse import reverse
from zds_client import ClientAuth
class APIMixin:
def get_absolute_api_url(self, request=None, **kwargs) -> str:
"""
Build the absolute URL of the object in the API.
"""
# build the URL of the informatieobject
resource_name = self._meta.model_name
reverse_kwargs = {'uuid': self.uuid}
reverse_kwargs.update(**kwargs)
url = reverse(
f'{resource_name}-detail',
kwargs=reverse_kwargs, request=request
)
return url
class JWTSecret(models.Model):
identifier = models.CharField(_("identifier"), max_length=50, unique=True)
secret = models.CharField(_("secret"), max_length=255)
def __str__(self):
return self.identifier
class APICredential(models.Model):
"""
Store credentials for external APIs.
When we need to authenticate against a remote API, we need to know which
client ID and secret to use to sign the JWT.
"""
api_root = models.URLField(_("api root"), unique=True)
client_id = models.CharField(_("client id"), max_length=255)
secret = models.CharField(_("secret"), max_length=255)
class Meta:
verbose_name = _("API credential")
verbose_name_plural = _("API credentials")
def __str__(self):
return self.api_root
@classmethod
def get_auth(cls, url: str, **kwargs) -> ClientAuth:
split_url = urlsplit(url)
scheme_and_domain = urlunsplit(split_url[:2] + ('', '', ''))
candidates = (
cls.objects
.filter(api_root__startswith=scheme_and_domain)
.annotate(api_root_length=Length('api_root'))
.order_by('-api_root_length')
)
# select the one matching
for candidate in candidates.iterator():
if url.startswith(candidate.api_root):
credentials = candidate
break
else:
return None
auth = ClientAuth(
client_id=credentials.client_id,
secret=credentials.secret,
**kwargs
)
return auth | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/models.py | models.py |
from django.utils.translation import ugettext_lazy as _
from rest_framework.exceptions import ValidationError
from rest_framework.pagination import PageNumberPagination
from rest_framework.settings import api_settings
from .filters import Backend
from .utils import lookup_kwargs_to_filters, underscore_to_camel
class NestedViewSetMixin:
def get_queryset(self):
"""
Filter the ``QuerySet`` based on its parents.
"""
queryset = super().get_queryset()
serializer_class = self.get_serializer_class()
lookup_kwargs = getattr(serializer_class, 'parent_lookup_kwargs', {})
filters = lookup_kwargs_to_filters(lookup_kwargs, self.kwargs)
return queryset.filter(**filters)
class CheckQueryParamsMixin:
def _check_query_params(self, request) -> None:
"""
Validate that the query params in the request are known.
"""
# nothing to check if there are no query parameters
if not request.query_params:
return
# TODO: check for pagination params
# NOTE: only works with django_filters based filter backends
backend = Backend()
queryset = self.get_queryset()
filterset_class = backend.get_filterset_class(self, queryset)
# build a list of known params from the filters
filters = filterset_class().get_filters().keys()
known_params = {underscore_to_camel(param) for param in filters}
# add the pagination params to the known params
if self.paginator:
if isinstance(self.paginator, PageNumberPagination):
known_params.add(self.paginator.page_query_param)
if self.paginator.page_size_query_param:
known_params.add(self.paginator.page_size_query_param)
else:
raise NotImplementedError("Unknown paginator class: %s" % type(self.paginator))
unknown_params = set(request.query_params.keys()) - known_params
if unknown_params:
msg = _("Onbekende query parameters: %s" % ", ".join(unknown_params))
raise ValidationError(
{api_settings.NON_FIELD_ERRORS_KEY: msg},
code='unknown-parameters'
)
def list(self, request, *args, **kwargs):
self._check_query_params(request)
return super().list(request, *args, **kwargs) | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/viewsets.py | viewsets.py |
from datetime import timedelta
from django.core import checks
from django.core.validators import MaxValueValidator, MinValueValidator
from django.db import models
from django.utils.translation import ugettext, ugettext_lazy as _
from iso639 import languages
from .constants import BSN_LENGTH, RSIN_LENGTH, VertrouwelijkheidsAanduiding
from .validators import validate_rsin
ISO_639_2B = languages.part2b
LANGUAGE_CHOICES = tuple([
(code, language.name) for code, language in ISO_639_2B.items()
])
class RSINField(models.CharField):
default_validators = [validate_rsin]
description = _("RSIN")
def __init__(self, *args, **kwargs):
kwargs.setdefault('max_length', RSIN_LENGTH)
super().__init__(*args, **kwargs)
def check(self, **kwargs):
errors = super().check(**kwargs)
errors.extend(self._check_fixed_max_length_attribute(**kwargs))
return errors
def _check_fixed_max_length_attribute(self, **kwargs):
if self.max_length != RSIN_LENGTH:
return [
checks.Error(
"RSINField may not override 'max_length' attribute.",
obj=self,
id='zds_schema.fields.E001',
)
]
return []
class BSNField(models.CharField):
default_validators = [validate_rsin]
description = _("BSN")
def __init__(self, *args, **kwargs):
kwargs.setdefault('max_length', BSN_LENGTH)
super().__init__(*args, **kwargs)
def check(self, **kwargs):
errors = super().check(**kwargs)
errors.extend(self._check_fixed_max_length_attribute(**kwargs))
return errors
def _check_fixed_max_length_attribute(self, **kwargs):
if self.max_length != BSN_LENGTH:
return [
checks.Error(
"BSNField may not override 'max_length' attribute.",
obj=self,
id='zds_schema.fields.E002',
)
]
return []
class LanguageField(models.CharField):
def __init__(self, *args, **kwargs):
kwargs.setdefault('max_length', 3)
kwargs.setdefault('choices', LANGUAGE_CHOICES)
super().__init__(*args, **kwargs)
def check(self, **kwargs):
errors = super().check(**kwargs)
errors.extend(self._check_fixed_max_length_attribute(**kwargs))
errors.extend(self._check_choices(**kwargs))
return errors
def _check_fixed_max_length_attribute(self, **kwargs):
if self.max_length != 3:
return [
checks.Error(
"LanguageField may not override 'max_length' attribute.",
obj=self,
id='zds_schema.fields.E003',
)
]
return []
def _check_choices(self, **kwargs):
if self.choices != LANGUAGE_CHOICES:
return [
checks.Error(
"LanguageField may not override 'choices' attribute.",
obj=self,
id='zds_schema.fields.E004',
)
]
return []
class VertrouwelijkheidsAanduidingField(models.CharField):
def __init__(self, *args, **kwargs):
kwargs.setdefault('max_length', 20)
kwargs.setdefault('choices', VertrouwelijkheidsAanduiding.choices)
super().__init__(*args, **kwargs)
def check(self, **kwargs):
errors = super().check(**kwargs)
errors.extend(self._check_choices(**kwargs))
return errors
def _check_choices(self, **kwargs):
if self.choices != VertrouwelijkheidsAanduiding.choices:
return [
checks.Error(
"VertrouwelijkheidsAanduidingField may not override 'choices' attribute.",
obj=self,
id='zds_schema.fields.E005',
)
]
return []
class DaysDurationField(models.DurationField):
"""
Express duration in number of calendar days.
:param min_duration: minimal duration, in number of calendar days.
Defaults to 1.
:param max_duration: maximal duration, in number of calendar days.
Defaults to 999.
"""
def __init__(self, *args, **kwargs):
kwargs.setdefault('min_duration', 1)
kwargs.setdefault('max_duration', 999) # 999 calendar days
self.min_duration = kwargs.pop('min_duration')
self.max_duration = kwargs.pop('max_duration')
self.default_validators = [
MinValueValidator(timedelta(days=self.min_duration)),
MaxValueValidator(timedelta(days=self.max_duration))
]
super().__init__(*args, **kwargs)
def deconstruct(self) -> tuple:
name, path, args, kwargs = super().deconstruct()
kwargs.update({
'min_duration': self.min_duration,
'max_duration': self.max_duration,
})
return name, path, args, kwargs
def check(self, **kwargs) -> list:
errors = super().check(**kwargs)
errors.extend(self._check_min_duration(**kwargs))
return errors
def _check_min_duration(self, **kwargs) -> list:
errors = []
if self.min_duration < 1:
errors.append([
checks.Error(
"De minimale duur in kalenderdagen moet groter dan of gelijk aan 1 zijn",
obj=self,
id='zds_schema.fields.E006',
)
])
if self.min_duration > self.max_duration:
errors.append([
checks.Error(
"De minimale duur mag niet langer zijn dan de maximale duur",
obj=self,
id='zds_schema.fields.E007',
)
])
return errors
def formfield(self, **kwargs):
# add sensible help-text
_help_text = ugettext("Specifieer de duur als 'DD 00:00'")
help_text = f"{self.help_text} {_help_text}" if self.help_text else _help_text
defaults = {
'help_text': help_text,
}
defaults.update(**kwargs)
return super().formfield(**defaults) | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/fields.py | fields.py |
import logging
import os
from django.apps import apps
from django.contrib.auth.models import User
from django.core.exceptions import ImproperlyConfigured
from django.template.loader import render_to_string
from django.urls import reverse
from drf_yasg import openapi
from drf_yasg.app_settings import swagger_settings
from drf_yasg.management.commands import generate_swagger
from rest_framework.settings import api_settings
from ...schema import OpenAPISchemaGenerator
from ...version import get_major_version
class Table:
def __init__(self, resource: str):
self.resource = resource
self.rows = []
class Row:
def __init__(self,
label: str, description: str, type: str, required: bool,
create: bool, read: bool, update: bool, delete: bool):
self.label = label
self.description = description
self.type = type
self.required = required
self.create = create
self.read = read
self.update = update
self.delete = delete
class Command(generate_swagger.Command):
"""
Patches to the provided command to modify the schema for ZDS needs.
"""
def add_arguments(self, parser):
super().add_arguments(parser)
parser.add_argument('--to-markdown-table', action='store_true')
def get_mock_request(self, *args, **kwargs):
request = super().get_mock_request(*args, **kwargs)
request.version = api_settings.DEFAULT_VERSION
return request
def write_schema(self, schema, stream, format):
del schema.host
del schema.schemes
super().write_schema(schema, stream, format)
# need to overwrite the generator class...
def handle(self, output_file, overwrite, format, api_url, mock, user, private, *args, **options):
# disable logs of WARNING and below
logging.disable(logging.WARNING)
info = getattr(swagger_settings, 'DEFAULT_INFO', None)
if not isinstance(info, openapi.Info):
raise ImproperlyConfigured(
'settings.SWAGGER_SETTINGS["DEFAULT_INFO"] should be an '
'import string pointing to an openapi.Info object'
)
if not format:
if os.path.splitext(output_file)[1] in ('.yml', '.yaml'):
format = 'yaml'
format = format or 'json'
api_root = reverse('api-root', kwargs={'version': get_major_version()})
api_url = (
api_url
or swagger_settings.DEFAULT_API_URL # noqa
or f"http://example.com{api_root}" # noqa
)
user = User.objects.get(username=user) if user else None
mock = mock or private or (user is not None)
if mock and not api_url:
raise ImproperlyConfigured(
'--mock-request requires an API url; either provide '
'the --url argument or set the DEFAULT_API_URL setting'
)
request = self.get_mock_request(api_url, format, user) if mock else None
generator = OpenAPISchemaGenerator(
info=info,
url=api_url
)
schema = generator.get_schema(request=request, public=not private)
if output_file == '-':
self.write_schema(schema, self.stdout, format)
else:
with open(output_file, 'w', encoding='utf8') as stream:
if options['to_markdown_table']:
self.to_markdown_table(schema, stream)
else:
self.write_schema(schema, stream, format)
def to_markdown_table(self, schema, stream):
template = 'zds_schema/api_schema_to_markdown_table.md'
tables = []
whitelist = [model._meta.object_name for model in apps.get_models()]
for resource, definition in schema.definitions.items():
if resource not in whitelist:
continue
if not hasattr(definition, 'properties'):
continue
table = Table(resource)
for field, _schema in definition.properties.items():
if isinstance(_schema, openapi.SchemaRef):
continue
readonly = getattr(_schema, 'readOnly', False)
table.rows.append(Row(
label=field,
description=getattr(_schema, 'description', ''),
type=_schema.type,
required=field in definition.required,
create=not readonly,
read=True,
update=not readonly,
delete=not readonly,
))
tables.append(table)
markdown = render_to_string(template, context={'tables': tables})
stream.write(markdown) | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/management/commands/generate_swagger.py | generate_swagger.py |
import logging
from collections import OrderedDict
from django.conf import settings
from drf_yasg import openapi
from drf_yasg.inspectors import SwaggerAutoSchema
from rest_framework import exceptions, serializers, status
from ..constants import VERSION_HEADER
from ..exceptions import Conflict, Gone, PreconditionFailed
from ..geo import GeoMixin
from ..permissions import ActionScopesRequired
from ..search import is_search_view
from ..serializers import FoutSerializer, ValidatieFoutSerializer
logger = logging.getLogger(__name__)
TYPE_TO_FIELDMAPPING = {
openapi.TYPE_INTEGER: serializers.IntegerField,
openapi.TYPE_NUMBER: serializers.FloatField,
openapi.TYPE_STRING: serializers.CharField,
openapi.TYPE_BOOLEAN: serializers.BooleanField,
}
COMMON_ERRORS = [
exceptions.AuthenticationFailed,
exceptions.NotAuthenticated,
exceptions.PermissionDenied,
exceptions.NotAcceptable,
Conflict,
Gone,
exceptions.UnsupportedMediaType,
exceptions.Throttled,
exceptions.APIException,
]
DEFAULT_ACTION_ERRORS = {
'create': COMMON_ERRORS + [
exceptions.ParseError,
exceptions.ValidationError,
],
'list': COMMON_ERRORS,
'retrieve': COMMON_ERRORS + [
exceptions.NotFound,
],
'update': COMMON_ERRORS + [
exceptions.ParseError,
exceptions.ValidationError,
exceptions.NotFound,
],
'partial_update': COMMON_ERRORS + [
exceptions.ParseError,
exceptions.ValidationError,
exceptions.NotFound,
],
'destroy': COMMON_ERRORS + [
exceptions.NotFound,
],
}
def response_header(description: str, type: str, format: str=None) -> OrderedDict:
header = OrderedDict((
('schema', OrderedDict((
('type', type),
))),
('description', description),
))
if format is not None:
header['schema']['format'] = format
return header
version_header = response_header(
"Geeft een specifieke API-versie aan in de context van een specifieke aanroep. Voorbeeld: 1.2.1.",
type=openapi.TYPE_STRING
)
location_header = response_header(
"URL waar de resource leeft.",
type=openapi.TYPE_STRING,
format=openapi.FORMAT_URI
)
class AutoSchema(SwaggerAutoSchema):
@property
def model(self):
qs = self.view.get_queryset()
return qs.model
@property
def _is_search_view(self):
return is_search_view(self.view)
def get_operation_id(self, operation_keys):
"""
Simply return the model name as lowercase string, postfixed with the operation name.
"""
action = operation_keys[-1]
model_name = self.model._meta.model_name
return f"{model_name}_{action}"
def should_page(self):
if self._is_search_view:
return hasattr(self.view, 'paginator')
return super().should_page()
def get_request_serializer(self):
if not self._is_search_view:
return super().get_request_serializer()
Base = self.view.get_search_input_serializer_class()
filter_fields = []
for filter_backend in self.view.filter_backends:
filter_fields += self.probe_inspectors(
self.filter_inspectors,
'get_filter_parameters', filter_backend()
) or []
filters = {}
for filter_field in filter_fields:
FieldClass = TYPE_TO_FIELDMAPPING[filter_field.type]
filters[filter_field.name] = FieldClass(
help_text=filter_field.description,
required=filter_field.required
)
SearchSerializer = type(Base.__name__, (Base,), filters)
return SearchSerializer()
def _get_search_responses(self):
response_status = status.HTTP_200_OK
response_schema = self.serializer_to_schema(self.get_view_serializer())
schema = openapi.Schema(type=openapi.TYPE_ARRAY, items=response_schema)
if self.should_page():
schema = self.get_paginated_response(schema) or schema
return OrderedDict({str(response_status): schema})
def _get_error_responses(self) -> OrderedDict:
"""
Add the appropriate possible error responses to the schema.
E.g. - we know that HTTP 400 on a POST/PATCH/PUT leads to validation
errors, 403 to Permission Denied etc.
"""
responses = {}
action = self.view.action
if action not in DEFAULT_ACTION_ERRORS and self._is_search_view: # similar to a CREATE
action = 'create'
exception_klasses = DEFAULT_ACTION_ERRORS.get(action)
if exception_klasses is None:
logger.debug("Unknown action %s, no default error responses added")
return responses
fout_schema = self.serializer_to_schema(FoutSerializer())
for exception_klass in exception_klasses:
status_code = exception_klass.status_code
responses[status_code] = fout_schema
has_validation_errors = self.get_filter_parameters() or any(
issubclass(klass, exceptions.ValidationError)
for klass in exception_klasses
)
if has_validation_errors:
schema = self.serializer_to_schema(ValidatieFoutSerializer())
responses[exceptions.ValidationError.status_code] = schema
if isinstance(self.view, GeoMixin):
status_code = PreconditionFailed.status_code
responses[status_code] = fout_schema
# sort by status code
return OrderedDict([
(status_code, schema)
for status_code, schema
in sorted(responses.items())
])
def get_default_responses(self) -> OrderedDict:
if self._is_search_view:
responses = self._get_search_responses()
serializer = self.get_view_serializer()
else:
responses = super().get_default_responses()
serializer = self.get_request_serializer() or self.get_view_serializer()
# inject any headers
_responses = OrderedDict()
for status_, schema in responses.items():
custom_headers = self.probe_inspectors(
self.field_inspectors, 'get_response_headers',
serializer, {'field_inspectors': self.field_inspectors},
status=status_
) or None
assert isinstance(schema, openapi.Schema.OR_REF) or schema == ''
response = openapi.Response(
description='',
schema=schema or None,
headers=custom_headers
)
_responses[status_] = response
for status_code, response in self._get_error_responses().items():
_responses[status_code] = response
return _responses
def get_response_schemas(self, response_serializers):
responses = super().get_response_schemas(response_serializers)
# add the Api-Version headers
for status_code, response in responses.items():
response.setdefault('headers', OrderedDict())
response['headers'][VERSION_HEADER] = version_header
if status_code == '201':
response['headers']['Location'] = location_header
return responses
def add_manual_parameters(self, parameters):
base = super().add_manual_parameters(parameters)
if self._is_search_view:
serializer = self.get_request_serializer()
else:
serializer = self.get_request_serializer() or self.get_view_serializer()
extra = self.probe_inspectors(
self.field_inspectors, 'get_request_header_parameters',
serializer, {'field_inspectors': self.field_inspectors}
) or []
return base + extra
def get_security(self):
"""Return a list of security requirements for this operation.
Returning an empty list marks the endpoint as unauthenticated (i.e. removes all accepted
authentication schemes). Returning ``None`` will inherit the top-level secuirty requirements.
:return: security requirements
:rtype: list[dict[str,list[str]]]"""
permissions = self.view.get_permissions()
scope_permissions = [perm for perm in permissions if isinstance(perm, ActionScopesRequired)]
if not scope_permissions:
return super().get_security()
if len(permissions) != len(scope_permissions):
logger.warning(
"Can't represent all permissions in OAS for path %s and method %s",
self.path, self.method
)
required_scopes = []
for perm in scope_permissions:
scopes = perm.get_required_scopes(self.view)
if scopes is None:
continue
required_scopes.append(scopes)
if not required_scopes:
return None # use global security
scopes = [str(scope) for scope in sorted(required_scopes)]
# operation level security
return [{
settings.SECURITY_DEFINITION_NAME: scopes,
}] | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/inspectors/view.py | view.py |
from collections import OrderedDict
from drf_yasg import openapi
from drf_yasg.inspectors import FieldInspector, NotHandled
from rest_framework import serializers
from rest_framework_gis.fields import GeometryField
from ..geo import DEFAULT_CRS, HEADER_ACCEPT, HEADER_CONTENT
REF_NAME_GEOJSON_GEOMETRY = 'GeoJSONGeometry'
def register_geojson(definitions):
Geometry = openapi.Schema(
type=openapi.TYPE_OBJECT,
title="Geometry",
description="GeoJSON geometry",
discriminator='type',
required=['type'],
externalDocs=OrderedDict(url='https://tools.ietf.org/html/rfc7946#section-3.1'),
properties=OrderedDict((
('type', openapi.Schema(
type=openapi.TYPE_STRING,
enum=[
'Point',
'MultiPoint',
'LineString',
'MultiLineString',
'Polygon',
'MultiPolygon',
'Feature',
'FeatureCollection',
'GeometryCollection',
],
description="The geometry type"
)),
))
)
definitions.set('Geometry', Geometry)
Point2D = openapi.Schema(
type=openapi.TYPE_ARRAY,
title="Point2D",
description="A 2D point",
items=openapi.Schema(type=openapi.TYPE_NUMBER),
maxItems=2,
minItems=2
)
definitions.set('Point2D', Point2D)
Point = openapi.Schema(
type=openapi.TYPE_OBJECT,
description="GeoJSON point geometry",
externalDocs=OrderedDict(url='https://tools.ietf.org/html/rfc7946#section-3.1.2'),
allOf=[
openapi.SchemaRef(definitions, 'Geometry'),
openapi.Schema(
type=openapi.TYPE_OBJECT,
required=['coordinates'],
properties=OrderedDict((
('coordinates', openapi.SchemaRef(definitions, 'Point2D')),
))
)
]
)
definitions.set('Point', Point)
MultiPoint = openapi.Schema(
type=openapi.TYPE_OBJECT,
description="GeoJSON multi-point geometry",
externalDocs=OrderedDict(url='https://tools.ietf.org/html/rfc7946#section-3.1.3'),
allOf=[
openapi.SchemaRef(definitions, 'Geometry'),
openapi.Schema(
type=openapi.TYPE_OBJECT,
required=['coordinates'],
properties=OrderedDict((
('coordinates', openapi.Schema(
type=openapi.TYPE_ARRAY,
items=openapi.SchemaRef(definitions, 'Point2D'),
)),
))
)
]
)
definitions.set('MultiPoint', MultiPoint)
LineString = openapi.Schema(
type=openapi.TYPE_OBJECT,
description="GeoJSON line-string geometry",
externalDocs=OrderedDict(url='https://tools.ietf.org/html/rfc7946#section-3.1.4'),
allOf=[
openapi.SchemaRef(definitions, 'Geometry'),
openapi.Schema(
type=openapi.TYPE_OBJECT,
required=['coordinates'],
properties=OrderedDict((
('coordinates', openapi.Schema(
type=openapi.TYPE_ARRAY,
items=openapi.SchemaRef(definitions, 'Point2D'),
minItems=2,
)),
))
)
]
)
definitions.set('LineString', LineString)
MultiLineString = openapi.Schema(
type=openapi.TYPE_OBJECT,
description="GeoJSON multi-line-string geometry",
externalDocs=OrderedDict(url='https://tools.ietf.org/html/rfc7946#section-3.1.5'),
allOf=[
openapi.SchemaRef(definitions, 'Geometry'),
openapi.Schema(
type=openapi.TYPE_OBJECT,
required=['coordinates'],
properties=OrderedDict((
('coordinates', openapi.Schema(
type=openapi.TYPE_ARRAY,
items=openapi.Schema(
type=openapi.TYPE_ARRAY,
items=openapi.SchemaRef(definitions, 'Point2D')
)
)),
))
)
]
)
definitions.set('MultiLineString', MultiLineString)
Polygon = openapi.Schema(
type=openapi.TYPE_OBJECT,
description="GeoJSON polygon geometry",
externalDocs=OrderedDict(url='https://tools.ietf.org/html/rfc7946#section-3.1.6'),
allOf=[
openapi.SchemaRef(definitions, 'Geometry'),
openapi.Schema(
type=openapi.TYPE_OBJECT,
required=['coordinates'],
properties=OrderedDict((
('coordinates', openapi.Schema(
type=openapi.TYPE_ARRAY,
items=openapi.Schema(
type=openapi.TYPE_ARRAY,
items=openapi.SchemaRef(definitions, 'Point2D')
)
)),
))
)
]
)
definitions.set('Polygon', Polygon)
MultiPolygon = openapi.Schema(
type=openapi.TYPE_OBJECT,
description="GeoJSON multi-polygon geometry",
externalDocs=OrderedDict(url='https://tools.ietf.org/html/rfc7946#section-3.1.7'),
allOf=[
openapi.SchemaRef(definitions, 'Geometry'),
openapi.Schema(
type=openapi.TYPE_OBJECT,
required=['coordinates'],
properties=OrderedDict((
('coordinates', openapi.Schema(
type=openapi.TYPE_ARRAY,
items=openapi.Schema(
type=openapi.TYPE_ARRAY,
items=openapi.Schema(
type=openapi.TYPE_ARRAY,
items=openapi.SchemaRef(definitions, 'Point2D')
)
)
)),
))
)
]
)
definitions.set('MultiPolygon', MultiPolygon)
GeometryCollection = openapi.Schema(
type=openapi.TYPE_OBJECT,
description="GeoJSON multi-polygon geometry",
externalDocs=OrderedDict(url='https://tools.ietf.org/html/rfc7946#section-3.1.8'),
allOf=[
openapi.SchemaRef(definitions, 'Geometry'),
openapi.Schema(
type=openapi.TYPE_OBJECT,
required=['geometries'],
properties=OrderedDict((
('geometries', openapi.Schema(
type=openapi.TYPE_ARRAY,
items=openapi.SchemaRef(definitions, 'Geometry')
)),
))
)
]
)
definitions.set('GeometryCollection', GeometryCollection)
GeoJSONGeometry = openapi.Schema(
title=REF_NAME_GEOJSON_GEOMETRY,
type=openapi.TYPE_OBJECT,
oneOf=[
openapi.SchemaRef(definitions, 'Point'),
openapi.SchemaRef(definitions, 'MultiPoint'),
openapi.SchemaRef(definitions, 'LineString'),
openapi.SchemaRef(definitions, 'MultiLineString'),
openapi.SchemaRef(definitions, 'Polygon'),
openapi.SchemaRef(definitions, 'MultiPolygon'),
openapi.SchemaRef(definitions, 'GeometryCollection'),
]
)
definitions.set(REF_NAME_GEOJSON_GEOMETRY, GeoJSONGeometry)
class GeometryFieldInspector(FieldInspector):
def field_to_swagger_object(self, field, swagger_object_type, use_references, **kwargs):
if not isinstance(field, GeometryField):
return NotHandled
definitions = self.components.with_scope(openapi.SCHEMA_DEFINITIONS)
if not definitions.has('Geometry'):
register_geojson(definitions)
return openapi.SchemaRef(definitions, REF_NAME_GEOJSON_GEOMETRY)
def has_geo_fields(self, serializer) -> bool:
"""
Check if any of the serializer fields are a GeometryField.
If the serializer has nested serializers, a depth-first search is done
to check if the nested serializers has `GeometryField`\ s.
"""
for field in serializer.fields.values():
if isinstance(field, serializers.Serializer):
has_nested_geo_fields = self.probe_inspectors(
self.field_inspectors, 'has_geo_fields',
field, {'field_inspectors': self.field_inspectors}
)
if has_nested_geo_fields:
return True
elif isinstance(field, (serializers.ListSerializer, serializers.ListField)):
field = field.child
if isinstance(field, GeometryField):
return True
return False
def get_request_header_parameters(self, serializer):
if not self.has_geo_fields(serializer):
return []
if self.method == 'DELETE':
return []
# see also http://lyzidiamond.com/posts/4326-vs-3857 for difference
# between coordinate system and projected coordinate system
return [openapi.Parameter(
name=HEADER_ACCEPT,
type=openapi.TYPE_STRING,
in_=openapi.IN_HEADER,
required=True,
description="Het gewenste 'Coordinate Reference System' (CRS) van de "
"geometrie in het antwoord (response body). Volgens de "
"GeoJSON spec is WGS84 de default (EPSG:4326 is "
"hetzelfde als WGS84).",
enum=[DEFAULT_CRS]
), openapi.Parameter(
name=HEADER_CONTENT,
type=openapi.TYPE_STRING,
in_=openapi.IN_HEADER,
required=True,
description="Het 'Coordinate Reference System' (CRS) van de "
"geometrie in de vraag (request body). Volgens de "
"GeoJSON spec is WGS84 de default (EPSG:4326 is "
"hetzelfde als WGS84).",
enum=[DEFAULT_CRS]
)]
def get_response_headers(self, serializer, status=None):
if not self.has_geo_fields(serializer):
return None
if int(status) != 200:
return None
return OrderedDict((
(HEADER_CONTENT, openapi.Schema(
type=openapi.TYPE_STRING,
enum=[DEFAULT_CRS],
description="Het 'Coordinate Reference System' (CRS) van de "
"antwoorddata. Volgens de GeoJSON spec is WGS84 de "
"default (EPSG:4326 is hetzelfde als WGS84).",
)),
)) | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/inspectors/geojson.py | geojson.py |
from collections import OrderedDict
from drf_extra_fields.fields import Base64FieldMixin
from drf_yasg import openapi
from drf_yasg.inspectors import FieldInspector, NotHandled, ViewInspector
from drf_yasg.utils import filter_none, get_serializer_ref_name
from rest_framework import serializers
class FileFieldInspector(FieldInspector):
def get_schema(self, serializer):
if self.method not in ViewInspector.body_methods:
return NotHandled
# only do this if there are base64 mixin fields
if any(isinstance(field, Base64FieldMixin) for field in serializer.fields.values()):
return self.probe_field_inspectors(serializer, openapi.Schema, True)
return NotHandled
def field_to_swagger_object(self, field, swagger_object_type, use_references, **kwargs):
if isinstance(field, serializers.Serializer):
return self._serializer_to_swagger_object(field, swagger_object_type, use_references, **kwargs)
if not isinstance(field, Base64FieldMixin):
return NotHandled
SwaggerType, ChildSwaggerType = self._get_partial_types(field, swagger_object_type, use_references, **kwargs)
type_b64 = SwaggerType(type=openapi.TYPE_STRING, format=openapi.FORMAT_BASE64)
type_uri = SwaggerType(type=openapi.TYPE_STRING, read_only=True, format=openapi.FORMAT_URI)
if swagger_object_type == openapi.Schema:
# on writes, it's always b64
if self.method in ViewInspector.body_methods:
return type_b64
# if not representing in base64, it's a link
return type_uri if not field.represent_in_base64 else type_b64
return NotHandled
def _serializer_to_swagger_object(self, serializer, swagger_object_type, use_references, **kwargs):
if self.method not in ViewInspector.body_methods:
return NotHandled
if not any(isinstance(field, Base64FieldMixin) for field in serializer.fields.values()):
return NotHandled
SwaggerType, ChildSwaggerType = self._get_partial_types(
serializer, swagger_object_type,
use_references, **kwargs
)
ref_name = get_serializer_ref_name(serializer)
ref_name = f"{ref_name}Data" if ref_name else None
def make_schema_definition():
properties = OrderedDict()
required = []
for property_name, child in serializer.fields.items():
prop_kwargs = {
'read_only': bool(child.read_only) or None
}
prop_kwargs = filter_none(prop_kwargs)
child_schema = self.probe_field_inspectors(
child, ChildSwaggerType, use_references, **prop_kwargs
)
properties[property_name] = child_schema
if child.required and not getattr(child_schema, 'read_only', False):
required.append(property_name)
result = SwaggerType(
type=openapi.TYPE_OBJECT,
properties=properties,
required=required or None,
)
if not ref_name and 'title' in result:
# on an inline model, the title is derived from the field name
# but is visually displayed like the model name, which is confusing
# it is better to just remove title from inline models
del result.title
# Provide an option to add manual paremeters to a schema
# for example, to add examples
# self.add_manual_fields(serializer, result)
return result
if not ref_name or not use_references:
return make_schema_definition()
definitions = self.components.with_scope(openapi.SCHEMA_DEFINITIONS)
definitions.setdefault(ref_name, make_schema_definition)
return openapi.SchemaRef(definitions, ref_name) | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/inspectors/files.py | files.py |
from django.db import models
from django.utils.encoding import force_text
from django.utils.translation import ugettext as _
from django_filters.filters import ChoiceFilter
from drf_yasg import openapi
from drf_yasg.inspectors.query import CoreAPICompatInspector
from ..filters import URLModelChoiceFilter
from ..utils import underscore_to_camel
class FilterInspector(CoreAPICompatInspector):
"""
Filter inspector that specifies the format of URL-based fields and lists
enum options.
"""
def get_filter_parameters(self, filter_backend):
fields = super().get_filter_parameters(filter_backend)
if fields:
queryset = self.view.get_queryset()
filter_class = filter_backend.get_filter_class(self.view, queryset)
for parameter in fields:
filter_field = filter_class.base_filters[parameter.name]
model_field = queryset.model._meta.get_field(parameter.name.split('__')[0])
if isinstance(filter_field, URLModelChoiceFilter):
parameter.description = _("URL to the related resource")
parameter.format = openapi.FORMAT_URI
elif isinstance(filter_field, ChoiceFilter):
parameter.enum = [choice[0] for choice in filter_field.extra['choices']]
elif isinstance(model_field, models.URLField):
parameter.format = openapi.FORMAT_URI
help_text = filter_field.extra.get('help_text', model_field.help_text)
if not parameter.description and help_text:
parameter.description = force_text(model_field.help_text)
return fields
def process_result(self, result, method_name, obj, **kwargs):
"""
Convert snake-case to camelCase.
"""
if result and type(result) is list:
for parameter in result:
parameter.name = underscore_to_camel(parameter.name)
return result | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/inspectors/query.py | query.py |
__all__ = [
'API_VERSION',
'BASE_REST_FRAMEWORK',
'BASE_SWAGGER_SETTINGS',
'LINK_FETCHER',
'ZDS_CLIENT_CLASS',
'GEMMA_URL_TEMPLATE',
'GEMMA_URL_COMPONENTTYPE',
'GEMMA_URL_INFORMATIEMODEL',
'GEMMA_URL_INFORMATIEMODEL_VERSIE',
'REDOC_SETTINGS',
]
API_VERSION = '1.0.0-alpha' # semantic version
BASE_REST_FRAMEWORK = {
'DEFAULT_RENDERER_CLASSES': (
'djangorestframework_camel_case.render.CamelCaseJSONRenderer',
),
'DEFAULT_PARSER_CLASSES': (
'djangorestframework_camel_case.parser.CamelCaseJSONParser',
),
# 'DEFAULT_AUTHENTICATION_CLASSES': (
# 'oauth2_provider.contrib.rest_framework.OAuth2Authentication',
# # 'rest_framework.authentication.SessionAuthentication',
# # 'rest_framework.authentication.BasicAuthentication'
# ),
# 'DEFAULT_PERMISSION_CLASSES': (
# 'oauth2_provider.contrib.rest_framework.TokenHasReadWriteScope',
# # 'rest_framework.permissions.IsAuthenticated',
# # 'rest_framework.permissions.AllowAny',
# ),
'DEFAULT_VERSIONING_CLASS': 'rest_framework.versioning.URLPathVersioning',
#
# # Generic view behavior
# 'DEFAULT_PAGINATION_CLASS': 'ztc.api.utils.pagination.HALPagination',
'DEFAULT_FILTER_BACKENDS': (
'zds_schema.filters.Backend',
# 'rest_framework.filters.SearchFilter',
# 'rest_framework.filters.OrderingFilter',
),
#
# # Filtering
# 'SEARCH_PARAM': 'zoek', # 'search',
# 'ORDERING_PARAM': 'sorteer', # 'ordering',
#
# Versioning
'DEFAULT_VERSION': '1', # NOT to be confused with API_VERSION - it's the major version part
'ALLOWED_VERSIONS': ('1', ),
'VERSION_PARAM': 'version',
#
# # Exception handling
'EXCEPTION_HANDLER': 'zds_schema.views.exception_handler',
'TEST_REQUEST_DEFAULT_FORMAT': 'json',
}
BASE_SWAGGER_SETTINGS = {
# 'SECURITY_DEFINITIONS': {
# 'OAuth2': {
# 'type': 'oauth2',
# 'flow': 'application',
# 'tokenUrl': '/oauth2/token/',
# 'scopes': {
# 'write': 'Schrijftoegang tot de catalogus en gerelateerde objecten.',
# 'read': 'Leestoegang tot de catalogus en gerelateerde objecten.'
# }
# },
# 'Bearer': {
# 'type': 'apiKey',
# 'name': 'Authorization',
# 'in': 'header'
# },
# },
'DEFAULT_AUTO_SCHEMA_CLASS': 'zds_schema.inspectors.view.AutoSchema',
'DEFAULT_INFO': 'must.be.overridden',
'DEFAULT_FIELD_INSPECTORS': (
'zds_schema.inspectors.geojson.GeometryFieldInspector',
'drf_yasg.inspectors.CamelCaseJSONFilter',
'drf_yasg.inspectors.RecursiveFieldInspector',
'drf_yasg.inspectors.ReferencingSerializerInspector',
'drf_yasg.inspectors.ChoiceFieldInspector',
'drf_yasg.inspectors.FileFieldInspector',
'drf_yasg.inspectors.DictFieldInspector',
'drf_yasg.inspectors.HiddenFieldInspector',
'drf_yasg.inspectors.RelatedFieldInspector',
'drf_yasg.inspectors.SimpleFieldInspector',
'drf_yasg.inspectors.StringDefaultFieldInspector',
),
'DEFAULT_FILTER_INSPECTORS': (
'zds_schema.inspectors.query.FilterInspector',
)
}
REDOC_SETTINGS = {
'EXPAND_RESPONSES': '200,201'
}
# See: https://github.com/Rebilly/ReDoc#redoc-options-object
LINK_FETCHER = 'requests.get'
ZDS_CLIENT_CLASS = 'zds_client.Client'
GEMMA_URL_TEMPLATE = "https://www.gemmaonline.nl/index.php/{informatiemodel}_{versie}/doc/{componenttype}/{component}"
GEMMA_URL_COMPONENTTYPE = 'objecttype'
GEMMA_URL_INFORMATIEMODEL = 'Rgbz'
GEMMA_URL_INFORMATIEMODEL_VERSIE = '2.0' | zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/conf/api.py | api.py |
{% load zds_schema %}# Resources
Dit document beschrijft de (RGBZ-)objecttypen die als resources ontsloten
worden met de beschikbare attributen.
{% for table in tables %}
## {{ table.resource }}
Objecttype op [GEMMA Online]({{ table.resource|gemmaonline_url }})
| Attribuut | Omschrijving | Type | Verplicht | CRUD* |
| --- | --- | --- | --- | --- |{% for row in table.rows %}
| {{ row.label|md_table_cell }} | {{ row.description|md_table_cell }} | {{ row.type|md_table_cell }} | {{ row.required|yesno:"ja,nee" }} | {{ row|crud }} |{% endfor %}
{% endfor %}
* Create, Read, Update, Delete
| zds-schema | /zds-schema-0.22.0.tar.gz/zds-schema-0.22.0/zds_schema/templates/zds_schema/api_schema_to_markdown_table.md | api_schema_to_markdown_table.md |
import io
import json
import re
import shutil
import sys
import os
from datetime import time, datetime
from hashlib import sha256
from zipfile import ZipFile
import click
import requests
import yaml
from bs4 import BeautifulSoup
from path import Path
from slugify import UniqueSlugify
@click.command()
@click.option(
"--template-name",
default="item",
help="The template name to use (default item for blog entries)",
)
@click.option("--lang", default=None, help="The lang to use (default to none)")
@click.option(
"--slug",
default=None,
help="The default page slug to use. If not provided, fallbacks to a slugified version of the title.",
)
@click.option(
"--number",
default=0,
help="If provided, the folder will be numbered using this number. Default to not be numbered.",
)
@click.option(
"--to",
default=None,
help="Where to store the Grav article directory (default to the archive directory, or the current directory if input by URL).",
)
@click.argument("zds-archive")
def zds_to_grav(zds_archive, template_name, lang, slug, number, to):
"""
Converts a Zeste de Savoir article or opinion for Grav.
The archive argument can either be a path to a downloaded archive or the URL
to an article or an opinion on Zeste de Savoir. URL are preferred as it allows
to fetch metadata not contained in the archive (tags, categories, authors, date).
"""
try:
tags = []
categories = []
authors = []
date = None
link = None
if zds_archive.startswith("http://") or zds_archive.startswith("https://"):
if not zds_archive.startswith(
"http://zestedesavoir.com/"
) and not zds_archive.startswith("https://zestedesavoir.com/"):
click.secho(
"Invalid URL, only Zeste de Savoir URLs are accepted. Aborting.",
fg="red",
bold=True,
)
return
click.secho(
"Downloading archive and metadata from Zeste de Savoir…",
fg="blue",
bold=True,
)
link = zds_archive
r = requests.get(zds_archive)
if not r.ok:
click.secho(
f"→ Cannot download Zeste de Savoir webpage: {r.status_code} {r.reason}",
fg="red",
bold=True,
)
return
zds_page = r.text
zds_soup = BeautifulSoup(zds_page, "html.parser")
click.secho("→ Retrieving metadata…", fg="yellow")
download_links = zds_soup.find("aside", class_="sidebar")
download_link = None
if download_links:
download_links = download_links.find_all("a", class_="download")
if download_links:
for dl_link in download_links:
download_link = dl_link.get("href")
if download_link.endswith(".zip"):
break
if not download_link:
click.secho(
" Cannot find the download link on the page. Maybe it was not generated by Zeste de Savoir? Aborting.",
fg="red",
bold=True,
)
return
if download_link.startswith("/"):
download_link = f"https://zestedesavoir.com{download_link}"
tags_list = zds_soup.find("ul", class_="taglist")
if tags_list:
for tag in tags_list.find_all("li"):
tags.append(tag.string.strip())
authors_block = (
zds_soup.find("article", class_="content-wrapper")
.find("header")
.find("div", class_="authors")
)
if authors_block:
meta_lists = authors_block.find_all("ul")
authors_list = meta_lists[0] if len(meta_lists) > 0 else None
categories_list = meta_lists[1] if len(meta_lists) > 1 else None
if authors_list:
for author in authors_list.find_all("li"):
authors.append(author.a.span.string.strip())
if categories_list:
for category in categories_list.find_all("a"):
categories.append(category.string.strip())
date_elem = (
zds_soup.find("article", class_="content-wrapper")
.find("header")
.find("span", class_="pubdate")
)
if date_elem:
date_elem = date_elem.find("time")
if date_elem:
date = datetime.fromisoformat(date_elem["datetime"])
click.secho(
f"→ Downloading content archive from {download_link}…", fg="yellow"
)
r = requests.get(download_link, stream=True)
if not r.ok:
click.secho(
f" Cannot download Zeste de Savoir webpage: {r.status_code} {r.reason}",
fg="red",
bold=True,
)
return
zds_archive = io.BytesIO(r.content)
if not to:
to = os.getcwd()
elif not to:
to = Path(zds_archive).parent
to = to.rstrip("/") + "/"
with ZipFile(zds_archive) as archive:
manifest = {}
with archive.open("manifest.json", "r") as manifest:
manifest = json.loads(manifest.read())
if manifest["version"] < 2:
click.secho(
f"Unsupported manifest version {manifest['version']} (only version 2 is supported)",
err=True,
fg="red",
bold=True,
)
return
if manifest["type"] not in ["ARTICLE", "OPINION"]:
click.secho(
f"Unsupported content type {manifest['type']} (only articles and opinions are supported at the moment); aborting.",
err=True,
fg="red",
bold=True,
)
return
if not slug:
slug = (
manifest["slug"]
if "slug" in manifest
else "unnamed-content-" + str(int(time.time()))
)
if number:
to += f"{number:02}."
to += slug + "/"
to = Path(to)
to.mkdir_p()
click.secho(
f"\nProcessing {manifest['type'].lower()} content…",
fg="blue",
bold=True,
)
markdown_content = ""
if "introduction" in manifest:
with archive.open(manifest["introduction"]) as introduction:
markdown_content = download_and_replace_markdown_images(
get_content(introduction), to
)
if "children" in manifest:
for child in manifest["children"]:
if not child["object"] == "extract":
continue
with archive.open(child["text"]) as extract:
markdown_content += "\n\n\n"
markdown_content += f"# {child['title']}\n\n"
markdown_content += download_and_replace_markdown_images(
shift_markdown_headers(get_content(extract)), to
)
if "conclusion" in manifest:
with archive.open(manifest["conclusion"]) as conclusion:
markdown_content += "\n\n\n------\n\n\n"
markdown_content += download_and_replace_markdown_images(
get_content(conclusion), to
)
# fmt: off
markdown_frontmatter = {
"title": manifest["title"] if "title" in manifest else f"Unnamed {manifest['type'].lower()}",
"abstract": manifest["description"] if "description" in manifest else "",
"taxonomy": {
"author": authors,
"category": categories,
"tag": tags
},
}
# fmt: on
if date:
markdown_frontmatter["date"] = date.strftime("%H:%M %d-%m-%Y")
if "licence" in manifest:
if manifest["licence"].startswith("CC"):
markdown_frontmatter["license"] = (
manifest["licence"].lower().replace("cc ", "")
)
if link:
markdown_frontmatter["canonical"] = link
markdown_frontmatter_raw = "---\n"
markdown_frontmatter_raw += yaml.dump(
markdown_frontmatter,
allow_unicode=True,
indent=4,
default_flow_style=False,
)
markdown_frontmatter_raw += "---\n\n"
markdown_content = markdown_frontmatter_raw + markdown_content.strip()
markdown_filename = to / (
template_name + ("." + lang if lang else "") + ".md"
)
with open(markdown_filename, "w") as markdown_file:
markdown_file.write(markdown_content)
click.secho(
f"\nMarkdown file wrote to "
+ click.format_filename(markdown_filename)
+ " successfully.",
fg="green",
bold=True,
)
except Exception as e:
click.secho(
f"Error while processing archive: {e}", err=True, fg="red", bold=True
)
raise
re_title_5 = re.compile(r"(\A|\r?\n)##### (.+)(\r?\n|\Z)")
re_title_4 = re.compile(r"(\A|\r?\n)#### (.+)(\r?\n|\Z)")
re_title_3 = re.compile(r"(\A|\r?\n)### (.+)(\r?\n|\Z)")
re_title_2 = re.compile(r"(\A|\r?\n)## (.+)(\r?\n|\Z)")
re_title_1 = re.compile(r"(\A|\r?\n)# (.+)(\r?\n|\Z)")
re_title_2_long = re.compile(r"(\A|\r?\n)(.+)\r?\n-{2,}(\r?\n|\Z)")
re_title_1_long = re.compile(r"(\A|\r?\n)(.+)\r?\n(={2,})(\r?\n|\Z)")
def shift_markdown_headers(markdown_source):
'''
Shifts headers in Markdown so that 1st level became 2nd, 2nd became 3rd, and so on.
>>> shift_markdown_headers("# Head")
'## Head'
>>> shift_markdown_headers("""
... # Header 1
...
... Lorem ipsum
...
... ## Header 2
...
... Lorem ipsum
...
... Dolor sit
...
... ##### Header 5
...
... ###### Header 6
... """)
'\\n## Header 1\\n\\nLorem ipsum\\n\\n### Header 2\\n\\nLorem ipsum\\n\\nDolor sit\\n\\n###### Header 5\\n\\n###### Header 6\\n'
>>> shift_markdown_headers("""
... Header 1
... ========
...
... Header 2
... --------
... """)
'\\nHeader 1\\n--------\\n\\n### Header 2\\n'
'''
markdown_source = re_title_5.sub(r"\1###### \2\3", markdown_source)
markdown_source = re_title_4.sub(r"\1##### \2\3", markdown_source)
markdown_source = re_title_3.sub(r"\1#### \2\3", markdown_source)
markdown_source = re_title_2.sub(r"\1### \2\3", markdown_source)
markdown_source = re_title_1.sub(r"\1## \2\3", markdown_source)
markdown_source = re_title_2_long.sub(r"\1### \2\3", markdown_source)
def repl_title_1_long(match):
return (
match.group(1)
+ match.group(2)
+ "\n"
+ "-" * len(match.group(3))
+ match.group(4)
)
markdown_source = re_title_1_long.sub(repl_title_1_long, markdown_source)
return markdown_source
re_image = re.compile(r"!\[([^\]]+)\]\(([^\)]+)\)")
slugify = UniqueSlugify(to_lower=True)
downloaded_images = {}
def download_and_replace_markdown_images(markdown_source, to):
def repl_and_download_image(match):
image_alt = match.group(1)
image_url = match.group(2)
if not image_url.lower().startswith(
"http://"
) and not image_url.lower().startswith("https://"):
if image_url.startswith("/"):
image_url = "https://zestedesavoir.com" + image_url
else:
click.echos(
f"→ Skipping image download for {image_url} (don't know where to fetch it).",
err=True,
)
return match.group(0)
click.secho(
f"→ Downloading and replacing image “"
+ click.style(image_alt, bold=True)
+ click.style("”…", fg="yellow"),
fg="yellow",
)
click.secho(f" {image_url}", dim=True)
r = requests.get(image_url, stream=True)
if not r.ok:
click.secho(" Unable to download image, skipping", err=True, fg="red")
return match.group(0)
image = io.BytesIO(r.content)
image_hash = sha256(image.read()).hexdigest()
image_ext = "." + image_url.split(".")[-1]
if image_hash in downloaded_images:
image_filename = downloaded_images[image_hash]
image_is_new = False
else:
# Filename: slug of the first sentence of the alt-text, limited to 20 words because of
# the max path size.
image_filename = (
slugify(" ".join(image_alt.split(".")[0].split()[:20])) + image_ext
)
image_is_new = True
downloaded_images[image_hash] = image_filename
if image_is_new:
image.seek(0)
with open(to / image_filename, "wb") as f:
shutil.copyfileobj(image, f, length=131_072)
return f""
return re_image.sub(repl_and_download_image, markdown_source)
def get_content(f):
return "".join([line for line in io.TextIOWrapper(io.BytesIO(f.read()))]).strip()
if __name__ == "__main__":
if "--test" in sys.argv:
import doctest
doctest.testmod()
else:
zds_to_grav() | zds-to-grav | /zds_to_grav-1.0.2-py3-none-any.whl/zds_to_grav/zds_to_grav.py | zds_to_grav.py |
[](http://badge.fury.io/py/zdsindicator)
Zds Indicator
-------------
Un applet Ubuntu pour Zeste de Savoir. Il permet de visualiser les messages privés et les notifications forums.
Testé pour l'instant sur Ubuntu 14.04 et 14.10.
Screenshot
-----------
Requis
------
* python-appindicator
* python-gtk
* lxml
* requests
Installation
------------
Installation via pip :
```
$ pip install zdsindicator
```
Deuxième solution, télécharger la dernière archive disponible, puis l'extraire.
Une fois dans le répertoire de l'application :
```
$ python setup.py install
```
Pour lancer l'application :
```
$ zdsindicator
```
Icônes : https://github.com/SimpleSoftwares/Clemojis
| zdsindicator | /zdsindicator-0.0.3.tar.gz/zdsindicator-0.0.3/README.md | README.md |
*zdsync* is a command-line utility for syncing Zendesk environments.
## Dependencies
- Python 3.5+
- [`zenpy`](https://github.com/facetoe/zenpy)
## Usage
If you install with `python setup.py install` or through pip, this should drop a program named `zdsync` into your PYTHONHOME. Otherwise, you can use `PYTHONPATH=. python -m zdsync.cli` to get the same effect.
There are two required environment variables,
* `SANDBOX_SUBDOMAIN` - The subdomain of your sandbox environment, e.g. `mycompany1552085434`.
* `PRODUCTION_SUBDOMAIN` - The subdomain of your production environment, e.g. `mycompany`.
There are three ways to authenticate to the Zendesk API and different environment variables are needed depending on your preferred method of authentication.
* Email & Password
* `SANDBOX_EMAIL` - The email that is used as your username when logging into your sandbox environment.
* `SANDBOX_PASSWORD` - The password that is used when logging into your sandbox environment.
* `PRODUCTION_EMAIL` - The email that is used as your username when logging into your production environment.
* `PRODUCTION_PASSWORD` - The password that is used when logging into your production environment.
* Email & API Token
* `SANDBOX_EMAIL` - The email that is used as your username when logging into your sandbox environment.
* `SANDBOX_TOKEN` - An API Token for the sandbox environment.
* `PRODUCTION_EMAIL` - The email that is used as your username when logging into your production environment.
* `PRODUCITON_TOKEN` - An API Token for the production environment.
* OAuth Token
* `SANDBOX_OAUTH_TOKEN` - An oauth token with _read/write_ access to the sandbox environment.
* `PRODUCTION_OAUTH_TOKEN` - An oauth token with _read only_ access to the production environment.
There are five supported objects for syncing,
* `--brands`
* `--groups`
* `--ticket-fields`
* `--ticket-forms`
* `--macros`
It its recommended to sync in this order since there are object dependencies as you progress through the list. If you pass the `--all` flag it will sync in this order.
Just passing an object flag or `--all` will print out the status of the environments,
```
$ zdsync --macros
The following Macros only exist in the sandbox:
The following Macros only exist in production:
The following Macros are different between environments:
Customer not responding Downgrade and inform Close and redirect to topics Take it!
There are 257 other Macros that are the same between environments.
```
In order to actually execute the sync you must pass the `--execute` flag,
```
$ zdsync --macros --execute
```
## License
This tool is licensed under the ISC License, the text of which is available at [LICENSE.txt](LICENSE.txt).
| zdsync | /zdsync-0.0.3.tar.gz/zdsync-0.0.3/README.md | README.md |
from __future__ import absolute_import, division, print_function
import argparse
import ConfigParser
import smtplib
import subprocess
import sys
from email.mime.text import MIMEText
def main():
parser = argparse.ArgumentParser(prog="zdup")
parser.add_argument("-c", "--config", default="/etc/zdup.cfg")
parser.add_argument("command")
args = parser.parse_args()
config = ConfigParser.ConfigParser()
config.read(args.config)
archive_dir = config.get("zdup", "archive-dir")
key_id = config.get("zdup", "key-id")
source = config.get("zdup", "source")
dest = config.get("zdup", "dest")
email = config.get("zdup", "email")
from_email = config.get("zdup", "from_email")
email_server = config.get("zdup", "email_server")
email_port = config.get("zdup", "email_port")
email_user = config.get("zdup", "email_user")
email_password = config.get("zdup", "email_password")
env = {
"AWS_ACCESS_KEY_ID": config.get("zdup", "aws_access_key_id"),
"AWS_SECRET_ACCESS_KEY": config.get("zdup", "aws_secret_access_key"),
"PASSPHRASE": config.get("zdup", "key-passphrase"),
"SIGN_PASSPHRASE": config.get("zdup", "key-passphrase"),
}
cmd = [
"duplicity",
"--archive-dir", archive_dir,
"--encrypt-sign-key", key_id,
"--s3-use-new-style",
"--volsize", "512",
"--asynchronous-upload",
]
if args.command == "backup":
cmd += [source, dest]
elif args.command == "verify":
cmd += ["verify", dest, source]
else:
raise RuntimeError("Invalid Command")
p = subprocess.Popen(
cmd,
env=env,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
p.wait()
msg = MIMEText("-- stdout --\n%s\n-- stderr --\n%s" % (
p.stdout.read(),
p.stderr.read()
))
if p.returncode == 0:
msg["Subject"] = "Backup Complete"
else:
msg["Subject"] = "Backup Failed"
msg["To"] = email
msg["From"] = from_email
s = smtplib.SMTP_SSL(email_server, email_port)
s.login(email_user, email_password)
s.sendmail(from_email, [email], msg.as_string())
s.quit()
return p.returncode
if __name__ == "__main__":
sys.exit(main()) | zdup | /zdup-1.2.tar.gz/zdup-1.2/zdup.py | zdup.py |
ze2nb CLI
=========
Installation
------------
.. code-block:: bash
pip3 install ze2nb-cli
Usage
-----
.. code-block:: bash
usage: ze2nb [-h] [-i INPUT] [--run-all] [--out-path OUT_PATH] [--to-html]
[--to-py]
optional arguments:
-h, --help show this help message and exit
-i INPUT, --input INPUT
The input file_name
--run-all If set, walks through this directory and converts all
*.json to ipynb
--out-path OUT_PATH Output path
--to-html Converts to HTML
--to-py Converts to .py
| ze2nb-cli | /ze2nb-cli-1.0.2.tar.gz/ze2nb-cli-1.0.2/README.rst | README.rst |
# zeppelin2nb: Zeppelin to jupyter notebook
This is my Zeppelin notebook to jupyter notebook python library repositories. This library is based on Ryan Blue's Jupyter/Zeppelin conversion: https://github.com/rdblue/jupyter-zeppelin.
The ``API`` can be found at: https://runawayhorse001.github.io/ze2nb.
If you want to install it, you can
### Install from PyPI
You can install the zeppelin2nb from [PyPI](https://pypi.org/project/ze2nb):
pip install ze2nb
### Install from Repo
Or you can install the zeppelin2nb from the repo:
#### 1. clone
git clone https://github.com/runawayhorse001/ze2nb.git
#### 2. install
cd ze2nb
pip install -r requirements.txt
python setup.py install
#### 3. test
cd zeppelin2nb/test
python demo.py
#### 4. uninstall
pip uninstall ze2nb
| ze2nb | /ze2nb-1.0.0.tar.gz/ze2nb-1.0.0/README.md | README.md |
from __future__ import annotations
import argparse
import random
from pathlib import Path
import requests
from platformdirs import user_runtime_path
from rich.live import Live
from rich.progress import Progress
from rich.spinner import Spinner
from zeal_feeds import ApplicationError, user_contrib, zeal
def main():
"""Parse command line arguments and run sub-command."""
parser = argparse.ArgumentParser(
prog="zeal-feeds", description="Install user contributed Docsets into Zeal"
)
subparsers = parser.add_subparsers()
install_parser = subparsers.add_parser("install", help="install docsets")
install_parser.add_argument("docset", metavar="DOCSET", nargs="+")
install_parser.add_argument("--url", default=user_contrib.USER_DOCSET_API)
install_parser.set_defaults(func=install)
search_parser = subparsers.add_parser("search", help="search available docsets")
search_parser.add_argument("text", metavar="TEXT")
search_parser.add_argument("--url", default=user_contrib.USER_DOCSET_API)
search_parser.set_defaults(func=search)
args = parser.parse_args()
if not hasattr(args, "func"):
parser.print_help()
return 1
try:
return args.func(args)
except ApplicationError as exc:
return str(exc)
def search(args) -> str | None:
"""Search for matching docsets."""
docset_data = _load_docset_index(args.url)
fallback = False
search_text = args.text
matches = sorted(docset_data.search(search_text))
if not matches:
matches = sorted(docset_data.fallback_search(search_text))
fallback = True
if not matches:
return "No matching docsets found"
if fallback:
print("No exact matches, did you mean:")
else:
print("Matching docsets:")
for docset in matches:
print(docset)
return None
def install(args) -> str | None:
"""Install the specified DocSets."""
docset_data = _load_docset_index(args.url)
docset_names = args.docset
found_docsets = {name: docset_data.get(name) for name in docset_names}
missing_docsets = [name for name, docset in found_docsets.items() if docset is None]
if missing_docsets:
return f"Failed to find the following docsets: {', '.join(missing_docsets)}"
installed_docsets = set(zeal.installed_docsets())
for docset in found_docsets.values():
if docset is None:
continue
if docset.name in installed_docsets:
print(f"Skipping {docset.name}, already installed")
continue
archive = _download_archive(docset)
spinner = Spinner("simpleDots", f"Installing {docset.name}")
with Live(spinner):
zeal.install(docset, archive)
archive.unlink()
return None
def _load_docset_index(url: str) -> user_contrib.DocSetCollection:
"""Load the docset index, with a spinner."""
if docsets := user_contrib.load_cached_index():
# should I use Rich for "normal" output?
print("Using cached index of user contributed docsets")
return docsets
spinner = Spinner("dots", "Loading index of user contributed docsets")
with Live(spinner):
return user_contrib.user_contrib_index(url)
def _download_archive(docset: user_contrib.DocSet) -> Path:
"""Download the docset archive, from a random mirror, with progress bar.
According to *zeal-user-contrib*, the random URL is what *Zeal* does.
"""
archive_url = random.choice(docset.urls)
archive_destination = user_runtime_path("zeal-feeds") / docset.archive
archive_destination.parent.mkdir(exist_ok=True, parents=True)
with (
requests.get(archive_url, stream=True) as r,
Progress() as progress,
archive_destination.open("wb") as archive,
):
file_size = int(r.headers["content-length"])
download_task = progress.add_task(f"Downloading {docset.name}", total=file_size)
for content in r.iter_content(chunk_size=512):
archive.write(content)
progress.update(download_task, advance=len(content))
return archive_destination | zeal-feeds | /zeal_feeds-0.2.1-py3-none-any.whl/zeal_feeds/main.py | main.py |
"""Functionality related to fetching the user contributed docsets."""
from __future__ import annotations
import json
import time
from collections.abc import Iterable, Iterator, Mapping
from typing import Optional
import attrs
import requests
from cattrs import Converter
from cattrs.gen import make_dict_structure_fn, override
from platformdirs import user_data_path
from . import APP_NAME, ApplicationError
USER_DOCSET_API = "https://zealusercontributions.vercel.app/api/docsets"
_CACHE_FILENAME = "docsets.json"
@attrs.define
class DocSet:
"""Model the user contributed docset data."""
name: str
author: DocSetAuthor
archive: str
version: str
aliases: list[str] = attrs.field(factory=list)
urls: list[str] = attrs.field(factory=list)
icon: str = attrs.field(default=None, eq=False, repr=False)
icon_2x: str = attrs.field(default=None, eq=False, repr=False)
@property
def title(self) -> str:
"""Pretty name of Docset."""
return self.name.replace("_", " ")
def __str__(self):
return f"{self.name} ({self.version})"
def __lt__(self, other: DocSet):
return self.name < other.name
class DocSetCollection(Mapping[str, DocSet]):
"""Collection of DocSet information.
This mapping is keyed by the DocSet ID,
and provides other methods for searching the collection.
"""
def __init__(self, docsets: Iterable[DocSet]):
self._docsets = {self._normalize(docset.name): docset for docset in docsets}
def __getitem__(self, item: str) -> DocSet:
return self._docsets[self._normalize(item)]
def __len__(self) -> int:
return len(self._docsets)
def __iter__(self):
return iter(self._docsets)
def search(self, text: str) -> Iterator[DocSet]:
"""Yield packages that match the provided name."""
text = self._normalize(text)
for id_, docset in self._docsets.items():
if text in id_:
yield docset
continue
if text in self._normalize(docset.title):
yield docset
continue
if self._search_aliases(text, docset.aliases):
yield docset
continue
def fallback_search(self, text: str) -> Iterator[DocSet]:
"""Yield packages that approximately match the provided name."""
text = self._normalize(text)
for id_, docset in self._docsets.items():
if _edit_distance(text, id_) <= 2:
yield docset
@staticmethod
def _normalize(value: str) -> str:
return value.lower()
def _search_aliases(self, text: str, aliases: list[str]) -> bool:
return any(text in self._normalize(alias) for alias in aliases)
@attrs.define
class DocSetAuthor:
"""Model author for user contributed docset."""
name: str
link: str
def __str__(self):
return f"{self.name} ({self.link})"
@attrs.define
class DocSetVersion:
"""Model version for user contributed docset."""
version: str
archive: str
# *cattrs* evaluations this type hint, so we cannot use | when <= py3.10
author: Optional[DocSetAuthor] = None
@attrs.define
class DocSetComment:
"""Model comment for user contributed docset."""
_comment: str
def user_contrib_index(docset_index: str) -> DocSetCollection:
"""Get the user contributed docset index information."""
r = requests.get(docset_index)
if not r.ok:
raise ApplicationError(
"Failed to load information about user contributed docsets"
)
index_json = r.json()
cached_index = user_data_path(APP_NAME) / _CACHE_FILENAME
cached_index.parent.mkdir(exist_ok=True, parents=True)
json.dump(index_json, cached_index.open("w"))
return DocSetCollection(_parse_docset_index(index_json))
def load_cached_index() -> DocSetCollection | None:
"""Try to load cached Docset index.json.
Checks for existence of cached file and that it is less than 12 hours old.
"""
cached_index = user_data_path(APP_NAME) / _CACHE_FILENAME
if not cached_index.exists():
return None
cache_updated = cached_index.stat().st_mtime
if time.time() - cache_updated > 43_200: # 12 hours in seconds
return None
cached_json = json.load(cached_index.open("r"))
return DocSetCollection(_parse_docset_index(cached_json))
def _parse_docset_index(index_json: dict) -> Iterator[DocSet]:
"""Yield docset data models from the `/api/docsets` data."""
converter = Converter()
# map "icon@2x" in JSON to "icon_2x" in dataclass
converter.register_structure_hook(
DocSet,
make_dict_structure_fn(DocSet, converter, icon_2x=override(rename="icon@2x")),
)
for docset in index_json:
yield converter.structure(docset, DocSet)
def _edit_distance(pattern: str, target: str) -> int:
len_a, len_b = len(pattern), len(target)
d = _edit_distance_matrix(len_a, len_b)
for i, pattern_char in enumerate(pattern, start=1):
for j, target_char in enumerate(target, start=1):
cost = int(pattern_char != target_char)
d[i][j] = min(
d[i - 1][j] + 1, # deletion
d[i][j - 1] + 1, # insertion
d[i - 1][j - 1] + cost, # substitution
)
return d[len_a][len_b]
def _edit_distance_matrix(pattern_length: int, target_length: int) -> list[list[int]]:
rows, cols = pattern_length + 1, target_length + 1
d = []
for _ in range(rows):
d.append([0] * cols)
for i in range(rows):
d[i][0] = i
for j in range(cols):
d[0][j] = j
return d | zeal-feeds | /zeal_feeds-0.2.1-py3-none-any.whl/zeal_feeds/user_contrib.py | user_contrib.py |
"""Functionality related to Zeal application."""
from __future__ import annotations
import functools
import json
import re
import sys
import tarfile
from collections.abc import Iterator
from configparser import ConfigParser
from pathlib import Path
import attrs
from cattrs import Converter
from platformdirs import user_config_path
from . import ApplicationError
from .user_contrib import DocSet
@attrs.define
class MetaData:
"""Model metadata to save with DocSet for Zeal."""
name: str
title: str
version: str
feed_url: str
urls: list[str]
FEED_URL = "https://zealusercontributions.vercel.app/api/docsets/{name}.xml"
@functools.cache
def docset_install_path() -> Path:
"""Get the path where Docsets are installed to."""
if sys.platform == "win32":
install_path = _windows_docset_install_path()
else:
install_path = _linux_docset_install_path()
if not install_path.exists():
install_path.mkdir(parents=True)
return install_path
def installed_docsets() -> Iterator[str]:
"""List of locally installed DocSets."""
docset_path = docset_install_path()
for meta_json in docset_path.glob("*/meta.json"):
metadata = json.load(meta_json.open("r"))
yield metadata["name"]
def install(docset: DocSet, tarball: Path):
"""Install a docset into the Zeal data directory."""
# TODO: don't install if docset already installed
docset_path = docset_install_path()
with tarfile.open(tarball) as docset_archive:
docset_folder = docset_archive.next()
if not (docset_folder and re.match(r"\w+\.docset", docset_folder.name)):
raise ApplicationError(f"Unexpected contents for {docset.name} archive")
docset_archive.extractall(docset_path)
converter = Converter()
meta_json = docset_path / docset_folder.name / "meta.json"
metadata = MetaData(
name=docset.name,
title=docset.title,
version=docset.version,
urls=docset.urls,
feed_url=FEED_URL.format(name=docset.name),
)
json.dump(converter.unstructure(metadata), meta_json.open("w"), indent=2)
def _linux_docset_install_path() -> Path:
"""Get the docset path from the Zeal configuration file."""
config_file = user_config_path("Zeal") / "Zeal.conf"
if not config_file.exists():
raise ApplicationError("Zeal configuration not found.")
zeal_config = ConfigParser()
zeal_config.read_file(config_file.open())
docset_path = zeal_config.get("docsets", "path")
return Path(docset_path)
def _windows_docset_install_path() -> Path:
"""Get the docset path from the Zeal registry entries."""
# gatekeeper so that mypy doesn't choke on `winreg` in Linux
if sys.platform != "win32":
raise RuntimeError("Incorrect platform for Windows registry")
import winreg
try:
with winreg.OpenKey(
winreg.HKEY_CURRENT_USER, r"SOFTWARE\Zeal\Zeal\docsets"
) as key:
docset_path = winreg.QueryValueEx(key, "path")[0]
except OSError as exc:
raise ApplicationError(
f"Failed to read docset path from registry: {exc}"
) from None
return Path(docset_path) | zeal-feeds | /zeal_feeds-0.2.1-py3-none-any.whl/zeal_feeds/zeal.py | zeal.py |
# Zealous Framework
[](https://gitlab.com/python-zealous/zealous/badges/master/pipeline.svg)
[](https://gitlab.com/python-zealous/zealous/badges/master/coverage.svg)
---
**Documentation:** <https://python-zealous.gitlab.io/zealous/>
**Source Code:** <https://gitlab.com/python-zealous/zealous>
---
Zealous is a framework that aims to simplify specification-driven development.
It is built from the ground up with emphasis on static type checking to ensure that the
specification is respected while developing around it.
The framework's core elements run in an asyncio event loop so concurrency is supported
out of the box.
| zealous | /zealous-0.2.4.tar.gz/zealous-0.2.4/README.md | README.md |
==============
zeam.component
==============
``zeam.component`` is inspired by ``zope.component`` and
``grokcore.component``, but stays much simpler, and have less
base concepts. Hopefully this improve flexibility.
Registration
------------
A base class can be used to register a component,
``zeam.component.Component``. It supports all the directives
``grok.context``, ``grok.adapts``, ``grok.provides`` and ``grok.name``
like they are defined in Grok. You can use those to register your
component as either an Utility, an (named) Adapter or a (named)
MultiAdapter.
An another possibility to register a component is to use the
``component`` decorator, ``zeam.component.component``. It takes as
arguments the interfaces that the component adapts, and as keyword
arguments, ``provides`` the `Interface` that the component provides,
and as ``name`` the name under which it will be registered.
Lookup
------
You can lookup a specific registered component with
``zeam.component.getComponent``. You can optionally provide:
- ``specs``: a tuple of objects or specifications that the component
must adapt in order to be returned.
- ``provided``: an `Interface` that the component must provides in
order to be returned.
- ``name``: a name under which the component must be registered in
order to be returned.
- ``default``: a default value that will be returned if no component
match the requirements. If you no default value is provided, and no
component is found, an exception will be triggered.
You can lookup a list of possible registered component with
``zeam.component.getAllComponents``. You can optionally provide:
- ``specs``: tuple of objects or specification stat the component must
adapt in order to be returned.
- ``provided``: an `Interface` that the component must provides in
order to be returned.
Please note that in both cases the component is directly returned. In
any case, no construction is done with the result of the lookup.
An helper ``zeam.component.getWrapper`` that support the same options
than the ``zeam.component.getComponent`` function will call the result
of the lookup passing as argument the values given as ``specs`` to
it. This is used in order to have a `getAdapter` or `queryAdapter`
like behavior. Please note that if an error happens during the
initialization of the component, the error won't be catched for you.
| zeam.component | /zeam.component-1.0.tar.gz/zeam.component-1.0/README.txt | README.txt |
from zope.interface import Interface, providedBy, implementedBy
from zope.interface.adapter import AdapterRegistry
from zope.interface.interfaces import ISpecification
from zope.testing.cleanup import addCleanUp
from zeam.component.components import ComponentLookupError
def specificationOfInstance(obj):
if ISpecification.providedBy(obj):
return obj
return providedBy(obj)
def specificationOfClass(obj):
if ISpecification.providedBy(obj):
return obj
return implementedBy(obj)
def readSpecification(specs, transformer):
if isinstance(specs, (list, tuple)):
return tuple(transformer(spec) for spec in specs)
return (transformer(specs),)
class Site(object):
def __init__(self):
self.clear()
def lookup(self, specs=(), provided=Interface, name=u'', default=None):
specs = readSpecification(specs, specificationOfInstance)
return self.components.lookup(specs, provided, name, default)
def lookupAll(self, specs=(), provided=Interface):
specs = readSpecification(specs, specificationOfInstance)
return self.components.lookupAll(specs, provided)
def register(self, component, for_=None, provided=Interface, name=u''):
if for_ is None:
for_ = tuple()
else:
assert isinstance(for_, tuple) or ISpecification.providedBy(for_)
specs = readSpecification(for_, specificationOfClass)
self.components.register(specs, provided, name, component)
def unregister(self, for_=None, provided=Interface, name=u''):
if for_ is None:
for_ = tuple()
else:
assert isinstance(for_, tuple) or ISpecification.providedBy(for_)
specs = readSpecification(for_, specificationOfClass)
self.components.unregister(specs, provided, name)
def clear(self):
self.components = AdapterRegistry()
global_site = Site()
_marker = object()
addCleanUp(global_site.clear)
def getSite():
return global_site
def getComponent(specs=(), provided=Interface, name=u'', default=_marker):
component = getSite().lookup(specs, provided, name, default)
if component is _marker:
raise ComponentLookupError(specs, provided, name)
return component
def getAllComponents(specs=(), provided=Interface):
return getSite().lookupAll(specs, provided)
def getWrapper(specs=(), provided=Interface, name=u'', default=_marker):
if not isinstance(specs, tuple):
specs = (specs,)
component = getSite().lookup(specs, provided, name, default)
if component is _marker:
raise ComponentLookupError(specs, provided, name)
return component(*specs) | zeam.component | /zeam.component-1.0.tar.gz/zeam.component-1.0/src/zeam/component/site.py | site.py |
import martian
import zeam.component
import grokcore.component
from martian.error import GrokError
from martian.util import isclass
from zope.interface import Interface
from zope.interface.interfaces import ISpecification
from zeam.component.site import getSite
from zope.component import adaptedBy
OPTIONS = set(['name', 'provides'])
class DecoratedComponentGrokker(martian.GlobalGrokker):
def grok(self, name, module, module_info, config, **kw):
components = module_info.getAnnotation('zeam.components', [])
for factory, specs, options in components:
if set(options.keys()).difference(OPTIONS):
raise GrokError(u'There are unknown options for %s' % factory)
name = options.get('name', u'')
provides = options.get('provides', Interface)
validated_specs = []
for value in specs:
if value is None:
validated_specs.append(Interface)
elif ISpecification.providedBy(value) or isclass(value):
validated_specs.append(value)
else:
raise GrokError(
u"Invalid adaption argument %r for %r" % (
value, factory))
validated_specs = tuple(validated_specs)
config.action(
discriminator=('component', validated_specs, provides, name),
callable=getSite().register,
args=(factory, validated_specs, provides, name))
return len(components) != 0
class ComponentGrokker(martian.ClassGrokker):
martian.component(zeam.component.Component)
martian.directive(zeam.component.provides)
martian.directive(zeam.component.name)
def execute(self, factory, config, provides, name, **kw):
specs = adaptedBy(factory)
context = grokcore.component.context.bind(
get_default=lambda *args, **kwargs: None).get(factory)
validated_specs = []
if specs is None:
if context is not None:
validated_specs = [context,]
else:
default = context is not None and context or Interface
for value in specs:
if value is None:
validated_specs.append(default)
elif ISpecification.providedBy(value) or isclass(value):
validated_specs.append(value)
else:
raise GrokError(
u"Invalid adaption argument %r for %r" % (
value, factory))
validated_specs = tuple(validated_specs)
config.action(
discriminator=('component', validated_specs, provides, name),
callable=getSite().register,
args=(factory, validated_specs, provides, name))
return True | zeam.component | /zeam.component-1.0.tar.gz/zeam.component-1.0/src/zeam/component/martiansupport.py | martiansupport.py |
====================
zeam.form.autofields
====================
``zeam.form.autofields`` is able to collect fields definition for your
form. This enable you to create forms with a plugable list of fields.
.. contents::
Example
=======
You need first to define a group of fields. This will be just an
interface::
>>> from zope.interface import Interface
>>> class IReplyFields(Interface):
... pass
Now you can define groups of fields::
>>> from zeam.form import base, autofields
>>> class ReplyInformation(autofields.AutoFields):
... autofields.group(IReplyFields)
... autofields.order(0)
... fields = base.Fields(base.Field('Comment'))
>>> class ReplyBlogInformation(autofields.AutoFields):
... autofields.group(IReplyFields)
... autofields.order(10)
... fields = base.Fields(base.Field('Blog URL'))
And you will be able to use those fields on your form somewhere else::
>>> class ReplyForm(base.Form):
... fields = autofields.FieldsCollector(IReplyFields)
API
===
In addition to its API, ``zeam.form.autofields`` export the one of
``zeam.form.base``.
Classes
-------
``AutoFields``
Base classes used to define a group of Fields to be included in a form.
Directives
----------
``group``
Directive used on ``AutoFields`` which select for which group you
whish to provide the fields for. A group is just a plain zope
interface, that will be given as parameter to the
``FieldsCollector``.
``view``
Directive used on ``AutoFields`` that will let you specify for
which Form (or view) you whish to provide the fields for. This
directive is not required, and default to ``IBrowserView``.
``order``
Optional directive which let decide in wich order the fields will
included at the end.
Properties
----------
``FieldsCollector``
Property used to collect form Fields for you.
| zeam.form.autofields | /zeam.form.autofields-1.0.1.tar.gz/zeam.form.autofields-1.0.1/README.txt | README.txt |
==============
zeam.form.base
==============
Summary
=======
``zeam.form.base`` is a form framework for Zope. It has common goals
and purposes with ``formlib`` or ``z3c.form`` but tries to:
- define small sane and reusable components : you don't
need a full flavored form to render and display only few widgets in
your application,
- be easily customizable without using hundreds of adapters: most
of settings are set with properties on your form/fields,
- prevent ZCML declarations by using Grok to register the few needed
adapters (widgets and widgets value extractors),
- always keep the context untouched: the form works on a content
that can be something else than the context, it can even be a
dictionnary. That means everywhere in the form, including in
widgets, and actions, you can either access the context as the real
context of the form, and have a way to access the content that the
form is working on. This helps greatly if you have complicated
widgets working, including when they are embedded in other widgets
(like in a list or a table),
- let people easily change form templates, by using
``megrok.pagetemplate`` by default, selecting which fields goes
where they want,
- let people define easily their widgets, and use them,
- be able to create complex forms, like composed or table
forms, where each form can modify the data it needs without having
to hack-o-refresh other sub-forms: *all* actions are executed before
any widget compute its value to render,
By default, it is unware of things like Zope-schema. Generating fields
from a Zope-schema would be done with the help of ``zeam.form.ztk``.
It work with Python 2.6, 2.7 (tested in Zope 2.13 and Grok 1.5). Older
versions works for older versions of Zope 2 and Grok.
Example
=======
Let's define a quick example. Actions can be defined standalone::
from zeam.form.base import Action, SUCCESS
class MailAction(Action):
def available(self, form):
return form.context.haveMailHost()
def __call__(self, form):
# Send a mail
form.status = u"Mail sent"
return SUCCESS
And included as attributes to the form::
class MailForm(Form):
label = u"Send a mail"
description = u"to people"
fields = Fields(Field(u'Name'), Field(u'E-mail'), Field(u'Message'))
actions = Actions(MailAction(u'Send mail'))
(A decoractor can be used on a form method as well if you don't need
lot of code for your action).
For more information
====================
You can refer to the functional and doctest included in the
package. Since it tries to be composed of small components, there is
many way to put them together.
| zeam.form.base | /zeam.form.base-1.4.1.tar.gz/zeam.form.base-1.4.1/README.txt | README.txt |
import operator
import sys
import binascii
from grokcore import component as grok
from grokcore.view import util
from zeam.form.base import interfaces
from zeam.form.base.actions import Actions
from zeam.form.base.datamanager import ObjectDataManager
from zeam.form.base.errors import Errors, Error
from zeam.form.base.fields import Fields
from zeam.form.base.markers import NO_VALUE, INPUT
from zeam.form.base.widgets import Widgets, WidgetFactory
from zeam.form.base.interfaces import ICollection, IError, InvalidCSRFToken
from zope import component, interface
from zope.interface import implementer
from zope.cachedescriptors.property import Lazy
from zope.i18nmessageid import MessageFactory
from zope.pagetemplate.interfaces import IPageTemplate
from zope.publisher.browser import BrowserPage
from zope.publisher.interfaces.http import MethodNotAllowed
from zope.publisher.publish import mapply
_ = MessageFactory('zeam.form.base')
@implementer(interfaces.IGrokViewSupport)
class GrokViewSupport:
"""Support Grok view like behavior, without inheriting of Grok
view (not to get any grokker at all, or inherit from BrowerView,
BrowserPage).
The render method support IPageTemplate in addition to Grok template.
"""
grok.baseclass()
def __init__(self, context, request):
super(GrokViewSupport, self).__init__(context, request)
self.context = context
self.request = request
static_name = getattr(self, '__static_name__', None)
if static_name is not None:
self.static = component.queryAdapter(
self.request,
interface.Interface,
name=static_name)
if self.static is not None:
# For security in Zope 2
self.static.__parent__ = self
else:
self.static = None
@property
def response(self):
return self.request.response
def redirect(self, url):
self.response.redirect(url)
def url(self, obj=None, name=None, data=None):
"""Return string for the URL based on the obj and name. The data
argument is used to form a CGI query string.
"""
if isinstance(obj, str):
if name is not None:
raise TypeError(
'url() takes either obj argument, obj, string arguments, '
'or string argument')
name = obj
obj = None
if obj is None:
obj = self.context
if data is None:
data = {}
else:
if not isinstance(data, dict):
raise TypeError('url() data argument must be a dict.')
return util.url(self.request, obj, name, data=data)
def default_namespace(self):
namespace = {'view': self,
'context': self.context,
'static': self.static,
'request': self.request}
return namespace
def namespace(self):
return {}
def update(self):
pass
def render(self):
# Try grok template first
template = getattr(self, 'template', None)
if template is not None:
return self.template.render(self)
# Fallback on IPageTemplate
template = component.getMultiAdapter(
(self, self.request), IPageTemplate)
return template()
_marker = object()
def cloneFormData(original, content=_marker, prefix=None):
assert interfaces.IFieldExtractionValueSetting.providedBy(original)
clone = FormData(original.context, original.request, content)
clone.ignoreRequest = original.ignoreRequest
clone.ignoreContent = original.ignoreContent
clone.mode = original.mode
clone.parent = original
if prefix is None:
clone.prefix = original.prefix
else:
clone.prefix = prefix
# XXX Those fields are not checked by the interface
clone.methods = original.methods
clone.widgetFactoryFactory = original.widgetFactoryFactory
errors = original.errors.get(clone.prefix, None)
if errors is not None:
clone.errors = errors
return clone
class FieldsValues(dict):
"""Dictionary to contains values of fields. get default by default
on the default value of a field.
"""
def __init__(self, form, fields):
self.form = form
self.fields = fields
def getWithDefault(self, key, default=None):
value = super(FieldsValues, self).get(key, default)
if value is NO_VALUE:
value = self.fields[key].getDefaultValue(self.form)
if value is NO_VALUE:
return default
return value
def getDictWithDefault(self, default=None):
result = {}
for key in self.keys():
result[key] = self.getWithDefault(key, default=default)
return result
# BBB
getDefault = getWithDefault
@implementer(interfaces.IFormData)
class FormData:
"""This represent a submission of a form. It can be used to update
widgets and run actions.
"""
grok.baseclass()
prefix = 'form'
parent = None
mode = INPUT
dataManager = ObjectDataManager
dataValidators = []
widgetFactoryFactory = WidgetFactory
methods = frozenset(('POST', 'GET'))
ignoreRequest = False
ignoreContent = True
status = u''
def __init__(self, context, request, content=_marker):
self.context = context
self.request = request
self.errors = Errors()
self.__extracted = {}
self.__content = None
if content is _marker:
content = context
self.setContentData(content)
@Lazy
def widgetFactory(self):
return self.widgetFactoryFactory(self, self.request)
@property
def formErrors(self):
error = self.errors.get(self.prefix, None)
if error is None:
return []
if ICollection.providedBy(error):
return error
return [error]
def htmlId(self):
return self.prefix.replace('.', '-')
def getContent(self):
# Shortcut for actions. You should not reimplement that method
# but getContentData.
return self.getContentData().getContent()
def getContentData(self):
return self.__content
def setContentData(self, content):
if not interfaces.IDataManager.providedBy(content):
content = self.dataManager(content)
self.__content = content
def validateData(self, fields, data):
errors = Errors()
for factory in self.dataValidators:
validator = factory(self, fields)
for error in validator.validate(data):
if not IError.providedBy(error):
error = Error(error, self.prefix)
errors.append(error)
return errors
def extractData(self, fields):
# XXX to review this
cached = self.__extracted.get(fields)
if cached is not None:
return cached
data = FieldsValues(self, fields)
self.errors = errors = Errors()
self.__extracted[fields] = (data, errors)
for field in fields:
if not field.available(self):
continue
# Widget extraction and validation
extractor = self.widgetFactory.extractor(field)
if extractor is not None:
value, error = extractor.extract()
if error is None:
error = field.validate(value, self)
if error is not None:
if not IError.providedBy(error):
error = Error(error, extractor.identifier)
errors.append(error)
data[field.identifier] = value
# Generic form validation
errors.extend(self.validateData(fields, data))
if len(errors):
# Add a form level error if not already present
if self.prefix not in errors:
errors.append(Error(_(u"There were errors."), self.prefix))
self.errors = errors
return (data, errors)
class FormCanvas(GrokViewSupport, FormData):
"""This represent a sumple form setup: setup some fields and
actions, prepare widgets for it.
"""
grok.baseclass()
grok.implements(interfaces.ISimpleFormCanvas)
label = u''
description = u''
actions = Actions()
fields = Fields()
protected = False
csrftoken = None
def __init__(self, context, request):
super(FormCanvas, self).__init__(context, request)
self.actionWidgets = Widgets(form=self, request=self.request)
self.fieldWidgets = Widgets(form=self, request=self.request)
def setUpToken(self):
self.csrftoken = self.request.getCookies().get('__csrftoken__')
if self.csrftoken is None:
# It is possible another form, that is rendered as part of
# this request, already set a csrftoken. In that case we
# should find it in the response cookie and use that.
setcookie = self.request.response.getCookie('__csrftoken__')
if setcookie is not None:
self.csrftoken = setcookie['value']
else:
# Ok, nothing found, we should generate one and set
# it in the cookie ourselves. Note how we ``str()``
# the hex value of the ``os.urandom`` call here, as
# Python-3 will return bytes and the cookie roundtrip
# of a bytes values gets messed up.
self.csrftoken = str(binascii.hexlify(os.urandom(32)))
self.request.response.setCookie(
'__csrftoken__',
self.csrftoken,
path='/',
expires=None, # equivalent to "remove on browser quit"
httpOnly=True, # no javascript access please.
)
def checkToken(self):
cookietoken = self.request.getCookies().get('__csrftoken__')
if cookietoken is None:
# CSRF is enabled, so we really should get a token from the
# cookie. We didn't get it, so this submit is invalid!
raise InvalidCSRFToken(_('Invalid CSRF token'))
if cookietoken != self.request.form.get('__csrftoken__', None):
# The token in the cookie is different from the one in the
# form data. This submit is invalid!
raise InvalidCSRFToken(_('Invalid CSRF token'))
def extractData(self, fields=None):
if fields is None:
fields = self.fields
return super(FormCanvas, self).extractData(fields)
def haveRequiredFields(self):
for field in self.fields:
if field.required:
return True
return False
def updateActions(self):
if self.protected:
# This form has CSRF protection enabled.
self.checkToken()
return self.actions.process(self, self.request)
def updateWidgets(self):
self.fieldWidgets.extend(self.fields)
self.actionWidgets.extend(self.actions)
self.fieldWidgets.update()
self.actionWidgets.update()
class StandaloneForm(GrokViewSupport, BrowserPage):
"""This is a base for a standalone form, process the form.
"""
grok.baseclass()
def updateActions(self):
return self, None, None
def updateWidgets(self):
pass
def updateForm(self):
self.updateActions()
self.updateWidgets()
def __call__(self):
mapply(self.update, (), self.request)
if self.response.getStatus() in (302, 303):
# A redirect was triggered somewhere in update(). Don't
# continue processing the form
return
self.updateForm()
if self.response.getStatus() in (302, 303):
return
return self.render()
@implementer(interfaces.ISimpleForm)
class Form(FormCanvas, StandaloneForm):
"""A full simple standalone form.
"""
grok.baseclass()
def extends(*forms, **opts):
# Extend a class with parents components
field_type = opts.get('fields', 'all')
def extendComponent(field_type):
factory = {'actions': Actions, 'fields': Fields}.get(field_type)
if factory is None:
raise ValueError(u"Invalid parameter fields to extends")
frame = sys._getframe(2)
f_locals = frame.f_locals
components = f_locals.setdefault(field_type, factory())
components.extend(*map(operator.attrgetter(field_type), forms))
if field_type == 'all':
extendComponent('actions')
extendComponent('fields')
else:
extendComponent(field_type) | zeam.form.base | /zeam.form.base-1.4.1.tar.gz/zeam.form.base-1.4.1/src/zeam/form/base/form.py | form.py |
from zeam.form.base.interfaces import IDataManager
from zope.interface import implements, implementer
@implementer(IDataManager)
class BaseDataManager:
"""Base class for a data manager.
"""
def __init__(self, content):
self.content = content
def getContent(self):
return self.content
def get(self, identifier):
raise NotImplementedError
def set(self, identifier, value):
raise NotImplementedError
def delete(self, identifier):
raise NotImplementedError
def __repr__(self):
return '<%s used for %r>' % (self.__class__.__name__, self.content)
class ObjectDataManager(BaseDataManager):
"""An object data manager, which look up data as attributes on
objects.
"""
def get(self, identifier):
try:
return getattr(self.content, identifier)
except AttributeError:
raise KeyError(identifier)
def set(self, identifier, value):
setattr(self.content, identifier, value)
def delete(self, identifier):
try:
delattr(self.content, identifier)
except AttributeError:
raise KeyError(identifier)
class DictDataManager(BaseDataManager):
"""A dictionary data manager, which look up data as keys in the
dictionary.
"""
def get(self, identifier):
return self.content[identifier]
def set(self, identifier, value):
self.content[identifier] = value
def delete(self, identifier):
del self.content[identifier]
class NoneDataManager(BaseDataManager):
"""A null data manager, which return directly the given object as
data.
"""
def get(self, identifier):
return self.content
def makeAdaptiveDataManager(interface):
class AdaptiveDataManager(ObjectDataManager):
"""A data manager that adapt its content to an interface
before doing anything.
"""
def __init__(self, content):
self.content = interface(content)
return AdaptiveDataManager | zeam.form.base | /zeam.form.base-1.4.1.tar.gz/zeam.form.base-1.4.1/src/zeam/form/base/datamanager.py | datamanager.py |
from zope import interface
from zope.publisher.interfaces.browser import IBrowserPage
class IInvalidCSRFToken(interface.Interface):
def doc():
"""The form submit could not be handled as the CSRF token is missing
or incorrect.
"""
@interface.implementer(IInvalidCSRFToken)
class InvalidCSRFToken(Exception):
"""The form submit could not be handled as the CSRF token is missing
or incorrect.
"""
class IModeMarker(interface.Interface):
"""This interface identifies a form mode and defines if it allows
data extraction.
"""
extractable = interface.Attribute(
u"Boolean allowing or not the extraction of the data,"
u" for components in that mode.")
class IComponent(interface.Interface):
"""A named component.
"""
identifier = interface.Attribute(u"Component id")
title = interface.Attribute(u"Component title")
order = interface.Attribute(u"Integer used to specify component order")
def clone(new_identifier=None):
"""Return a clone of the new component, with identifier
new_identifier if it is not None.
"""
class IComponentFactory(interface.Interface):
"""Component used to built components.
"""
def produce(self):
"""Should generate components.
"""
class IIterable(interface.Interface):
"""An iterable that return a component upon each iteration.
"""
def __iter__():
"""Return an iterator on the components.
"""
class ICollection(IIterable):
"""Support to manage a collection of ordered named components.
"""
type = interface.Attribute(
u"Interface restricting the type of component")
factory = interface.Attribute(
u"Interface to query in order to get a factory to extend "
u"collection with unknow components.")
def append(component):
"""Add a new component to the collection. Modify the current
collection.
"""
def extend(*component):
"""Create/Add a list of components to the collection. Modify
the current collection.
"""
def get(id, default=None):
"""Return the component with the given ID.
"""
def select(*ids):
"""Return a copy containing only the given named components.
"""
def omit(*ids):
"""Return a copy containing all but none of the given named
components.
"""
def copy():
"""Return a copy of the collection.
"""
def clear():
"""Empty the collection: remove all components from it.
"""
def keys():
"""Return all components id contained in the collection.
"""
def __add__(other):
"""Create a collection as copy of self, and add value for
other component or collection.
"""
def __getitem__(id):
"""Return the given component identified by id or raise
KeyError.
"""
def __contains__(id):
"""Return true if the collection contains a component
identified by id.
"""
def __len__():
"""Return the numbre of components.
"""
class IMutableCollection(ICollection):
"""A collection that can be changed.
"""
def set(id , value):
"""Change component associated to this id.
"""
def __setitem__(id, value):
"""Change component associated to this id.
"""
def __delitem__(id):
"""Remove the component associated to this id.
"""
class IPrefixable(interface.Interface):
"""An object with a prefix.
"""
prefix = interface.Attribute("Prefix")
class IRenderableComponent(IPrefixable, IComponent):
"""A component that can be rendered with the help of a widget.
"""
mode = interface.Attribute(
u"Mode should be used to render the component")
def available(form):
"""Return a boolean to qualify if the component wants to be
rendered in the given context (i.e. form).
"""
class IFieldExtractionValueSetting(IPrefixable):
"""Setting to extract field values.
"""
ignoreRequest = interface.Attribute(u"Ignore request values")
ignoreContent = interface.Attribute(u"Ignore content values")
mode = interface.Attribute(
u"Mode should be used to render all the widgets")
class IDataManager(interface.Interface):
"""A data manager let you access content.
"""
def __init__(content):
"""Initialize the data manager for the given content.
"""
def getContent():
"""Return the content managed by this data manager.
"""
def get(identifier):
"""Return content value associated to the given identifier or
raise KeyError.
"""
def set(identifier, value):
"""Modifiy content value associated to the given identifier.
"""
def delete(identifier):
"""Return the content value associated with the given identifier.
"""
class IFormData(IFieldExtractionValueSetting):
"""Form data processing facilities.
"""
dataManager = interface.Attribute(
u"Data manager class used to access content.")
dataValidators = interface.Attribute(
u"List of extra validators that must be called.")
status = interface.Attribute(
u"Form status message.")
errors = interface.Attribute(
u"Iterable of the errors that occured during the form processing.")
formErrors = interface.Attribute(
u"Main errors that occurred during the form processing.")
widgetFactory = interface.Attribute(
u"Callable used to create new widgets."
u"Called with the form, field and request.")
def getContent():
"""Return the content that is used by the form.
"""
def getContentData():
"""Returns a data manager that work on the content used by the
form.
"""
def setContentData(content):
"""Sets the content that will be used as the form processing context.
"""
def validateData(fields, data):
"""Validates the form in a global way and returns a collection
of errors (if any occured).
"""
def extractData(fields):
"""Returns the form data and errors for the given fields.
"""
class ActionError(Exception):
"""A error happening while processing the form.
"""
class IAction(IRenderableComponent):
"""A form action.
"""
description = interface.Attribute(u"Describe the action")
accesskey = interface.Attribute(u"Accesskey for the action")
html5Validation = interface.Attribute(
u"Enable HTML5 validation for this action")
def validate(form):
"""Self validation of values in order to run.
"""
def __call__(form):
"""Execute the action.
"""
class IActions(ICollection):
"""A list of actions.
"""
def process(form, request):
"""Execute actions.
"""
class IField(IRenderableComponent, IFieldExtractionValueSetting):
"""A form field.
"""
description = interface.Attribute(
u"Field description")
required = interface.Attribute(
u"Boolean indicating if the field is required")
readonly = interface.Attribute(
u"Boolean indicating if the field is read-only")
htmlAttributes = interface.Attribute(
u"Dictionnary with extra html attributes to add to the field")
interface = interface.Attribute(
u"Optional Zope interface associated to the field")
def getDefaultValue(form):
"""Return the default value.
"""
def validate(value, form):
"""Validate that the given value fullfil the field
requirement.
"""
class IFieldFactory(IComponentFactory):
"""Factory to create zeam.form Fields from other components than
zeam.form ones.
"""
class IFields(ICollection):
"""A collection of fields.
"""
class IError(IComponent):
"""A error.
"""
def get(prefix, default=None):
"""Return a sub error identified by the given prefix if
available.
"""
class IErrors(IMutableCollection):
"""A collection of errors.
"""
class IWidget(IComponent):
"""Display a form component on the page.
"""
defaultHtmlClass = interface.Attribute(
u"List of default html class to apply to the widget")
defaultHtmlAttributes = interface.Attribute(
u"Set of default authorized html attributes (without data- attributes)")
alternateLayout = interface.Attribute(
u"Boolean indicating if the widget can be rendered in a compact way")
def htmlId():
"""Return the HTML id of the HTML component representing the
widget.
"""
def htmlClass():
"""Return an HTML class to mark the widget with.
"""
def htmlAttribute(name):
"""Return the value of the given extra HTML attribute.
"""
def htmlAttributes():
"""Return a dictionary with all authorized extra HTML attributes.
"""
def isVisible():
"""Return True if the widget will render something visible in
the rendered HTML.
"""
def update():
"""Update the widget. This must be called before render.
"""
def render():
"""Return the rendered HTML of the widget.
"""
class IWidgetFactory(interface.Interface):
"""Adapt a form to create widgets.
"""
def __init__(form, request):
"""Create a factory.
"""
def widget(field):
"""Create a widget for the given field.
"""
def extractor(field):
"""Create a widget extractor for the given field.
"""
class IFieldWidget(IWidget):
"""Widget for fields.
"""
description = interface.Attribute(
u"Description of the field")
error = interface.Attribute(
u"Field error, or None")
required = interface.Attribute(
u"Boolean indicating if the field is required")
class IWidgetExtractor(interface.Interface):
"""The counterpart of the Widget, used to extract widget value
from the request.
"""
def extract():
"""Return a tuple (value, error). Value must be a valid field
value. If error is not None, value is discarded.
"""
def extractRaw():
"""Return request entries needed for the widget to redisplay
the same information in case of validation failure.
"""
class IWidgets(ICollection):
"""A collection of widgets.
"""
class IGrokViewSupport(interface.Interface):
"""Some usefull methods from Grok View.
"""
response = interface.Attribute(
u"Response object that is associated with the current request.")
def redirect(url):
"""Redirect to given URL.
"""
def url(obj=None, name=None, data=None):
"""Compute an URL to an object (or self), and add a name, and
maybe some data.
"""
def update():
"""User defined pre-update.
"""
def render():
"""Render the form.
"""
class IFormCanvas(IPrefixable, IFieldExtractionValueSetting, IGrokViewSupport):
"""Definition of a form structure.
Form presentation : label, description
Form contents and actions : fields, actions and their related methods.
"""
label = interface.Attribute(u"Form title")
description = interface.Attribute(u"Form description")
actions = interface.Attribute(u"Form actions")
fields = interface.Attribute(u"Form fields")
def htmlId():
"""Return an identifier that can be used in the HTML code to
identify the form.
"""
def haveRequiredFields():
"""Return an boolean True if any of the fields are required.
"""
def updateActions():
"""Set up and run form actions.
"""
def updateWidgets():
"""Set up rendering field / action widgets and their value to
display.
"""
class ISimpleFormCanvas(IFormCanvas, IFormData):
"""A simple form canvas with only fields and actions.
"""
actionWidgets = interface.Attribute(u"Form widgets")
fieldWidgets = interface.Attribute(u"Form widgets")
class IForm(IBrowserPage, IFormCanvas):
"""Regular form containing fields and actions, that you can call,
and will be updated and rendered.
"""
def updateForm():
"""Update the form mechanism (setup fields, actions, run
actions, setup widgets).
"""
def __call__():
"""Update and render the form.
"""
class ISimpleForm(IForm, ISimpleFormCanvas):
"""A simple form, with fields and actions.
"""
class IZeamFormBaseAPI(interface.Interface):
"""Base zeam form API.
"""
Action = interface.Attribute(
u"A form action")
Actions = interface.Attribute(
u"A collection of actions")
CompoundActions = interface.Attribute(
u"A collection of actions that can be managed differently")
Field = interface.Attribute(
u"A form field")
Fields = interface.Attribute(
u"A collection of fields")
Error = interface.Attribute(
u"An error")
Errors = interface.Attribute(
u"A collection of errors")
Widgets = interface.Attribute(
u"A collection of widgets")
FormData = interface.Attribute(
u"A configuration object to render fields as widgets")
Form = interface.Attribute(
u"A basic and simple Form")
ActionError = interface.Attribute(
u"An error occuring while processing an Action")
action = interface.Attribute(
u"Decorator to use a form method as an Action")
ObjectDataManager = interface.Attribute(
u"Data manager to work with values as attribute of an object")
DictDataManager = interface.Attribute(
u"Data manager to work with values in dictionary")
NoneDataManager = interface.Attribute(
u"Data manager to work directly with a value")
makeAdaptiveDataManager = interface.Attribute(
u"Data manager to work with from an simple adapter")
context = interface.Attribute(
u"Directive to map form to a context")
name = interface.Attribute(
u"Directive to name a form")
layer = interface.Attribute(
u"Directive to specify a form layer")
template = interface.Attribute(
u"Directive to specify a grok template to render the form")
require = interface.Attribute(
u"Directive to require a permission to access the form")
NO_VALUE = interface.Attribute(
u"Marker to mark the absence of a value")
NO_CHANGE = interface.Attribute(
u"Marker to mark the non-modification of a value")
DISPLAY = interface.Attribute(
u"Marker for mode to get display widgets")
INPUT = interface.Attribute(
u"Marker for mode to get input widgets")
HIDDEN = interface.Attribute(
u"Marker for mode to get hidden widgets")
DEFAULT = interface.Attribute(
u"Marker used to use the default value located on the form")
SUCCESS = interface.Attribute(
u"Marker used by actions to report a success")
FAILURE = interface.Attribute(
u"Marker used by actions to report a failure")
NOTHING_DONE = interface.Attribute(
u"Marker used by actions to report the absence of activity") | zeam.form.base | /zeam.form.base-1.4.1.tar.gz/zeam.form.base-1.4.1/src/zeam/form/base/interfaces.py | interfaces.py |
import re
import operator
import binascii
from pkg_resources import iter_entry_points
from zope import component
from zope.interface import implementer
from zope.testing import cleanup
from zeam.form.base import interfaces
_valid_identifier = re.compile('[A-Za-z][A-Za-z0-9_-]*$')
_default_sort_key = operator.attrgetter('order')
def createId(name) -> str:
# Create a valid id from any string.
name = str(name)
identifier = name.strip().replace(' ', '-')
if _valid_identifier.match(identifier):
return identifier.lower()
return bytes(identifier, 'utf-8').hex()
@implementer(interfaces.IComponent)
class Component:
identifier = None
title = None
# This help to reorder components.
order = 0
def __init__(self, title=None, identifier=None):
if not self.title:
if not title:
# If the title is empty, use the identifier as title
title = identifier
if title is None:
raise ValueError(
u"Need at least a title to build a component.")
self.title = title
if identifier is None:
identifier = createId(self.title)
self.identifier = str(identifier)
def clone(self, new_identifier=None):
return self.__class__(self.title, new_identifier)
def __repr__(self):
return "<%s %s>" % (self.__class__.__name__, self.title)
_marker = object()
_loaded = False
def loadComponents():
"""Goes through all available components loaders and call them.
"""
global _loaded
if _loaded:
return
for loader_entry in iter_entry_points('zeam.form.components'):
loader = loader_entry.load()
if not callable(loader):
raise TypeError(
'Entry point %r should be a callable to register components'
% loader_entry.name)
loader()
_loaded = True
def reloadComponents():
"""Reload all zeam components.
This is mainly used by testing layers.
"""
global _loaded
_loaded = False
loadComponents()
cleanup.addCleanUp(reloadComponents)
@implementer(interfaces.ICollection)
class Collection:
"""Represent a collection of components.
"""
type = interfaces.IComponent
factory = None
def __init__(self, *components, **options):
self.__options = {}
for name, value in options.items():
if name not in interfaces.ICollection:
self.__options[name] = value
self.__dict__.update(self.__options)
self.__ids = []
self.__components = []
if len(components):
self.extend(*components)
def reverse(self):
self.__components = [c for c in reversed(self.__components)]
self.__ids = [c.identifier for c in self.__components]
def sort(self, key=_default_sort_key, reverse=False):
self.__components.sort(key=key, reverse=reverse)
self.__ids = [c.identifier for c in self.__components]
def clear(self):
self.__ids = []
self.__components = []
def get(self, id, default=_marker):
id = str(id)
try:
return self.__components[self.__ids.index(id)]
except ValueError:
if default is _marker:
raise KeyError(id)
return default
def set(self, id, value):
if not interfaces.IMutableCollection.providedBy(self):
raise NotImplementedError
if not self.type.providedBy(value):
raise TypeError(value)
try:
self.__components[self.__ids.index(id)] = value
except ValueError:
raise KeyError(id)
def append(self, component):
if self.type.providedBy(component):
if component.identifier not in self.__ids:
if not component.order:
component.order = 10 * (len(self.__ids) + 1)
self.__ids.append(component.identifier)
self.__components.append(component)
else:
raise ValueError(
u"Duplicate identifier", component.identifier)
else:
raise TypeError(u"Invalid type", component)
def extend(self, *components):
for cmp in components:
if self.type.providedBy(cmp):
self.append(cmp)
elif interfaces.IIterable.providedBy(cmp):
for item in cmp:
self.append(item)
else:
if self.factory is not None:
loadComponents()
factory = component.queryAdapter(cmp, self.factory)
if factory is not None:
for item in factory.produce():
self.append(item)
continue
raise TypeError(u'Invalid type', cmp)
def select(self, *ids):
components = (c for c in self.__components if c.identifier in ids)
return self.__class__(*components, **self.__options)
def omit(self, *ids):
components = (c for c in self.__components if c.identifier not in ids)
return self.__class__(*components, **self.__options)
def copy(self):
return self.__class__(*self.__components, **self.__options)
def keys(self):
return list(self.__ids)
def __add__(self, other):
if interfaces.ICollection.providedBy(other):
copy = self.copy()
for component in other:
copy.append(component)
return copy
if interfaces.IComponent.providedBy(other):
copy = self.copy()
copy.append(other)
return copy
raise NotImplementedError
def __getitem__(self, id):
return self.get(id)
def __setitem__(self, id, value):
self.set(id, value)
def __delitem__(self, id):
if not interfaces.IMutableCollection.providedBy(self):
raise NotImplementedError
try:
index = self.__ids.index(id)
self.__ids.remove(id)
del self.__components[index]
except ValueError:
raise KeyError(id)
def __contains__(self, id):
return id in self.__ids
def __iter__(self):
return self.__components.__iter__()
def __len__(self):
return self.__components.__len__()
def __repr__(self):
return "<%s>" % (self.__class__.__name__) | zeam.form.base | /zeam.form.base-1.4.1.tar.gz/zeam.form.base-1.4.1/src/zeam/form/base/components.py | components.py |
from zeam.form.base import interfaces
from zeam.form.base.components import Component, Collection, _marker
from zope.interface import implementer, implements, directlyProvides
from zope.i18nmessageid import MessageFactory
_ = MessageFactory('zeam.form.base')
@implementer(interfaces.IError)
class Error(Component):
#implements(interfaces.IError)
def get(self, prefix, default=_marker):
# We implements get to be compatible with the sub-error protocol.
if self.identifier == prefix:
return self
if default is _marker:
raise KeyError(prefix)
return default
@implementer(interfaces.IErrors)
class Errors(Collection):
#implements(interfaces.IErrors)
type = interfaces.IError
order = 0
def __init__(self, *components, **options):
Collection.__init__(self, *components, **options)
if 'identifier' in options:
directlyProvides(self, interfaces.IError)
@property
def title(self):
if interfaces.IError.providedBy(self):
default_error = self.get(self.identifier, None)
if default_error is not None:
return default_error.title
return _(u"There were errors.")
raise AttributeError('property')
def append(self, component):
if self.type.providedBy(component):
if component.identifier in self:
previous = self[component.identifier]
if not interfaces.IErrors.providedBy(previous):
previous.identifier += '.0'
collection = self.__class__(
previous, identifier=component.identifier)
self[component.identifier] = collection
else:
collection = previous
component.identifier += '.%d' % len(collection)
collection.append(component)
else:
super(Errors, self).append(component)
else:
raise TypeError(u"Invalid type", component)
def clone(self, new_identifier=None):
raise NotImplementedError(u'Errors collections are not clonable.')
def __repr__(self):
if interfaces.IError.providedBy(self):
return "<%s for %r>" % (self.__class__.__name__, self.identifier)
return Collection.__repr__(self) | zeam.form.base | /zeam.form.base-1.4.1.tar.gz/zeam.form.base-1.4.1/src/zeam/form/base/errors.py | errors.py |
import martian
import grokcore.view
import grokcore.component
import grokcore.security
from grokcore.security.util import protect_getattr
from grokcore.view.meta.views import TemplateGrokker
from zeam.form.base.widgets import Widget
from zeam.form.base.form import StandaloneForm, GrokViewSupport
from zope import interface, component
from zope.publisher.interfaces.browser import IBrowserPage
from zope.publisher.interfaces.browser import IDefaultBrowserLayer
class WidgetTemplateGrokker(TemplateGrokker):
martian.component(Widget)
def has_render(self, factory):
return factory.render != Widget.render
def has_no_render(self, factory):
return not self.has_render(factory)
class FormTemplateGrokker(TemplateGrokker):
martian.component(GrokViewSupport)
def has_render(self, factory):
return factory.render != GrokViewSupport.render
def has_no_render(self, factory):
return False
class FormGrokker(grokcore.view.meta.views.ViewGrokker):
martian.component(StandaloneForm)
martian.directive(grokcore.component.context)
martian.directive(grokcore.view.layer, default=IDefaultBrowserLayer)
martian.directive(grokcore.component.name,
get_default=grokcore.view.meta.views.default_view_name)
def execute(self, factory, config, context, layer, name, **kw):
# __view_name__ is needed to support IAbsoluteURL on views
factory.__view_name__ = name
adapts = (context, layer)
config.action(
discriminator=('adapter', adapts, interface.Interface, name),
callable=grokcore.component.util.provideAdapter,
args=(factory, adapts, interface.Interface, name))
return True
class FormSecurityGrokker(martian.ClassGrokker):
martian.component(StandaloneForm)
martian.directive(grokcore.security.require, name='permission')
def execute(self, factory, config, permission, **kw):
# XXX use something else than IBrowserPage ? (trollfot)
for method_name in IBrowserPage:
config.action(
discriminator=('protectName', factory, method_name),
callable=protect_getattr,
args=(factory, method_name, permission))
return True | zeam.form.base | /zeam.form.base-1.4.1.tar.gz/zeam.form.base-1.4.1/src/zeam/form/base/meta.py | meta.py |
import sys
import itertools
from zeam.form.base import interfaces
from zeam.form.base.components import Component, Collection
from zeam.form.base.errors import Error
from zeam.form.base.markers import NO_VALUE, NOTHING_DONE, FAILURE
from zeam.form.base.markers import getValue, DEFAULT
from zope.publisher.interfaces.http import MethodNotAllowed
from zope.interface import implementer, implements, alsoProvides
from zope import component
@implementer(interfaces.IAction)
class Action(Component):
"""A form action.
"""
prefix = 'action'
# By default an action is always in input mode (there is not much
# sense otherwise).
mode = 'input'
description = None
accesskey = None
html5Validation = True
methods = None
htmlAttributes = {}
def __init__(self, title=None, identifier=None, **htmlAttributes):
super(Action, self).__init__(title, identifier)
self.htmlAttributes = self.htmlAttributes.copy()
self.htmlAttributes.update(htmlAttributes)
def available(self, form):
return True
def validate(self, form):
return True
def __call__(self, submission):
raise NotImplementedError
@implementer(interfaces.IActions)
class Actions(Collection):
"""A list of form action.
"""
type = interfaces.IAction
def process(self, form, request):
for action in self:
extractor = component.getMultiAdapter(
(action, form, request), interfaces.IWidgetExtractor)
value, error = extractor.extract()
if value is not NO_VALUE:
methods = action.methods or form.methods
if methods and request.method.upper() not in methods:
raise MethodNotAllowed(form.context, request)
try:
if action.validate(form):
return form, action, action(form)
except interfaces.ActionError as error:
form.errors.append(Error(error.args[0], form.prefix))
return form, action, FAILURE
return form, None, NOTHING_DONE
@implementer(interfaces.IIterable)
class CompoundActions:
"""Compound different types of actions together.
"""
def __init__(self, *new_actions):
self.__actions = []
self.extend(new_actions)
def extend(self, new_actions):
for actions in new_actions:
self.append(actions)
def append(self, actions):
assert interfaces.IActions.providedBy(actions), u"Invalid actions"
self.__actions.append(actions)
def copy(self):
copy = self.__class__()
copy.extend(self.__actions)
return copy
def process(self, form, request):
for actions in self.__actions:
action, status = actions.process(form, request)
if status != NOTHING_DONE:
break
return action, status
def __add__(self, actions):
copy = self.copy()
copy.extend(actions)
return copy
def __iter__(self):
return itertools.chain(*self.__actions)
# Convience API, decorator to add action
class DecoratedAction(Action):
"""An action created by a decorator.
"""
def __init__(self, title, callback,
identifier=None, description=None, accesskey=None,
validator=None, available=None, **htmlAttributes):
super(DecoratedAction, self).__init__(
title, identifier, **htmlAttributes)
self._callback = callback
self._validator = validator
self._available = available
self.accesskey = accesskey
self.description = description
def validate(self, form):
if self._validator is not None:
return self._validator(form)
return True
def available(self, form):
if self._available is not None:
return self._available(form)
return True
def __call__(self, form, *args, **kwargs):
assert self._callback is not None
return self._callback(form, *args, **kwargs)
# More convienent, extract the data before calling the action
class ExtractedDecoratedAction(DecoratedAction):
def __call__(self, form):
data, errors = form.extractData()
if errors:
return FAILURE
# We directly give data.
return super(ExtractedDecoratedAction, self).__call__(form, data)
def action(title, identifier=None, description=None, accesskey=None,
validator=None, available=None, implements=None,
factory=DecoratedAction, category='actions', **htmlAttributes):
def createAction(callback):
new_action = factory(
title, callback, identifier, description, accesskey,
validator, available, **htmlAttributes)
if implements is not None:
alsoProvides(new_action, implements)
# Magic to access the parent action list to add the action
frame = sys._getframe(1)
f_locals = frame.f_locals
actions = f_locals.setdefault(category, Actions())
actions.append(new_action)
# We keep the same callback, so we can do super in
# subclass. Registering it is enough, we do not need something
# else.
return callback
return createAction | zeam.form.base | /zeam.form.base-1.4.1.tar.gz/zeam.form.base-1.4.1/src/zeam/form/base/actions.py | actions.py |
import warnings
from grokcore import component as grok
from zeam.form.base import interfaces
from zeam.form.base.components import Component, Collection
from zeam.form.base.interfaces import IModeMarker, IWidgetFactory
from zeam.form.base.markers import NO_VALUE, getValue, HiddenMarker
from zope import component
from zope.interface import Interface, implementer
from zope.pagetemplate.interfaces import IPageTemplate
def widgetId(form, component):
"""Create an unique ID for a widget.
"""
return '.'.join(
(iditem for iditem in
(str(form.prefix), component.prefix, component.identifier,)
if iditem))
def getWidgetExtractor(field, form, request):
warnings.warn(
u"getWidgetExtractor is deprecated in favor of "
u"form.widgetFactory.extractor", DeprecationWarning)
return form.widgetFactory.extractor(field)
@implementer(IWidgetFactory)
class WidgetFactory:
"""Generic API to create widgets and extractors.
"""
def __init__(self, form, request):
self.form = form
self.request = request
def widget(self, field):
"""Create a widget for the given field.
"""
if not field.available(self.form):
return None
mode = str(getValue(field, 'mode', self.form))
return component.getMultiAdapter(
(field, self.form, self.request),
interfaces.IWidget,
name=mode)
def extractor(self, field):
"""Create a widget extractor for the given field.
"""
mode = getValue(field, 'mode', self.form)
# The field mode should be extractable or we skip it.
if (IModeMarker.providedBy(mode) and mode.extractable is False):
return None
extractor = component.queryMultiAdapter(
(field, self.form, self.request),
interfaces.IWidgetExtractor,
name=str(mode))
if extractor is not None:
return extractor
# Default to the default extractor
return component.getMultiAdapter(
(field, self.form, self.request),
interfaces.IWidgetExtractor)
@implementer(interfaces.IWidgets)
class Widgets(Collection):
type = interfaces.IWidget
def extend(self, *args):
if not args:
return
# Ensure the user created us with the right options
assert self.__dict__.get('form', None) is not None
factory = self.form.widgetFactory.widget
for arg in args:
if interfaces.IWidgets.providedBy(arg):
for widget in arg:
self.append(widget)
elif interfaces.IIterable.providedBy(arg):
for field in arg:
widget = factory(field)
if widget is not None:
self.append(widget)
elif interfaces.IWidget.providedBy(arg):
self.append(arg)
elif interfaces.IRenderableComponent.providedBy(arg):
widget = factory(arg)
if widget is not None:
self.append(widget)
else:
raise TypeError(u'Invalid type', arg)
def update(self):
for widget in self:
widget.update()
@implementer(interfaces.IWidget)
class Widget(Component, grok.MultiAdapter):
grok.baseclass()
grok.provides(interfaces.IWidget)
defaultHtmlAttributes = set(['required', 'readonly', 'placeholder',
'autocomplete', 'size', 'maxlength',
'pattern', 'style'])
defaultHtmlClass = ['field']
alternateLayout = False
def __init__(self, component, form, request):
identifier = widgetId(form, component)
super(Widget, self).__init__(component.title, identifier)
self.component = component
self.form = form
self.request = request
self._htmlAttributes = {}
def clone(self, new_identifier=None):
raise NotImplementedError
def htmlId(self):
# Return an identifier suitable for CSS usage
return self.identifier.replace('.', '-')
def htmlClass(self):
result = self.defaultHtmlClass
if self.required:
result = result + ['field-required',]
return ' '.join(result)
def htmlAttribute(self, name=None):
value = self._htmlAttributes.get(name)
if value:
# Boolean return as value the name of the property
if isinstance(value, bool):
return name
return value
return None
def htmlAttributes(self):
attributes = {}
for key, value in sorted(self._htmlAttributes.items()):
if (value and
(key.startswith('data-') or key in self.defaultHtmlAttributes)):
if isinstance(value, bool):
attributes[key] = key
else:
attributes[key] = str(value)
return attributes
def isVisible(self):
return not isinstance(self.component.mode, HiddenMarker)
def default_namespace(self):
namespace = {'widget': self,
'request': self.request}
return namespace
def namespace(self):
return {}
def update(self):
pass
def render(self):
# Try grok template first
template = getattr(self, 'template', None)
if template is not None:
return self.template.render(self)
# Fallback on IPageTemplate
template = component.getMultiAdapter(
(self, self.request), IPageTemplate)
return template()
@implementer(interfaces.IWidgetExtractor)
class WidgetExtractor(grok.MultiAdapter):
grok.provides(interfaces.IWidgetExtractor)
grok.adapts(
interfaces.IRenderableComponent,
interfaces.IFieldExtractionValueSetting,
Interface)
def __init__(self, component, form, request):
self.identifier = widgetId(form, component)
self.component = component
self.form = form
self.request = request
def extract(self):
value = self.request.form.get(self.identifier)
if value is None:
value = NO_VALUE
return (value, None)
def extractRaw(self):
entries = {}
sub_identifier = self.identifier + '.'
for key, value in self.request.form.items():
if key.startswith(sub_identifier) or key == self.identifier:
entries[key] = value
return entries
class FieldWidgetExtractor(WidgetExtractor):
grok.adapts(
interfaces.IField,
interfaces.IFieldExtractionValueSetting,
Interface)
def extract(self):
value = self.request.form.get(self.identifier)
# The value is empty only if the field is required.
if (value is None or
(not len(value) and self.component.isRequired(self.form))):
value = NO_VALUE
return (value, None)
class HiddenWidgetExtractor(WidgetExtractor):
grok.name('hidden')
class ReadOnlyWidgetExtractor(WidgetExtractor):
grok.name('readonly')
# After follow the implementation of some really generic default
# widgets
class ActionWidget(Widget):
grok.adapts(
interfaces.IAction,
interfaces.IFieldExtractionValueSetting,
Interface)
grok.name('input')
defaultHtmlAttributes = set(['accesskey', 'formnovalidate', 'style'])
defaultHtmlClass = ['action']
def __init__(self, component, form, request):
super(ActionWidget, self).__init__(component, form, request)
self.description = component.description
self._htmlAttributes.update({
'accesskey': component.accesskey,
'formnovalidate': not component.html5Validation})
self._htmlAttributes.update(component.htmlAttributes)
def htmlClass(self):
return 'action'
@implementer(interfaces.IFieldWidget)
class FieldWidget(Widget):
grok.adapts(
interfaces.IField,
interfaces.IFormData,
Interface)
grok.name('input')
def __init__(self, component, form, request):
super(FieldWidget, self).__init__(component, form, request)
self.description = component.description
self.required = component.isRequired(form)
self._htmlAttributes.update(component.htmlAttributes)
self._htmlAttributes.update({
'readonly': component.readonly,
'required': self.required})
@property
def error(self):
return self.form.errors.get(self.identifier, None)
def computeValue(self):
# First lookup the request
ignoreRequest = getValue(self.component, 'ignoreRequest', self.form)
if not ignoreRequest:
extractor = self.form.widgetFactory.extractor(self.component)
if extractor is not None:
value = extractor.extractRaw()
if value:
return self.prepareRequestValue(value, extractor)
# After, the context
ignoreContent = getValue(self.component, 'ignoreContent', self.form)
if not ignoreContent:
data = self.form.getContentData()
try:
value = data.get(self.component.identifier)
# XXX: Need review
if value is None:
value = NO_VALUE
return self.prepareContentValue(value)
except KeyError:
# No value on the content for field, continue.
pass
# Take any default value
value = self.component.getDefaultValue(self.form)
return self.prepareContentValue(value)
def valueToUnicode(self, value):
return value
def prepareRequestValue(self, value, extractor):
return value
def prepareContentValue(self, value):
formatted_value = u''
if value is not NO_VALUE:
formatted_value = self.valueToUnicode(value)
return {self.identifier: formatted_value}
def inputValue(self, id=None):
if id is not None:
id = '%s.%s' % (self.identifier, id)
else:
id = self.identifier
return self.value.get(id, '')
def update(self):
self.value = self.computeValue()
class DisplayFieldWidget(FieldWidget):
grok.name('display')
class HiddenFieldWidget(FieldWidget):
grok.name('hidden')
class ReadOnlyFieldWidget(FieldWidget):
grok.name('readonly') | zeam.form.base | /zeam.form.base-1.4.1.tar.gz/zeam.form.base-1.4.1/src/zeam/form/base/widgets.py | widgets.py |
from zeam.form.base import interfaces
from zeam.form.base.components import Component, Collection
from zeam.form.base.markers import NO_VALUE, DEFAULT, Marker
from zope.interface import implementer
from zope.i18nmessageid import MessageFactory
_ = MessageFactory('zeam.form.base')
@implementer(interfaces.IField)
class Field(Component):
description = u''
required = False
prefix = 'field'
readonly = False
htmlAttributes = {}
interface = None
ignoreContent = DEFAULT
ignoreRequest = DEFAULT
mode = DEFAULT
defaultValue = NO_VALUE
def __init__(self,
title=None,
identifier=None,
description=u"",
required=False,
readonly=False,
defaultFactory=None,
defaultValue=NO_VALUE,
constrainValue=None,
interface=None,
**htmlAttributes):
super(Field, self).__init__(title, identifier)
self.description = description
self.required = required
self.readonly = readonly
self.defaultValue = defaultValue
self.interface = interface
self.defaultFactory = defaultFactory
if constrainValue is not None:
self.constrainValue = constrainValue
self.htmlAttributes = self.htmlAttributes.copy()
self.htmlAttributes.update(htmlAttributes)
def clone(self, new_identifier=None):
copy = self.__class__(title=self.title, identifier=self.identifier)
copy.__dict__.update(self.__dict__)
if new_identifier is not None:
copy.identifier = new_identifier
return copy
def available(self, form):
return True
def isRequired(self, form):
if callable(self.required):
return self.required(form)
return self.required
def isEmpty(self, value):
return value is NO_VALUE
def getDefaultValue(self, form):
# We should take the defaultFactory into account.
# Not sure how yet.
if callable(self.defaultValue):
return self.defaultValue(form)
return self.defaultValue
def constrainValue(self, value):
return True
def validate(self, value, form):
if self.isEmpty(value):
if self.isRequired(form):
return _(u"Missing required value.")
elif not isinstance(value, Marker):
try:
if not self.constrainValue(value):
return _(u"The constraint failed.")
except Exception as error:
if hasattr(error, 'doc'):
return error.doc()
return _(u"The constraint failed.")
return None
@implementer(interfaces.IFields)
class Fields(Collection):
type = interfaces.IField
factory = interfaces.IFieldFactory | zeam.form.base | /zeam.form.base-1.4.1.tar.gz/zeam.form.base-1.4.1/src/zeam/form/base/fields.py | fields.py |
==================
zeam.form.composed
==================
This package let you defines forms containing other forms in
`zeam.form.base`_.
.. contents::
Example
=======
Here a simple example. Let's define a setting form::
from zeam.form import composed, base
from zope.interface import Interface
class Setting(composed.ComposedForm):
composed.context(Interface)
label = u"Settings"
After, a module can add some mail settings on that screen::
class MailSetting(composed.SubForm):
composed.context(MyApplication)
composed.view(Setting)
composed.order(99)
label = u"Mail delivery settings"
...
And publications of that application could add some publication
settings::
class PublicationSetting(composed.SubForm):
composed.context(MyPublications)
composed.view(Setting)
composed.order(10)
label = u"Publication settings"
...
Some default templates are included as well, but you can replace like
you will do in `zeam.form.base`_.
API
===
Classes
-------
``ComposedForm``
This class define a form which able to contain other forms. It
behave like a ``zeam.form.base`` Form, but does use its fields.
A usefull method can give you back a given subform :
``getSubForm(identifier)``.
``SubForm``
This class represent a form which is contained inside a
``ComposedForm``. This form behave exactly like a
``zeam.form.base`` Form to which you add:
- a method ``available()`` which is called before anything else to
know if the form shoud still be included in the ``ComposedForm``.
- a method ``getComposedForm()`` that gives you back the composed
form in which this form is rendered.
``SubFormGroup``
This class let you group ``SubForm`` together. They are rendered within
the group template, and prefixed by the group name. Like a ``SubForm``
they have an ``available()`` and a ``getComposedForm()`` method. It as
well have a ``getSubForm(identifier)`` method.
Directives
----------
All those directives comes from Grokcore component. Please refer to
the `Grok documentation <http://grok.zope.org>`_ for more information.
``context``
Define for which object the form/sub form is available.
``layer``
Define the skin for which the form/sub form is aviable.
``require``
Define a permission need to access the form.
``template``
Define a Grok-like template for the form. After you done that, the
Grok template will be look up and used. You can't use anymore a
``megrok.pagetemplate`` template, unless you set ``template=None``
again on your form class.
``view``
On a sub form, define for which form the sub form is available.
``order``
Let you specify a number to sort your sub form afterwards using
that setting.
.. _zeam.form.base: http://pypi.python.org/pypi/zeam.form.base
| zeam.form.composed | /zeam.form.composed-1.3.3.tar.gz/zeam.form.composed-1.3.3/README.txt | README.txt |
from megrok import pagetemplate as pt
from grokcore.component.util import sort_components
from grokcore import component as grok
from zope import component
from zeam.form.base import form
from zeam.form.composed import interfaces
from zope.interface import implementer
pt.templatedir('default_templates')
class SubFormBase(object):
"""Base class to be applied on a FormCanvas to get a subform.
"""
grok.baseclass()
# Set prefix to None, so it's changed by the grokker
label = u''
description = u''
prefix = None
def __init__(self, context, parent, request):
super(SubFormBase, self).__init__(context, request)
self.parent = parent
def available(self):
return True
def htmlId(self):
return self.prefix.replace('.', '-')
def getComposedForm(self):
return self.parent.getComposedForm()
@implementer(interfaces.ISubFormGroup)
class SubFormGroupBase(object):
"""A group of subforms: they can be grouped inside a composed form.
"""
def __init__(self, context, request):
super(SubFormGroupBase, self).__init__(context, request)
# retrieve subforms by adaptation
subforms = map(lambda f: f[1], component.getAdapters(
(self.context, self, self.request), interfaces.ISubForm))
# sort them
self.allSubforms = sort_components(subforms)
self.subforms = []
def getSubForm(self, identifier):
for form in self.subforms:
if form.htmlId() == identifier:
return form
return None
def getComposedForm(self):
return self
def htmlId(self):
return self.prefix.replace('.', '-')
def update(self):
# Call update for all forms
for subform in self.allSubforms:
subform.update()
def updateActions(self):
# Set/run actions for all forms
form, action, status = self, None, None
for subform in self._getAvailableSubForms():
form, action, status = subform.updateActions()
if action is not None:
break
return form, action, status
def updateWidgets(self):
# Set the subforms to render
self.subforms = self._getAvailableSubForms()
# Set widgets for all forms
for subform in self.subforms:
subform.updateWidgets()
def _getAvailableSubForms(self):
# filter out unavailables ones
return filter(lambda f: f.available(), self.allSubforms)
@implementer(interfaces.ISimpleSubForm)
class SubForm(SubFormBase, form.FormCanvas):
"""Form designed to be included in an another form (a
ComposedForm).
"""
grok.baseclass()
class SubFormTemplate(pt.PageTemplate):
"""Default template for a SubForm
"""
pt.view(SubForm)
@implementer(interfaces.ISubFormGroup)
class SubFormGroup(SubFormBase, SubFormGroupBase, form.GrokViewSupport):
"""A group of subforms.
"""
grok.baseclass()
def available(self):
return len(self._getAvailableSubForms()) != 0
class SubFormGroupTemplate(pt.PageTemplate):
"""Default template for a SubFormGroup.
"""
pt.view(SubFormGroup)
@implementer(interfaces.IComposedForm)
class ComposedForm(SubFormGroupBase, form.Form):
"""A form which is composed of other forms (SubForm).
"""
grok.baseclass()
def updateForm(self):
executed_form, action, status = SubFormGroupBase.updateActions(self)
if action is None:
form.Form.updateActions(self)
SubFormGroupBase.updateWidgets(self)
form.Form.updateWidgets(self)
class ComposedFormTemplate(pt.PageTemplate):
"""Default template for a ComposedForm.
"""
pt.view(ComposedForm) | zeam.form.composed | /zeam.form.composed-1.3.3.tar.gz/zeam.form.composed-1.3.3/src/zeam/form/composed/form.py | form.py |
===============
zeam.form.plone
===============
``zeam.form.plone`` provides support for `zeam.form.base`_ into Plone
3, 4 and 5:
- make forms and security work in Zope 2,
- default form template using Plone macros,
- provide a simple simple edit form,
- use Plone status message system to report status,
- provides extra widgets, like a WYSIWYG text widget.
Example
=======
Let's define a simple example::
from zeam.form.plone import EditForm
from zeam.form.base import Fields
class EditPeople(EditForm):
label = u"Edit people"
fields = Fields(IPeople)
fields['summary'].mode = 'plone.wysiwyg'
If you install the extension *Zeam Form* you will get nicer CSS and
extra JS for the widgets.
For more information information, please refer to `zeam.form.base`_
and to the Grok documentation.
.. _zeam.form.base: http://pypi.python.org/pypi/zeam.form.base
| zeam.form.plone | /zeam.form.plone-1.1.tar.gz/zeam.form.plone-1.1/README.txt | README.txt |
import Acquisition
from Products.statusmessages.interfaces import IStatusMessage
from five import grok
from megrok import pagetemplate as pt
from zeam.form import base
from zeam.form.ztk.actions import EditAction, CancelAction
from zope.i18n.interfaces import IUserPreferredLanguages
from zope.i18n.locales import locales, LoadLocaleError
from zope.i18nmessageid import MessageFactory
_ = MessageFactory('zeam-form-plone')
class PloneFormData(object):
@property
def i18nLanguage(self):
return self.request.get('LANGUAGE', 'en')
@apply
def status():
def get(self):
return ''
def set(self, status):
messager = IStatusMessage(self.request)
messager.addStatusMessage(status, type="info")
return property(get, set)
def find_locale(request):
envadapter = IUserPreferredLanguages(request, None)
if envadapter is None:
return None
langs = envadapter.getPreferredLanguages()
for httplang in langs:
parts = (httplang.split('-') + [None, None])[:3]
try:
return locales.getLocale(*parts)
except LoadLocaleError:
# Just try the next combination
pass
else:
# No combination gave us an existing locale, so use the default,
# which is guaranteed to exist
return locales.getLocale(None, None, None)
def decode_to_unicode(string):
if not isinstance(string, str):
return string
try:
return string.decode('utf-8')
except UnicodeDecodeError:
# Log
return string
def convert_request_form_to_unicode(form):
for key, value in form.iteritems():
if isinstance(value, list):
form[key] = [decode_to_unicode(i) for i in value]
else:
form[key] = decode_to_unicode(value)
class PloneForm(PloneFormData, Acquisition.Explicit):
"""Form in Plone.
"""
grok.baseclass()
# Inherit from Acquisition for Zope 2.
def __init__(self, context, request):
super(PloneForm, self).__init__(context, request)
self.__name__ = self.__view_name__
def __call__(self):
# Set request.method
self.request.other['method'] = self.request.environ['REQUEST_METHOD']
# Set local
if not hasattr(self.request, 'locale'):
# This is not pretty, but no choice.
self.request.locale = find_locale(self.request)
convert_request_form_to_unicode(self.request.form)
return super(PloneForm, self).__call__()
class Form(PloneForm, base.Form):
"""Generic Plone Form
"""
grok.baseclass()
plonePageBorder = True
class EditForm(Form):
"""Generic Plone Edit Form
"""
grok.baseclass()
grok.name('edit')
grok.require('cmf.ModifyPortalContent')
label = _(u"Edit")
ignoreContent = False
actions = base.Actions(
EditAction(_(u"Save")),
CancelAction(_(u"Cancel")))
class FormTemplate(pt.PageTemplate):
pt.view(Form) | zeam.form.plone | /zeam.form.plone-1.1.tar.gz/zeam.form.plone-1.1/src/zeam/form/plone/form.py | form.py |
// $Id$
//
// JavaScript implementation of json-template.
//
// This is predefined in tests, shouldn't be defined anywhere else. TODO: Do
// something nicer.
var log = log || function() {};
var repr = repr || function() {};
// The "module" exported by this script is called "jsontemplate":
var jsontemplate = function() {
// Regex escaping for metacharacters
function EscapeMeta(meta) {
return meta.replace(/([\{\}\(\)\[\]\|\^\$\-\+\?])/g, '\\$1');
}
var token_re_cache = {};
function _MakeTokenRegex(meta_left, meta_right) {
var key = meta_left + meta_right;
var regex = token_re_cache[key];
if (regex === undefined) {
var str = '(' + EscapeMeta(meta_left) + '.*?' + EscapeMeta(meta_right) +
'\n?)';
regex = new RegExp(str, 'g');
}
return regex;
}
//
// Formatters
//
function HtmlEscape(s) {
return s.replace(/&/g,'&').
replace(/>/g,'>').
replace(/</g,'<');
}
function HtmlTagEscape(s) {
return s.replace(/&/g,'&').
replace(/>/g,'>').
replace(/</g,'<').
replace(/"/g,'"');
}
// Default ToString can be changed
function ToString(s) {
if (s === null) {
return 'null';
}
return s.toString();
}
// Formatter to pluralize words
function _Pluralize(value, unused_context, args) {
var s, p;
switch (args.length) {
case 0:
s = ''; p = 's';
break;
case 1:
s = ''; p = args[0];
break;
case 2:
s = args[0]; p = args[1];
break;
default:
// Should have been checked at compile time
throw {
name: 'EvaluationError', message: 'pluralize got too many args'
};
}
return (value > 1) ? p : s;
}
function _Cycle(value, unused_context, args) {
// Cycle between various values on consecutive integers.
// @index starts from 1, so use 1-based indexing.
return args[(value - 1) % args.length];
}
var DEFAULT_FORMATTERS = {
'html': HtmlEscape,
'htmltag': HtmlTagEscape,
'html-attr-value': HtmlTagEscape,
'str': ToString,
'raw': function(x) { return x; },
'AbsUrl': function(value, context) {
// TODO: Normalize leading/trailing slashes
return context.get('base-url') + '/' + value;
}
};
var DEFAULT_PREDICATES = {
'singular?': function(x) { return x == 1; },
'plural?': function(x) { return x > 1; },
'Debug?': function(unused, context) {
try {
return context.get('debug');
} catch(err) {
if (err.name == 'UndefinedVariable') {
return false;
} else {
throw err;
}
}
}
};
var FunctionRegistry = function() {
return {
lookup: function(user_str) {
return [null, null];
}
};
};
var SimpleRegistry = function(obj) {
return {
lookup: function(user_str) {
var func = obj[user_str] || null;
return [func, null];
}
};
};
var CallableRegistry = function(callable) {
return {
lookup: function(user_str) {
var func = callable(user_str);
return [func, null];
}
};
};
// Default formatters which can't be expressed in DEFAULT_FORMATTERS
var PrefixRegistry = function(functions) {
return {
lookup: function(user_str) {
for (var i = 0; i < functions.length; i++) {
var name = functions[i].name, func = functions[i].func;
if (user_str.slice(0, name.length) == name) {
// Delimiter is usually a space, but could be something else
var args;
var splitchar = user_str.charAt(name.length);
if (splitchar === '') {
args = []; // No arguments
} else {
args = user_str.split(splitchar).slice(1);
}
return [func, args];
}
}
return [null, null]; // No formatter
}
};
};
var ChainedRegistry = function(registries) {
return {
lookup: function(user_str) {
for (var i=0; i<registries.length; i++) {
var result = registries[i].lookup(user_str);
if (result[0]) {
return result;
}
}
return [null, null]; // Nothing found
}
};
};
//
// Template implementation
//
function _ScopedContext(context, undefined_str) {
// The stack contains:
// The current context (an object).
// An iteration index. -1 means we're NOT iterating.
var stack = [{context: context, index: -1}];
return {
PushSection: function(name) {
if (name === undefined || name === null) {
return null;
}
var new_context;
if (name == '@') {
new_context = stack[stack.length-1].context;
} else {
new_context = stack[stack.length-1].context[name] || null;
}
stack.push({context: new_context, index: -1});
return new_context;
},
Pop: function() {
stack.pop();
},
next: function() {
var stacktop = stack[stack.length-1];
// Now we're iterating -- push a new mutable object onto the stack
if (stacktop.index == -1) {
stacktop = {context: null, index: 0};
stack.push(stacktop);
}
// The thing we're iterating over
var context_array = stack[stack.length-2].context;
// We're already done
if (stacktop.index == context_array.length) {
stack.pop();
return undefined; // sentinel to say that we're done
}
stacktop.context = context_array[stacktop.index++];
return true; // OK, we mutated the stack
},
_Undefined: function(name) {
if (undefined_str === undefined) {
throw {
name: 'UndefinedVariable', message: name + ' is not defined'
};
} else {
return undefined_str(name);
}
},
_LookUpStack: function(name) {
var i = stack.length - 1;
while (true) {
var frame = stack[i];
if (name == '@index') {
if (frame.index != -1) { // -1 is undefined
return frame.index;
}
} else {
var context = frame.context;
if (typeof context === 'object') {
var value = context[name];
if (value !== undefined) {
return value;
}
}
}
i--;
if (i <= -1) {
return this._Undefined(name);
}
}
},
get: function(name) {
if (name == '@') {
return stack[stack.length-1].context;
}
var parts = name.split('.');
var value = this._LookUpStack(parts[0]);
if (parts.length > 1) {
for (var i=1; i<parts.length; i++) {
value = value[parts[i]];
if (value === undefined) {
return this._Undefined(parts[i]);
}
}
}
return value;
}
};
}
// Crockford's "functional inheritance" pattern
var _AbstractSection = function(spec) {
var that = {};
that.current_clause = [];
that.Append = function(statement) {
that.current_clause.push(statement);
};
that.AlternatesWith = function() {
throw {
name: 'TemplateSyntaxError',
message:
'{.alternates with} can only appear with in {.repeated section ...}'
};
};
that.NewOrClause = function(pred) {
throw { name: 'NotImplemented' }; // "Abstract"
};
return that;
};
var _Section = function(spec) {
var that = _AbstractSection(spec);
that.statements = {'default': that.current_clause};
that.section_name = spec.section_name;
that.Statements = function(clause) {
clause = clause || 'default';
return that.statements[clause] || [];
};
that.NewOrClause = function(pred) {
if (pred) {
throw {
name: 'TemplateSyntaxError',
message: '{.or} clause only takes a predicate inside predicate blocks'
};
}
that.current_clause = [];
that.statements['or'] = that.current_clause;
};
return that;
};
// Repeated section is like section, but it supports {.alternates with}
var _RepeatedSection = function(spec) {
var that = _Section(spec);
that.AlternatesWith = function() {
that.current_clause = [];
that.statements['alternate'] = that.current_clause;
};
return that;
};
// Represents a sequence of predicate clauses.
var _PredicateSection = function(spec) {
var that = _AbstractSection(spec);
// Array of func, statements
that.clauses = [];
that.NewOrClause = function(pred) {
// {.or} always executes if reached, so use identity func with no args
pred = pred || [function(x) { return true; }, null];
that.current_clause = [];
that.clauses.push([pred, that.current_clause]);
};
return that;
};
function _Execute(statements, context, callback) {
for (var i=0; i<statements.length; i++) {
var statement = statements[i];
if (typeof(statement) == 'string') {
callback(statement);
} else {
var func = statement[0];
var args = statement[1];
func(args, context, callback);
}
}
}
function _DoSubstitute(statement, context, callback) {
var value;
value = context.get(statement.name);
// Format values
for (var i=0; i<statement.formatters.length; i++) {
var pair = statement.formatters[i];
var formatter = pair[0];
var args = pair[1];
value = formatter(value, context, args);
}
callback(value);
}
// for [section foo]
function _DoSection(args, context, callback) {
var block = args;
var value = context.PushSection(block.section_name);
var do_section = false;
// "truthy" values should have their sections executed.
if (value) {
do_section = true;
}
// Except: if the value is a zero-length array (which is "truthy")
if (value && value.length === 0) {
do_section = false;
}
if (do_section) {
_Execute(block.Statements(), context, callback);
context.Pop();
} else { // Empty list, None, False, etc.
context.Pop();
_Execute(block.Statements('or'), context, callback);
}
}
// {.pred1?} A {.or pred2?} B ... {.or} Z {.end}
function _DoPredicates(args, context, callback) {
// Here we execute the first clause that evaluates to true, and then stop.
var block = args;
var value = context.get('@');
for (var i=0; i<block.clauses.length; i++) {
var clause = block.clauses[i];
var predicate = clause[0][0];
var pred_args = clause[0][1];
var statements = clause[1];
var do_clause = predicate(value, context, pred_args);
if (do_clause) {
_Execute(statements, context, callback);
break;
}
}
}
function _DoRepeatedSection(args, context, callback) {
var block = args;
items = context.PushSection(block.section_name);
pushed = true;
if (items && items.length > 0) {
// TODO: check that items is an array; apparently this is hard in JavaScript
//if type(items) is not list:
// raise EvaluationError('Expected a list; got %s' % type(items))
// Execute the statements in the block for every item in the list.
// Execute the alternate block on every iteration except the last. Each
// item could be an atom (string, integer, etc.) or a dictionary.
var last_index = items.length - 1;
var statements = block.Statements();
var alt_statements = block.Statements('alternate');
for (var i=0; context.next() !== undefined; i++) {
_Execute(statements, context, callback);
if (i != last_index) {
_Execute(alt_statements, context, callback);
}
}
} else {
_Execute(block.Statements('or'), context, callback);
}
context.Pop();
}
var _SECTION_RE = /(repeated)?\s*(section)\s+(\S+)?/;
var _OR_RE = /or(?:\s+(.+))?/;
var _IF_RE = /if(?:\s+(.+))?/;
// Turn a object literal, function, or Registry into a Registry
function MakeRegistry(obj) {
if (!obj) {
// if null/undefined, use a totally empty FunctionRegistry
return new FunctionRegistry();
} else if (typeof obj === 'function') {
return new CallableRegistry(obj);
} else if (obj.lookup !== undefined) {
// TODO: Is this a good pattern? There is a namespace conflict where get
// could be either a formatter or a method on a FunctionRegistry.
// instanceof might be more robust.
return obj;
} else if (typeof obj === 'object') {
return new SimpleRegistry(obj);
}
}
// TODO: The compile function could be in a different module, in case we want to
// compile on the server side.
function _Compile(template_str, options) {
var more_formatters = MakeRegistry(options.more_formatters);
// default formatters with arguments
var default_formatters = PrefixRegistry([
{name: 'pluralize', func: _Pluralize},
{name: 'cycle', func: _Cycle}
]);
var all_formatters = new ChainedRegistry([
more_formatters,
SimpleRegistry(DEFAULT_FORMATTERS),
default_formatters
]);
var more_predicates = MakeRegistry(options.more_predicates);
// TODO: Add defaults
var all_predicates = new ChainedRegistry([
more_predicates, SimpleRegistry(DEFAULT_PREDICATES)
]);
// We want to allow an explicit null value for default_formatter, which means
// that an error is raised if no formatter is specified.
var default_formatter;
if (options.default_formatter === undefined) {
default_formatter = 'str';
} else {
default_formatter = options.default_formatter;
}
function GetFormatter(format_str) {
var pair = all_formatters.lookup(format_str);
if (!pair[0]) {
throw {
name: 'BadFormatter',
message: format_str + ' is not a valid formatter'
};
}
return pair;
}
function GetPredicate(pred_str) {
var pair = all_predicates.lookup(pred_str);
if (!pair[0]) {
throw {
name: 'BadPredicate',
message: pred_str + ' is not a valid predicate'
};
}
return pair;
}
var format_char = options.format_char || '|';
if (format_char != ':' && format_char != '|') {
throw {
name: 'ConfigurationError',
message: 'Only format characters : and | are accepted'
};
}
var meta = options.meta || '{}';
var n = meta.length;
if (n % 2 == 1) {
throw {
name: 'ConfigurationError',
message: meta + ' has an odd number of metacharacters'
};
}
var meta_left = meta.substring(0, n/2);
var meta_right = meta.substring(n/2, n);
var token_re = _MakeTokenRegex(meta_left, meta_right);
var current_block = _Section({});
var stack = [current_block];
var strip_num = meta_left.length; // assume they're the same length
var token_match;
var last_index = 0;
while (true) {
token_match = token_re.exec(template_str);
if (token_match === null) {
break;
} else {
var token = token_match[0];
}
// Add the previous literal to the program
if (token_match.index > last_index) {
var tok = template_str.slice(last_index, token_match.index);
current_block.Append(tok);
}
last_index = token_re.lastIndex;
var had_newline = false;
if (token.slice(-1) == '\n') {
token = token.slice(null, -1);
had_newline = true;
}
token = token.slice(strip_num, -strip_num);
if (token.charAt(0) == '#') {
continue; // comment
}
if (token.charAt(0) == '.') { // Keyword
token = token.substring(1, token.length);
var literal = {
'meta-left': meta_left,
'meta-right': meta_right,
'space': ' ',
'tab': '\t',
'newline': '\n'
}[token];
if (literal !== undefined) {
current_block.Append(literal);
continue;
}
var new_block, func;
var section_match = token.match(_SECTION_RE);
if (section_match) {
var repeated = section_match[1];
var section_name = section_match[3];
if (repeated) {
func = _DoRepeatedSection;
new_block = _RepeatedSection({section_name: section_name});
} else {
func = _DoSection;
new_block = _Section({section_name: section_name});
}
current_block.Append([func, new_block]);
stack.push(new_block);
current_block = new_block;
continue;
}
var pred_str, pred;
// Check {.or pred?} before {.pred?}
var or_match = token.match(_OR_RE);
if (or_match) {
pred_str = or_match[1];
pred = pred_str ? GetPredicate(pred_str) : null;
current_block.NewOrClause(pred);
continue;
}
// Match either {.pred?} or {.if pred?}
var matched = false;
var if_match = token.match(_IF_RE);
if (if_match) {
pred_str = if_match[1];
matched = true;
} else if (token.charAt(token.length-1) == '?') {
pred_str = token;
matched = true;
}
if (matched) {
pred = pred_str ? GetPredicate(pred_str) : null;
new_block = _PredicateSection();
new_block.NewOrClause(pred);
current_block.Append([_DoPredicates, new_block]);
stack.push(new_block);
current_block = new_block;
continue;
}
if (token == 'alternates with') {
current_block.AlternatesWith();
continue;
}
if (token == 'end') {
// End the block
stack.pop();
if (stack.length > 0) {
current_block = stack[stack.length-1];
} else {
throw {
name: 'TemplateSyntaxError',
message: 'Got too many {end} statements'
};
}
continue;
}
}
// A variable substitution
var parts = token.split(format_char);
var formatters;
var name;
if (parts.length == 1) {
if (default_formatter === null) {
throw {
name: 'MissingFormatter',
message: 'This template requires explicit formatters.'
};
}
// If no formatter is specified, use the default.
formatters = [GetFormatter(default_formatter)];
name = token;
} else {
formatters = [];
for (var j=1; j<parts.length; j++) {
formatters.push(GetFormatter(parts[j]));
}
name = parts[0];
}
current_block.Append([_DoSubstitute, {name: name, formatters: formatters}]);
if (had_newline) {
current_block.Append('\n');
}
}
// Add the trailing literal
current_block.Append(template_str.slice(last_index));
if (stack.length !== 1) {
throw {
name: 'TemplateSyntaxError',
message: 'Got too few {end} statements'
};
}
return current_block;
}
// The Template class is defined in the traditional style so that users can add
// methods by mutating the prototype attribute. TODO: Need a good idiom for
// inheritance without mutating globals.
function Template(template_str, options) {
// Add 'new' if we were not called with 'new', so prototyping works.
if(!(this instanceof Template)) {
return new Template(template_str, options);
}
this._options = options || {};
this._program = _Compile(template_str, this._options);
}
Template.prototype.render = function(data_dict, callback) {
// options.undefined_str can either be a string or undefined
var context = _ScopedContext(data_dict, this._options.undefined_str);
_Execute(this._program.Statements(), context, callback);
};
Template.prototype.expand = function(data_dict) {
var tokens = [];
this.render(data_dict, function(x) { tokens.push(x); });
return tokens.join('');
};
// fromString is a construction method that allows metadata to be written at the
// beginning of the template string. See Python's FromFile for a detailed
// description of the format.
//
// The argument 'options' takes precedence over the options in the template, and
// can be used for non-serializable options like template formatters.
var OPTION_RE = /^([a-zA-Z\-]+):\s*(.*)/;
var OPTION_NAMES = [
'meta', 'format-char', 'default-formatter', 'undefined-str'];
// Use this "linear search" instead of Array.indexOf, which is nonstandard
var OPTION_NAMES_RE = new RegExp(OPTION_NAMES.join('|'));
function fromString(s, options) {
var parsed = {};
var begin = 0, end = 0;
while (true) {
var parsedOption = false;
end = s.indexOf('\n', begin);
if (end == -1) {
break;
}
var line = s.slice(begin, end);
begin = end+1;
var match = line.match(OPTION_RE);
if (match !== null) {
var name = match[1].toLowerCase(), value = match[2];
if (name.match(OPTION_NAMES_RE)) {
name = name.replace('-', '_');
value = value.replace(/^\s+/, '').replace(/\s+$/, '');
if (name == 'default_formatter' && value.toLowerCase() == 'none') {
value = null;
}
parsed[name] = value;
parsedOption = true;
}
}
if (!parsedOption) {
break;
}
}
// TODO: This doesn't enforce the blank line between options and template, but
// that might be more trouble than it's worth
if (parsed !== {}) {
body = s.slice(begin);
} else {
body = s;
}
for (var o in options) {
parsed[o] = options[o];
}
return Template(body, parsed);
}
// We just export one name for now, the Template "class".
// We need HtmlEscape in the browser tests, so might as well export it.
return {
Template: Template, HtmlEscape: HtmlEscape,
FunctionRegistry: FunctionRegistry, SimpleRegistry: SimpleRegistry,
CallableRegistry: CallableRegistry, ChainedRegistry: ChainedRegistry,
fromString: fromString,
// Private but exposed for testing
_Section: _Section
};
}(); | zeam.form.plone | /zeam.form.plone-1.1.tar.gz/zeam.form.plone-1.1/src/zeam/form/plone/resources/json-template.js | json-template.js |
=============
zeam.form.rdb
=============
``zeam.form.rdb`` provides an helper to generate form fields for
`zeam.form.base`_, using `zeam.form.ztk`_ fields from an `SQLAlchemy`_
model.
To accomplish, you must create your fields using the descriptor
``ModelFields`` in your form. It will automatically fetch the context
of the form, and generate the fields accordingly, caching them (for
performance reasons).
Example::
from zeam.form.rdb import ModelFields
from zeam.form.base import Form
class MyForm(Form):
label = "Test form"
fields = ModelFields()
In your `SQLAlchemy`_ schema, you can use the extra dictionnary
``info`` to control the widget generated. Foreign key will generate a
choice of possible values to select, using the column you desire as
title.
Example::
from sqlalchemy import Column, ForeignKey
from sqlalchemy.types import Integer, String
from zeam.form.ztk.widgets.uri import URIField
idT_Effort = Column(
'idT_Effort',
Integer,
primary_key=True,
info={'title': u"Identifier"})
idT_Opportunity = Column(
'idT_Opportunity',
Integer,
ForeignKey('T_Opportunity.idT_Opportunities'),
info={'title': u'Opportunity',
'foreignTitleColumn': 'Title'})
Name = Column(
'Name',
String(45),
info={'minLength': 20,
'maxLength': 45})
URL = Column(
'URL',
String(63),
info={'title': u"URL",
'description': u"Website URL"
'factory': URIField,
'defaultValue': 'http://github.com',
'required': True})
For a ForeignKey, you have the possibility to provides multiple
columns to ``foreignTitleColumn``, and a function to be called to
create the title as ``foreignTitleFactory``, both in the ``info``
dictionnary. ``foreignTitleQuery`` can specified to refine the
SQLAlchemy request used to obtain the title terms.
A field will be required unless the column is nullable, or the option
``required`` is given through ``info``.
``title`` and ``description`` from ``info`` will be used as well in
order to create the form field.
.. _zeam.form.base: http://pypi.python.org/pypi/zeam.form.base
.. _zeam.form.ztk: http://pypi.python.org/pypi/zeam.form.ztk
.. _SQLAlchemy: http://www.sqlalchemy.org/
| zeam.form.rdb | /zeam.form.rdb-1.0.1.tar.gz/zeam.form.rdb-1.0.1/README.txt | README.txt |
from z3c.saconfig import Session
from zope.schema.vocabulary import SimpleVocabulary, SimpleTerm
from zope.i18nmessageid import MessageFactory
_ = MessageFactory('zeam.form.base')
class ExtendingVocabulary(SimpleVocabulary):
"""A vocabulary that can be extended with terms of an another
vocabulary on demand.
"""
def __init__(self, terms, query=None):
super(ExtendingVocabulary, self).__init__(terms)
self._query = query
self._vocabulary = None
def addTerm(self, term):
if term.value in self.by_value:
raise ValueError(term)
if term.token in self.by_token:
raise ValueError(term)
self.by_value[term.value] = term
self.by_token[term.token] = term
self._terms.append(term)
def getVocabulary(self):
if self._vocabulary is None and self._query is not None:
self._vocabulary = SimpleVocabulary(list(self._query))
return self._vocabulary
def getTerm(self, value):
try:
return super(ExtendingVocabulary, self).getTerm(value)
except LookupError:
vocabulary = self.getVocabulary()
if vocabulary is None:
raise
term = vocabulary.getTerm(value)
self.addTerm(term)
return term
def getTermByToken(self, token):
try:
return super(ExtendingVocabulary, self).getTermByToken(token)
except LookupError:
vocabulary = self.getVocabulary()
if vocabulary is None:
raise
term = vocabulary.getTermByToken(token)
self.addTerm(term)
return term
def foreign_source(value_column, options):
"""Generate a vocabulary containing terms for each possible value
you can set in a SQLAlchemy foreign key.
"""
defaults = []
if not options['required']:
defaults.append(SimpleTerm(title=_(u'(not set)'), value=None))
session = Session()
table = value_column.table
columns = [value_column,]
if 'foreignTitleColumn' in options:
if isinstance(options['foreignTitleColumn'], basestring):
columns.append(table.columns[options['foreignTitleColumn']])
else:
for identifier in options['foreignTitleColumn']:
columns.append(table.columns[identifier])
del options['foreignTitleColumn']
else:
columns.append(value_column)
if 'foreignTitleFactory' in options:
title_factory = options['foreignTitleFactory']
del options['foreignTitleFactory']
else:
title_factory = lambda d: unicode(d[0])
def create_terms(query):
for result in query.all():
yield SimpleTerm(
title=title_factory(result[1:]),
value=result[0])
full_query = session.query(*columns)
if 'foreignTitleQuery' in options:
title_terms = create_terms(options['foreignTitleQuery'](full_query))
full_terms = create_terms(full_query)
del options['foreignTitleQuery']
else:
title_terms = create_terms(full_query)
full_terms = None
return ExtendingVocabulary(defaults + list(title_terms), full_terms) | zeam.form.rdb | /zeam.form.rdb-1.0.1.tar.gz/zeam.form.rdb-1.0.1/src/zeam/form/rdb/source.py | source.py |
import sqlalchemy
from grokcore import component as grok
from zope.component import provideAdapter
from zope.interface import Interface
from zeam.form.base.interfaces import IFieldFactory
from zeam.form.ztk import widgets as fields
from zeam.form.rdb.source import foreign_source
class IFieldBuilder(Interface):
pass
class SQLFieldBuilder(object):
grok.implements(IFieldBuilder)
field = fields.TextLineField
sql_field = sqlalchemy.types.String
def __init__(self, sql_type):
self.sql_type = sql_type
@classmethod
def register(cls):
provideAdapter(cls, (cls.sql_field,), IFieldBuilder)
def __call__(self, sql_field):
options = sql_field.info.copy()
instance_options = {}
if 'identifier' not in options:
options['identifier'] = sql_field.name
if 'title' not in options:
options['title'] = unicode(sql_field.description)
if 'required' not in options:
options['required'] = not sql_field.nullable
if 'defaultValue' not in options:
if sql_field.default is not None:
options['defaultValue'] = sql_field.default.arg
if 'mode' in options:
instance_options['mode'] = options['mode']
if len(sql_field.foreign_keys):
foreign_key = sql_field.foreign_keys[0]
factory = fields.ChoiceField
options['source'] = foreign_source(foreign_key.column, options)
elif 'factory' in options:
factory = options['factory']
del options['factory']
else:
factory = self.field
field = factory(**options)
for name, value in instance_options.iteritems():
setattr(field, name, value)
return field
class StringFieldBuilder(SQLFieldBuilder):
pass
class TextFieldBuilder(SQLFieldBuilder):
field = fields.TextField
sql_field = sqlalchemy.types.Text
class IntegerFieldBuilder(SQLFieldBuilder):
field = fields.IntegerField
sql_field = sqlalchemy.types.Integer
class FloatFieldBuilder(SQLFieldBuilder):
field = fields.FloatField
sql_field = sqlalchemy.types.Float
class DateFieldBuilder(SQLFieldBuilder):
field = fields.DateField
sql_field = sqlalchemy.types.Date
class DatetimeFieldBuilder(SQLFieldBuilder):
field = fields.DatetimeField
sql_field = sqlalchemy.types.DateTime
class TimeFieldBuilder(SQLFieldBuilder):
field = fields.TimeField
sql_field = sqlalchemy.types.Time
class BooleanFieldBuilder(SQLFieldBuilder):
field = fields.BooleanField
sql_field = sqlalchemy.types.Boolean
class ColumnFieldFactory(object):
"""Generate zeam.form fields out of a SQLAlchemy column.
"""
grok.implements(IFieldFactory)
def __init__(self, column):
self.column = column
def produce(self):
factory = IFieldBuilder(self.column.type)
yield factory(self.column)
class TableFieldFactory(object):
"""Generate zeam.form fields out of a SQLAlchemy table.
"""
grok.implements(IFieldFactory)
def __init__(self, table):
self.table = table
def produce(self):
for column in self.table.columns:
if column.primary_key:
continue
factory = IFieldBuilder(column.type)
yield factory(column)
def register():
# Factories
StringFieldBuilder.register()
TextFieldBuilder.register()
IntegerFieldBuilder.register()
FloatFieldBuilder.register()
DateFieldBuilder.register()
DatetimeFieldBuilder.register()
TimeFieldBuilder.register()
BooleanFieldBuilder.register()
# Field producer
provideAdapter(
ColumnFieldFactory,
(sqlalchemy.Column,))
provideAdapter(
TableFieldFactory,
(sqlalchemy.Table,)) | zeam.form.rdb | /zeam.form.rdb-1.0.1.tar.gz/zeam.form.rdb-1.0.1/src/zeam/form/rdb/factories.py | factories.py |
===============
zeam.form.silva
===============
``zeam.form.silva`` is the integration of `Zeam Form
<http://pypi.python.org/pypi/zeam.form.base>`_ in `Silva`_.
This packages provides forms for SMI (including default add and edit
forms for content), ZMI (service configuration forms), and public
views usage (page forms, and viewlet/content provider forms).
For more information about this, please check the `Silva developer
documentation`_.
Code repository
===============
You can find the code of this extension in Git:
https://github.com/silvacms/zeam.form.silva
.. _Silva: http://silvacms.org
.. _Silva developer documentation: http://docs.silvacms.org/latest/
| zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/README.txt | README.txt |
import logging
from zeam import component
from zeam.form.base.interfaces import IFormData
from zeam.form.silva.interfaces import IXMLFormSerialization
from zeam.form.silva.interfaces import IXMLFieldSerializer
from zeam.form.silva.interfaces import IXMLFieldDeserializer
from Products.Formulator.Errors import ValidationError
from Products.Formulator.zeamsupport import IFormulatorField
logger = logging.getLogger('silva.core.xml')
class FieldSerializer(component.Component):
"""Make possible to serialize a field in XML.
"""
component.adapts(IFormulatorField, IFormData)
component.provides(IXMLFieldSerializer)
def __init__(self, field, form, value):
self.identifier = field.identifier
self.field = field._field
self.form = form
self.value = value
def serialize(self, producer):
if self.value is not None:
self.field.validator.serializeValue(
self.field, self.value, producer)
def __call__(self, producer):
self.serialize(producer)
class FieldDeserializer(component.Component):
"""Make possible to deserialize a field in XML.
"""
component.adapts(IFormulatorField, IFormData)
component.provides(IXMLFieldDeserializer)
def __init__(self, field, form):
self.identifier = field.identifier
self.field = field._field
self.form = form
def deserialize(self, data, context=None):
try:
return self.field.validator.deserializeValue(
self.field, data, context=context)
except ValidationError as error:
logger.error(
u'Cannot set Formulator field value %s: %s',
self.field.getId(), str(error.error_text))
def write(self, value):
self.form.getContentData().set(self.identifier, value)
def __call__(self, data, context=None):
self.write(self.deserialize(data, context=context))
class XMLFormSerialization(component.Component):
component.adapts(IFormData)
component.provides(IXMLFormSerialization)
def __init__(self, form):
self.form = form
def getSerializers(self):
form = self.form
assert form.getContent() is not None
content = form.getContentData()
for field in form.fields:
try:
value = content.get(field.identifier)
except KeyError:
continue
factory = component.getComponent(
(field, form), IXMLFieldSerializer)
yield factory(field, form, value)
def getDeserializers(self):
form = self.form
deserializers = {}
for field in form.fields:
deserializers[field.identifier] = component.getWrapper(
(field, form), IXMLFieldDeserializer)
return deserializers | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/xml.py | xml.py |
from Acquisition import aq_base
from persistent.interfaces import IPersistent
from zope.interface import Interface
from zeam.form.base.datamanager import ObjectDataManager
from zeam.form.base.datamanager import BaseDataManager
from zeam.form.base.interfaces import IFields
from zeam.form.silva import interfaces
from zeam import component
_marker = object()
class SilvaDataManager(ObjectDataManager):
"""Try to use in priority set_ and get_ methods when setting and
getting values on an object, paying attention to the Acquisition.
"""
def get(self, identifier):
if hasattr(aq_base(self.content), 'get_%s' % identifier):
getter = getattr(self.content, 'get_%s' % identifier)
return getter()
if not hasattr(aq_base(self.content), identifier):
raise KeyError(identifier)
return getattr(self.content, identifier)
def set(self, identifier, value):
if hasattr(aq_base(self.content), 'set_%s' % identifier):
setter = getattr(self.content, 'set_%s' % identifier)
return setter(value)
return setattr(self.content, identifier, value)
class FieldValueWriter(component.Component):
"""Write a Formulator field data on an object.
"""
component.provides(interfaces.IFieldValueWriter)
component.implements(interfaces.IFieldValueWriter)
component.adapts(IPersistent, Interface)
def __init__(self, identifier, field, content, form):
self.identifier = identifier
self.field = field
self.form = form
self.content = content
def delete(self):
if self.identifier in self.content.__dict__:
del self.content.__dict__[self.identifier]
self.content._p_changed = True
def __call__(self, value):
self.content.__dict__[self.identifier] = value
self.content._p_changed = True
class FieldValueReader(component.Component):
"""Read a Formulator field data from an object.
"""
component.provides(interfaces.IFieldValueReader)
component.implements(interfaces.IFieldValueReader)
component.adapts(Interface, Interface)
def __init__(self, identifier, field, content, form):
self.identifier = identifier
self.field = field
self.content = content
self.form = form
def __call__(self, default=None):
return self.content.__dict__.get(self.identifier, default)
class FieldValueDataManager(BaseDataManager):
"""A data manager that adapt each of the fields separatly in
order to set or get its value.
"""
def __init__(self, form, content):
self.form = form
self.content = content
self._readers = {}
self._writers = {}
def _get(self, identifier, cache, iface):
field = self.form.fields[identifier]
factory = cache.get(identifier, _marker)
if factory is _marker:
factory = component.getComponent(
(self.form.fields[identifier], self.form), provided=iface)
cache[identifier] = factory
return factory(identifier, field, self.content, self.form)
def get(self, identifier):
reader = self._get(
identifier, self._readers, interfaces.IFieldValueReader)
value = reader(default=_marker)
if value is _marker:
raise KeyError(identifier)
return value
def set(self, identifier, value):
writer = self._get(
identifier, self._writers, interfaces.IFieldValueWriter)
writer(value)
def delete(self, identifier):
writer = self._get(
identifier, self._writers, interfaces.IFieldValueWriter)
writer.delete()
def FieldValueDataManagerFactory(self, content):
return FieldValueDataManager(self, content)
class MultiDataManager(BaseDataManager):
def __init__(self, configuration, content):
self._managers = managers = {}
for field, factory in configuration:
manager = factory(content)
if isinstance(field, basestring):
managers[field] = manager
elif IFields.providedBy(field):
for unique_field in field:
manager[unique_field.identifier] = manager
elif field is None:
if None in managers:
raise ValueError('More than one default manager')
managers[None] = manager
self.content = content
def get(self, identifier):
manager = self._managers.get(identifier)
if manager is None:
manager = self._managers[None]
return manager.get(identifier)
def set(self, identifier, value):
manager = self._managers.get(identifier)
if manager is None:
manager = self._managers[None]
manager.set(identifier, value)
def delete(self, identifier):
manager = self._managers.get(identifier)
if manager is None:
manager = self._managers[None]
manager.delete(identifier)
def MultiDataManagerFactory(configuration):
def Factory(content):
return MultiDataManager(configuration, content)
return Factory | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/datamanager.py | datamanager.py |
from zope import interface
from zeam.form.base.interfaces import IFormData, IAction, IWidgetFactory
# Integrate a form in Silva.
class ISilvaFormData(interface.Interface):
"""A form data in Silva.
"""
class ISMIForm(ISilvaFormData, IFormData):
"""A form in SMI.
"""
def get_content_path(content):
"""Return the relative path of the content.
"""
class IDisplayWidgetFactory(IWidgetFactory):
"""Create widgets suitable for display only forms.
"""
class IPublicForm(ISilvaFormData, IFormData):
"""A form for public display.
"""
# Define style for actions
class IRemoverAction(IAction):
"""An action that appear in red.
"""
class ICancelerAction(IAction):
"""An action that cancel something.
"""
class IDefaultAction(IAction):
"""Mark the default action.
"""
# Define categories of actions for RESTForm.
class IRESTAction(IAction):
"""Action design to be used with a RESTForm, that have a special
meaning.
"""
class IRESTSuccessAction(IRESTAction):
"""Action just send success on success.
"""
class IRESTCloseAction(IRESTAction):
"""Do not call the action callback, just close the RESTForm.
"""
class IRESTCloseOnSuccessAction(IRESTCloseAction, IRESTSuccessAction):
"""Call the action callback, and close the rest form upon success.
"""
class IRESTRefreshAction(IRESTAction):
"""Trigger the refresh of a form component on the main view.
"""
refresh = interface.Attribute(u'Identifier to refresh')
class IRESTExtraPayloadProvider(interface.Interface):
"""Adapt an action to provides extra payload.
"""
def get_extra_payload(form):
"""Return the extra payload for the given form.
"""
# This is used by the data manager FieldValueDataManager
class IFieldValueWriter(interface.Interface):
"""Write a field value on a content.
"""
def __init__(field, form, content):
"""Adapt the given field and content.
"""
def delete():
"""Remove the value.
"""
def __call__(value):
"""Save value on the given content.
"""
class IFieldValueReader(interface.Interface):
"""Read a field value from a content.
"""
def __init__(field, form, content):
"""Adapt the given field and content.
"""
def __call__():
"""Read the given value.
"""
class IFormLookup(interface.Interface):
"""Return the correct form that match a prefix.
"""
def fields(self):
"""Return the associated fields.
"""
def lookup(self, key):
"""Return the associated form.
"""
class IXMLFieldSerializer(interface.Interface):
identifier = interface.Attribute(u"Field identifier")
def __call__(producer):
"""Serialize field.
"""
class IXMLFieldDeserializer(interface.Interface):
def __call__(data, context=None):
"""Deserialize field.
"""
class IXMLFormSerialization(interface.Interface):
def getSerializer():
"""Return field XML serializer.
"""
def getDeserializer():
"""Return field XML deserializer.
""" | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/interfaces.py | interfaces.py |
from five import grok
from zope.interface import Interface
from silva.ui.rest.base import UIREST
from zeam.form.base.errors import Error
from zeam.form.base.interfaces import IFormCanvas, ICollection, IError
from zeam.form.composed.interfaces import ISubFormGroup
from zeam.form.silva.utils import convert_request_form_to_unicode
from zeam.form.silva.interfaces import IFormLookup
def is_prefix(prefix, value):
return (value.startswith(prefix) and
(len(value) == len(prefix) or
value[len(prefix)] == '.'))
def serialize_error(rest, errors):
result = {errors.identifier: rest.translate(errors.title)}
if ICollection.providedBy(errors):
for error in errors:
result.update(serialize_error(rest, error))
return result
class DefaultFormLookup(grok.Adapter):
grok.context(Interface)
grok.provides(IFormLookup)
grok.implements(IFormLookup)
def __init__(self, form):
self.form = form
def fields(self):
return self.form.fields
def lookup(self, key):
if self.form.prefix == key:
return self
raise KeyError(key)
class SubFormLookup(DefaultFormLookup):
grok.context(ISubFormGroup)
def lookup(self, key):
for subform in self.form.allSubforms:
if is_prefix(subform.prefix, key):
subfetcher = IFormLookup(subform)
if subform.prefix == key:
return subfetcher
return subfetcher.lookup(key)
return super(SubFormLookup, self).lookup(key)
class RESTValidatorForm(UIREST):
grok.name('zeam.form.silva.validate')
grok.context(IFormCanvas)
def validate(self):
convert_request_form_to_unicode(self.request.form)
info = {'success': True}
fieldname = self.request.form['prefix.field']
# We need to update the form first, since this is the common
# place to configure more fields.
self.context.update()
try:
lookup = IFormLookup(self.context).lookup(
self.request.form['prefix.form'])
except KeyError:
info['success'] = False
else:
# Look for extractor, extract and validate value.
for field in lookup.fields():
extractor = lookup.form.widgetFactory.extractor(field)
if extractor is not None:
if extractor.identifier == fieldname:
value, error = extractor.extract()
if error is None:
error = field.validate(value, self.context)
if error is not None:
if not IError.providedBy(error):
error = Error(title=error, identifier=fieldname)
info['success'] = False
info['errors'] = serialize_error(self, error)
break
else:
info['success'] = False
return self.json_response(info)
def POST(self):
return self.validate() | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/validation.py | validation.py |
from Acquisition import aq_inner, aq_parent
from five import grok
from zope.interface import Interface
from silva.core.interfaces import IRoot, IZMIObject
from silva.core.interfaces.errors import ContentError
from silva.translations import translate as _
from zope.traversing.browser import absoluteURL
from zeam.form.base import SUCCESS, FAILURE
from zeam.form.base.actions import Action, DecoratedAction
from zeam.form.base.interfaces import IFormData, IAction
from zeam.form.base.widgets import ActionWidget
from zeam.form.ztk.actions import EditAction as BaseEditAction
from .interfaces import ISMIForm, ISilvaFormData, IDisplayWidgetFactory
from .interfaces import IRemoverAction, ICancelerAction, IDefaultAction
from .interfaces import IRESTCloseOnSuccessAction, IRESTCloseAction
class EditAction(BaseEditAction):
"""Edit action
"""
grok.implements(
IRESTCloseOnSuccessAction,
IDefaultAction)
title = _(u"Save changes")
description = _(u"Save modifications on the item")
accesskey = u'ctrl+s'
def available(self, form):
return not IDisplayWidgetFactory.providedBy(form.widgetFactory)
def __call__(self, form):
try:
status = super(EditAction, self).__call__(form)
except (ContentError, ValueError), error:
if ISilvaFormData.providedBy(form):
form.send_message(error.args[0], type="error")
else:
form.status = error.args[0]
return FAILURE
if ISilvaFormData.providedBy(form):
if status is SUCCESS:
form.send_message(_(u"Changes saved."), type="feedback")
return status
class PopupAction(Action):
"""An action that opens a popup form.
"""
action = None
def __call__(self, form):
# It should never be called actually.
return SUCCESS
class LinkAction(Action):
"""An action that opens as a link in a given target. (Only works in SMI).
"""
target = '_blank'
class PopupWidget(ActionWidget):
"""Widget to style popup buttons
"""
grok.adapts(PopupAction, IFormData, Interface)
def url(self):
return '/'.join(
(absoluteURL(self.form.context, self.request),
'++rest++' + self.component.action))
class SMIActionWidget(ActionWidget):
grok.adapts(IAction, ISMIForm, Interface)
def update(self):
super(SMIActionWidget, self).update()
self.is_default = IDefaultAction.providedBy(self.component)
self.css_class = ''
self.icon = 'ui-icon ui-icon-radio-on'
if self.is_default:
self.icon = 'icon form_check'
self.css_class = 'default-form-control'
class SMILinkActionWidget(SMIActionWidget):
grok.adapts(LinkAction, ISMIForm, Interface)
def update(self):
super(SMILinkActionWidget, self).update()
self.target = self.component.target
class SMIRemoverWidget(ActionWidget):
grok.adapts(IRemoverAction, ISMIForm, Interface)
class CancelAction(Action):
"""An action to cancel
"""
grok.implements(IRESTCloseAction, ICancelerAction)
title = _(u"Cancel")
description = _(u"Go back to the previous screen")
accesskey = u'ctrl+z'
screen = 'content'
def getRedirectedContent(self, form):
return form.context
def __call__(self, form):
form.redirect(form.url(obj=self.getRedirectedContent(form)))
return SUCCESS
class CancelAddAction(CancelAction):
"""Cancel an add action.
"""
description = _(
u"Go back to the folder view without adding the item")
class CancelConfigurationAction(CancelAction):
description = _(u'Go back to the site preferences')
screen = 'admin'
def getRedirectedContent(self, form):
content = form.context
if IZMIObject.providedBy(content):
return aq_parent(aq_inner(content))
return content
class CancelEditAction(CancelAction):
"""Cancel an edit action.
"""
title = _(u"Back")
description = _(u"Go back to the folder view")
def getRedirectedContent(self, form):
content = form.context
if not IRoot.providedBy(content):
content = aq_parent(aq_inner(content))
return content
class SMICancelWidget(ActionWidget):
"""Widget to style Cancel buttons
"""
grok.adapts(ICancelerAction, ISMIForm, Interface)
def update(self):
super(SMICancelWidget, self).update()
self.screen = self.component.screen
self.contentPath = self.form.get_content_path(
self.component.getRedirectedContent(self.form))
class ExtractedDecoratedAction(DecoratedAction):
"""Action that can be used a factory for the decorator @action,
which extract data itself before calling the decorated method.
"""
def __call__(self, form):
data, errors = form.extractData()
if errors:
return FAILURE
# We directly give data.
return super(ExtractedDecoratedAction, self).__call__(form, data) | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/actions.py | actions.py |
import json
from operator import itemgetter
from five import grok
from megrok import pagetemplate as pt
from zope.traversing.browser import absoluteURL
from silva.ui.rest.base import UIREST, SMITransaction
from silva.ui.rest import helper
from silva.ui.rest.exceptions import RESTRedirectHandler
from zeam.form.base.form import FormCanvas, Form
from zeam.form.base.markers import SUCCESS, FAILURE
from zeam.form.silva import interfaces
from zeam.form.silva.utils import SilvaFormData
from zeam.form.silva.utils import convert_request_form_to_unicode
REST_ACTIONS_TO_TOKEN = [
(interfaces.IRESTCloseOnSuccessAction, 'close_on_success'),
(interfaces.IRESTCloseAction, 'close'),
(interfaces.IAction, 'send')]
class RefreshExtraPayload(grok.Adapter):
grok.context(interfaces.IRESTRefreshAction)
grok.provides(interfaces.IRESTExtraPayloadProvider)
def get_extra_payload(self, form):
return {'refresh': self.context.refresh}
class PopupCanvas(helper.UIHelper, SilvaFormData, FormCanvas):
grok.baseclass()
novalidation = False
def update(self):
pass
def renderActions(self):
def renderAction(action):
for rest_action, action_type in REST_ACTIONS_TO_TOKEN:
if rest_action.providedBy(action.component):
break
return {
'label': self.translate(action.title),
'name': action.identifier,
'action': action_type,
'default': interfaces.IDefaultAction.providedBy(action.component)}
return map(renderAction, self.actionWidgets)
def updateForm(self):
convert_request_form_to_unicode(self.request.form)
self.update()
form, action, status = self.updateActions()
if status is FAILURE:
# Render correctly the validation errors
for error in form.formErrors:
self.send_message(error.title, type="error")
self.updateWidgets()
info = {'ifaces': ['popup'],
'success': status is SUCCESS}
if status is SUCCESS:
extra = interfaces.IRESTExtraPayloadProvider(action, None)
if extra is not None:
info['extra'] = extra.get_extra_payload(self)
success_only = interfaces.IRESTSuccessAction.providedBy(action)
if not (success_only and status == SUCCESS):
actions = self.renderActions()
def findDefault(actions):
candidates = filter(itemgetter('default'), actions)
if not candidates:
candidates = actions
return candidates[0]['name'] if candidates else None
info.update(
{'label': self.translate(self.label),
'widgets': self.render(),
'prefix': self.prefix,
'actions': actions,
'url': absoluteURL(self, self.request),
'default': findDefault(actions),
'validation': not self.novalidation})
return {'content': info}
def renderForm(self):
with SMITransaction(self):
data = self.updateForm()
for provider in self.needed():
provider(self, data)
return data
class RESTPopupForm(PopupCanvas, UIREST):
grok.baseclass()
def __init__(self, context, request):
UIREST.__init__(self, context, request)
FormCanvas.__init__(self, context, request)
def GET(self):
try:
return self.json_response(self.renderForm())
except RESTRedirectHandler as handler:
return handler.publish(self)
def POST(self):
try:
return self.json_response(self.renderForm())
except RESTRedirectHandler as handler:
return handler.publish(self)
class PopupForm(PopupCanvas, Form):
grok.baseclass()
def __call__(self):
"""Popup form as a view.
"""
self.response.setHeader('Content-Type', 'application/json')
return json.dumps(self.renderForm())
class RESTFormTemplate(pt.PageTemplate):
pt.view(PopupCanvas) | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/form/popup.py | popup.py |
from zExceptions import Redirect
from five import grok
from megrok import pagetemplate as pt
from grokcore.layout.interfaces import IPage, ILayout
from zope import component
from zope.interface import Interface
from zope.publisher.publish import mapply
from zope.publisher.interfaces.browser import IDefaultBrowserLayer
from zeam.form import base, viewlet
from zeam.form.silva.utils import SilvaFormData
from zeam.form.silva.utils import convert_request_form_to_unicode
from zeam.form.silva.interfaces import IPublicForm, ICancelerAction
from zeam.form.ztk import validation
from zeam.form.base.widgets import ActionWidget
from zeam.form.base.interfaces import IAction
from silva.core import conf as silvaconf
from silva.core.layout.interfaces import ISilvaLayer
from silva.core.views.views import HTTPHeaderView
class IPublicFormResources(IDefaultBrowserLayer):
"""Resources for Silva forms.
"""
silvaconf.resource('public.css')
class SilvaForm(HTTPHeaderView, SilvaFormData):
"""Form in Silva.
"""
grok.baseclass()
grok.implements(IPage)
dataValidators = [validation.InvariantsValidation]
def __init__(self, context, request):
super(SilvaForm, self).__init__(context, request)
self.__name__ = self.__view_name__
self.layout = None
def default_namespace(self):
namespace = super(SilvaForm, self).default_namespace()
namespace['layout'] = self.layout
return namespace
def content(self):
return self.render()
def __call__(self):
convert_request_form_to_unicode(self.request.form)
self.layout = component.getMultiAdapter(
(self.request, self.context), ILayout)
mapply(self.update, (), self.request)
if self.request.response.getStatus() in (302, 303):
# A redirect was triggered somewhere in update(). Don't
# continue processing the form
return
self.updateForm()
if self.request.response.getStatus() in (302, 303):
return
return self.layout(self)
class PublicForm(SilvaForm, base.Form):
"""Regular SMI form.
"""
grok.baseclass()
grok.layer(ISilvaLayer)
grok.require('zope.Public')
grok.implements(IPublicForm)
class PublicFormTemplate(pt.PageTemplate):
pt.view(PublicForm)
class PublicActionWidget(ActionWidget):
grok.adapts(IAction, IPublicForm, Interface)
## ovverride ActionWidget function
def htmlClass(self):
if ICancelerAction.providedBy(self.component):
return 'action cancel'
return 'action submit'
class PublicViewletForm(SilvaFormData, viewlet.ViewletForm):
""" Base form in viewlet
"""
grok.baseclass()
def available(self):
for action in self.actions:
if action.available(self):
return True
return False
def update(self):
convert_request_form_to_unicode(self.request.form)
return super(PublicViewletForm, self).update()
def redirect(self, url):
# Raise redirect exception to be not to render the current
# page anymore.
raise Redirect(url)
class PublicContentProviderForm(SilvaFormData, viewlet.ViewletManagerForm):
grok.baseclass()
def update(self):
convert_request_form_to_unicode(self.request.form)
return super(PublicContentProviderForm, self).update()
def redirect(self, url):
# Raise redirect exception to be not to render the current
# page anymore.
raise Redirect(url) | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/form/public.py | public.py |
from AccessControl.security import checkPermission
from five import grok
from megrok import pagetemplate as pt
from zope.interface import Interface
from zope.component import queryMultiAdapter
from zope.component import getMultiAdapter
from zope.configuration.name import resolve
from zeam.form import composed, table
from zeam.form.base.actions import Actions, action
from zeam.form.base.fields import Fields
from zeam.form.base.form import FormCanvas
from zeam.form.base.interfaces import IWidget, IAction
from zeam.form.base.markers import DISPLAY, SUCCESS, FAILURE, NO_VALUE
from zeam.form.composed.form import SubFormGroupBase
from zeam.form.ztk import validation
from Products.Silva.ExtensionRegistry import extensionRegistry
from silva.core import conf as silvaconf
from silva.core.conf.interfaces import ITitledContent
from silva.core.conf.utils import getFactoryName
from silva.core.views import views as silvaviews
from silva.core.interfaces.content import IVersionedObject
from silva.ui.interfaces import ISilvaUIDependencies
from silva.translations import translate as _
from silva.ui.rest import PageREST, RedirectToPage
from ..actions import CancelAddAction, CancelEditAction, CancelAction
from ..actions import EditAction, ExtractedDecoratedAction
from ..datamanager import SilvaDataManager
from ..interfaces import ISMIForm, IDefaultAction, IDisplayWidgetFactory
from ..utils import SilvaFormData
from ..utils import convert_request_form_to_unicode
class IFormSilvaUIResources(ISilvaUIDependencies):
silvaconf.resource('smi.js')
class SMIFormPortlets(silvaviews.ViewletManager):
"""Report information on assets.
"""
grok.context(Interface)
grok.view(ISMIForm)
grok.name('portlets')
class SMIDisplayWidgetFactory(object):
grok.implements(IDisplayWidgetFactory)
def __init__(self, form, request):
self.form = form
self.request = request
def widget(self, field):
if not field.available(self.form):
return None
mode = 'input' if IAction.providedBy(field) else 'display'
return getMultiAdapter(
(field, self.form, self.request),
IWidget, name=mode)
def extractor(self, field):
# Read-only fields can not be extracted.
return None
class SMIForm(SilvaFormData, PageREST, FormCanvas):
"""Regular SMI form.
"""
grok.baseclass()
grok.name('content')
grok.require('silva.ChangeSilvaContent')
grok.implements(ISMIForm)
dataValidators = [validation.InvariantsValidation]
dataManager = SilvaDataManager
def __init__(self, context, request):
PageREST.__init__(self, context, request)
FormCanvas.__init__(self, context, request)
def update(self):
pass
def redirect(self, url):
raise RedirectToPage(url)
def payload(self):
convert_request_form_to_unicode(self.request.form)
self.update()
form, action, status = self.updateActions()
if status is FAILURE:
# Render correctly the validation errors
for error in form.formErrors:
self.send_message(error.title, type="error")
self.updateWidgets()
result = {'ifaces': ['form'],
'success': status == SUCCESS,
'forms': self.render()}
portlets = queryMultiAdapter(
(self.context, self.request, self), name='portlets')
if portlets is not None:
portlets.update()
rendered_portlets = portlets.render().strip()
if rendered_portlets:
result['portlets'] = rendered_portlets
return result
class SMIFormTemplate(pt.PageTemplate):
pt.view(SMIForm)
class ConfigurationForm(SMIForm):
grok.baseclass()
grok.name('admin')
grok.require('zope2.ViewManagementScreens')
ignoreContent = False
def get_menu_title(self):
return self.label
def get_menu_parent(self):
parent = super(ConfigurationForm, self).get_menu_parent()
parent['screen'] = 'admin'
return parent
class SMITableForm(SMIForm, table.TableForm):
"""SMI table forms.
"""
grok.baseclass()
class SMITableFormTemplate(pt.PageTemplate):
pt.view(SMITableForm)
class SMIComposedForm(SilvaFormData, PageREST, SubFormGroupBase, FormCanvas):
"""SMI Composed forms.
"""
grok.baseclass()
grok.implements(ISMIForm)
grok.require('silva.ChangeSilvaContent')
def __init__(self, context, request):
PageREST.__init__(self, context, request)
SubFormGroupBase.__init__(self, context, request)
FormCanvas.__init__(self, context, request)
def payload(self):
convert_request_form_to_unicode(self.request.form)
self.update()
form, action, status = SubFormGroupBase.updateActions(self)
if action is None:
form, action, status, FormCanvas.updateActions(self)
if status is FAILURE:
# Render correctly the validation errors
for error in form.formErrors:
self.send_message(error.title, type="error")
SubFormGroupBase.updateWidgets(self)
FormCanvas.updateWidgets(self)
result = {'ifaces': ['form'],
'success': status == SUCCESS,
'forms': self.render()}
portlets = queryMultiAdapter(
(self.context, self.request, self), name='portlets')
if portlets is not None:
portlets.update()
rendered_portlets = portlets.render().strip()
if rendered_portlets:
result['portlets'] = rendered_portlets
return result
class SMIComposedFormTemplate(pt.PageTemplate):
pt.view(SMIComposedForm)
class ComposedConfigurationForm(SMIComposedForm):
grok.baseclass()
grok.name('admin')
grok.require('zope2.ViewManagementScreens')
ignoreContent = False
def get_menu_title(self):
return self.label
def get_menu_parent(self):
parent = super(ComposedConfigurationForm, self).get_menu_parent()
parent['screen'] = 'admin'
return parent
class SMISubForm(SilvaFormData, composed.SubForm):
"""SMI Sub forms.
"""
grok.baseclass()
grok.implements(ISMIForm)
dataValidators = [validation.InvariantsValidation]
def get_content_path(self, content):
return self.parent.get_content_path(content)
class SMISubEditForm(SMISubForm):
grok.baseclass()
grok.require('silva.ReadSilvaContent')
dataManager = SilvaDataManager
ignoreContent = False
actions = Actions(
CancelAction(),
EditAction())
def setContentData(self, content):
"""Set edited content. If the content is a versioned content,
choose the correct version. This can change the form display
mode, if the content is only previewable, or if you don't have
the permission to edit it.
"""
original = content
if IVersionedObject.providedBy(original):
content = original.get_editable()
if content is None:
self.widgetFactoryFactory = SMIDisplayWidgetFactory
content = original.get_previewable()
super(SMISubEditForm, self).setContentData(content)
def update(self):
# If you don't have the permission to edit the content, then
# you don't. This can't be done in setContentData, as this is
# called before security is verified.
content = self.getContentData().content
if not checkPermission('silva.ChangeSilvaContent', content):
self.widgetFactoryFactory = SMIDisplayWidgetFactory
class SMISubFormTemplate(pt.PageTemplate):
pt.view(SMISubForm)
class SMISubFormGroup(SilvaFormData, composed.SubFormGroup):
"""SMI sub form group.
"""
grok.baseclass()
def get_content_path(self, content):
return self.parent.get_content_path(content)
class SMISubFormGroupTemplate(pt.PageTemplate):
pt.view(SMISubFormGroup)
class SMISubTableForm(SilvaFormData, table.SubTableForm):
"""SMI Sub table forms.
"""
grok.baseclass()
grok.implements(ISMIForm)
def get_content_path(self, content):
return self.parent.get_content_path(content)
class SMISubTableFormTemplate(pt.PageTemplate):
pt.view(SMISubTableForm)
class SMIAddForm(SMIForm):
""" SMI add form
"""
grok.baseclass()
prefix = 'addform'
fields = Fields(ITitledContent)
ignoreContent = True
actions = Actions(CancelAddAction())
@property
def label(self):
return _('Add a ${content_type}',
mapping={'content_type': self._content_type})
@property
def _content_type(self):
return self.__name__.split('/')[0]
def _add(self, parent, data):
"""Purely create the object. This method can be overriden to
support custom creation needs.
"""
# Search for an addable and a factory
addable = extensionRegistry.get_addable(self._content_type)
if not addable:
raise ValueError(u"Content factory cannot be found. ")
factory = getattr(
resolve(addable['instance'].__module__),
getFactoryName(addable['instance']))
# Build the content
identifier = str(data.getWithDefault('id'))
factory(parent, identifier, data.getWithDefault('title'))
content = getattr(parent, identifier)
self._edit(parent, content, data)
return content
def _edit(self, parent, content, data):
# Set from value
editable_content = self.dataManager(content.get_editable())
for key, value in data.iteritems():
if key not in ITitledContent and value is not NO_VALUE:
editable_content.set(key, value)
@action(
_(u'Save'),
description=_(u"Create a new content"),
factory=ExtractedDecoratedAction,
implements=IDefaultAction,
accesskey=u'ctrl+s')
def save(self, data):
try:
content = self._add(self.context, data)
except ValueError, error:
self.send_message(error.args[0], type=u"error")
return FAILURE
self.send_message(
_(u'Added ${meta_type}.', mapping={'meta_type': self._content_type}),
type="feedback")
raise RedirectToPage(content)
class SMIEditForm(SMIForm):
"""SMI Edit form.
"""
grok.baseclass()
# The permission is read. If the user doesn't have the right to
# change the content, the form mode will be switch to display
# mode.
grok.require('silva.ReadSilvaContent')
prefix = 'editform'
dataManager = SilvaDataManager
ignoreContent = False
actions = Actions(
CancelEditAction(),
EditAction())
@property
def label(self):
return _('Edit a ${content_type}',
mapping={'content_type': self.context.meta_type})
def setContentData(self, content):
"""Set edited content. If the content is a versioned content,
choose the correct version. This can change the form display
mode, if the content is only previewable, or if you don't have
the permission to edit it.
"""
original = content
if IVersionedObject.providedBy(original):
content = original.get_editable()
if content is None:
self.widgetFactoryFactory = SMIDisplayWidgetFactory
content = original.get_previewable()
super(SMIEditForm, self).setContentData(content)
def update(self):
# If you don't have the permission to edit the content, then
# you don't. This can't be done in setContentData, as this is
# called before security is verified.
content = self.getContentData().content
if not checkPermission('silva.ChangeSilvaContent', content):
self.widgetFactoryFactory = SMIDisplayWidgetFactory | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/form/smi.py | smi.py |
(function($,infrae){var create_validator=function(){var $field=$(this);if(!$field.hasClass("form-novalidation")&&!$field.closest(".field-object").length){var $form=$field.closest("form"),field_prefix=$field.attr("data-field-prefix"),form_prefix=$form.attr("name"),form_url=$form.attr("data-form-url");if(form_url){var find_sub_field=function(selector){return $field.is(selector)?$field.children("div.form-field"):$field.find(selector).children("div.form-field")};$field.delegate(".field","change",function(){setTimeout(function(){var values=[{name:"prefix.field",value:field_prefix},{name:"prefix.form",value:form_prefix}],serialize_field=function(){var $input=$(this);if(!$input.is(":checkbox")&&!$input.is(":radio")||$input.is(":checked")){var value=$input.val();if(null!==value){$.isArray(value)||(value=[value]);for(var i=value.length;i>0;i--)values.push({name:$input.attr("name"),value:value[i-1]})}}};$field.find("input").each(serialize_field),$field.find("textarea").each(serialize_field),$field.find("select").each(serialize_field),$.ajax({url:form_url+"/++rest++zeam.form.silva.validate",type:"POST",dataType:"json",data:values,success:function(data){var key,errors=data.errors;if($field.find(".form-error-message").remove(),data.success)return $field.removeClass("form-error"),void 0;if($field.addClass("form-error"),errors)for(key in errors)find_sub_field('div[data-field-prefix="'+key+'"]').after('<div class="form-error-message"><div class="form-error-detail"><p>'+errors[key]+"</p></div></div>")}})},0)})}}};$(document).bind("load-smiplugins",function(event,smi){var Popup=function($popup,extra_array){var popup={},close=$.Deferred(),closing=!1,$form=null,cleanup_form=function(){null!==$form&&($form.trigger("clean-smiform",{form:$form,container:$form,popup:$popup}),$form.remove(),$form=null)},create_callback=function(form_url,data){var action_label=data.label,action_name=data.name,action_type=data.action;return function(){switch(action_type){case"send":case"close_on_success":$form.trigger("serialize-smiform",{form:$form,container:$form,popup:$popup});var form_data=$form.serializeArray();form_data.push({name:action_name,value:action_label}),void 0!==extra_array&&(form_data=form_data.concat(extra_array)),smi.ajax.query(form_url,form_data).then(function(data){return infrae.interfaces.is_implemented_by("popup",data)?"close_on_success"==action_type&&data.success?popup.close(data):$.when(popup.from_data(data)).then(function($form){return infrae.ui.ResizeDialog($popup),$form}):popup.close(data).done(function(data){return $(document).render({data:data,args:[smi]})})},function(){popup.close({})});break;case"close":popup.close({})}return!1}};return $popup.dialog({autoOpen:!1,modal:!0,width:800}),$popup.bind("dialogclose",function(){cleanup_form(),$popup.remove(),closing===!1&&close.reject({})}),$popup.delegate("a.open-screen","click",function(){$popup.dialog("close")}),$.extend(popup,{display:function(builder){return $.when(builder).then(function(){return infrae.ui.ShowDialog($popup,{maxFactor:.8}),popup},function(request){return $.Deferred().reject(request)})},close:function(data){return closing=!0,$popup.dialog("close"),close.resolve(data)},promise:function(){return close.promise()},from_url:function(url){return smi.ajax.query(url).then(function(data){return infrae.interfaces.is_implemented_by("popup",data)?popup.from_data(data):popup.close(data)},function(request){return closing=!0,$popup.dialog("close"),close.reject(request)})},from_data:function(data){var buttons={},submit_url=data.submit_url||data.url;cleanup_form(),$form=$('<form class="form-content form-fields-container" />'),$form.attr("data-form-url",data.url),data.validation||$form.attr("data-form-novalidation","true"),$form.attr("name",data.prefix),$form.html(data.widgets),$form.append('<input type="submit" style="display: none" />'),$popup.dialog("option","title",data.label),$popup.append($form);for(var i=0;data.actions.length>i;i++){var label=data.actions[i].label,callback=create_callback(submit_url,data.actions[i]);buttons[label]=callback,data.actions[i].name==data["default"]&&$form.bind("submit",callback)}return $popup.dialog("option","buttons",buttons),$form.trigger("load-smiform",{form:$form,container:$form,popup:$popup}),$form}}),popup};$.fn.SMIFormPopup=function(options){var $popup=$("<div></div>"),url=void 0;options=$.extend(options,{}),url=void 0!==options.url?options.url:$(this).attr("href");var popup=Popup($popup,options.payload),builder=null;return builder=infrae.interfaces.is_implemented_by("popup",options)?popup.from_data(options):popup.from_url(url),popup.display(builder)},infrae.views.view({iface:"popup",factory:function($content,data){return $content.SMIFormPopup(data)}})}),$(document).on("addline-zeamform",".field-collection-line",function(){var $line=$(this);$line.addClass("form-fields-container"),$line.trigger("loadwidget-smiform")}),$(document).on("loadwidget-smiform",".form-fields-container",function(event){$(this).find("div.field-collection").each(function(){void 0!==$(this).ZeamCollectionWidget&&$(this).ZeamCollectionWidget()}),event.stopPropagation()});var bootstrap_form=function(){var $form=$(this);$form.find(".zeam-select-all").bind("change",function(){var $select=$(this),status=$select.attr("checked");$form.find("."+$select.attr("name")).each(function(){status?$(this).attr("checked",status):$(this).removeAttr("checked")})}),$form.is("form")&&!$form.data("form-novalidation")&&$form.find(".form-section").each(create_validator),$form.find("form").each(function(){var $form=$(this);$form.data("form-novalidation")||$form.find(".form-section").each(create_validator)})};$(document).on("load-smiform",".form-content",bootstrap_form),$(document).ready(function(){$(".form-content").each(bootstrap_form),$(document).on("click",".form-popup",function(){return $(this).SMIFormPopup(),!1})})})(jQuery,infrae); | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/form/static/smi.min.js | smi.min.js |
(function($, infrae) {
/**
* Inline validation on a form.
*/
var create_validator = function() {
var $field = $(this);
if ($field.hasClass('form-novalidation')) {
return;
};
if ($field.closest('.field-object').length) {
return; // We ignore fields in objects
};
var $form = $field.closest('form');
var field_prefix = $field.attr('data-field-prefix');
var form_prefix = $form.attr('name');
var form_url = $form.attr('data-form-url');
if (!form_url) {
return;
};
var find_sub_field = function(selector) {
if (!$field.is(selector)) {
return $field.find(selector).children('div.form-field');
};
return $field.children('div.form-field');
};
$field.delegate('.field', 'change', function () {
setTimeout(function() {
var values = [{name: 'prefix.field', value: field_prefix},
{name: 'prefix.form', value: form_prefix}];
var serialize_field = function() {
var $input = $(this);
if (($input.is(':checkbox') || $input.is(':radio')) &&
!$input.is(':checked')) {
return;
};
var value = $input.val();
if (value === null) {
return;
} else if (!$.isArray(value)) {
value = [value];
};
for (var i=value.length; i > 0; i--) {
values.push({name: $input.attr('name'), value: value[i - 1]});
};
};
$field.find('input').each(serialize_field);
$field.find('textarea').each(serialize_field);
$field.find('select').each(serialize_field);
$.ajax({
url: form_url + '/++rest++zeam.form.silva.validate',
type: 'POST',
dataType: 'json',
data: values,
success: function(data) {
var key, errors = data['errors'];
$field.find('.form-error-message').remove();
if (data['success']) {
// Success, clear the errors
$field.removeClass('form-error');
return;
};
// Report error
$field.addClass('form-error');
if (errors) {
for (key in errors) {
find_sub_field('div[data-field-prefix="' + key + '"]').after(
'<div class="form-error-message"><div class="form-error-detail"><p>' + errors[key] +'</p></div></div>');
};
};
}
});
}, 0);
});
};
$(document).bind('load-smiplugins', function(event, smi) {
/**
* Popup form.
*/
var Popup = function($popup, extra_array) {
var popup = {};
var close = $.Deferred();
var closing = false;
var $form = null;
var cleanup_form = function() {
if ($form !== null) {
$form.trigger('clean-smiform', {form: $form, container: $form, popup: $popup});
$form.remove();
$form = null;
};
};
var create_callback = function(form_url, data) {
var action_label = data['label'];
var action_name = data['name'];
var action_type = data['action'];
return function() {
switch (action_type) {
case 'send':
case 'close_on_success':
$form.trigger('serialize-smiform',
{form: $form, container: $form, popup: $popup});
var form_data = $form.serializeArray();
form_data.push({name: action_name, value: action_label});
if (extra_array !== undefined) {
form_data = form_data.concat(extra_array);
};
// Send request
smi.ajax.query(form_url, form_data).then(
function(data) {
if (infrae.interfaces.is_implemented_by('popup', data)) {
if (action_type == 'close_on_success' && data['success']) {
return popup.close(data);
};
return $.when(popup.from_data(data)).then(function ($form) {
infrae.ui.ResizeDialog($popup);
return $form;
});
};
return popup.close(data).done(function(data) {
return $(document).render({data: data, args: [smi]});
});
}, function(request) {
// On error, just close the popup.
popup.close({});
});
break;
case 'close':
popup.close({});
break;
};
return false;
};
};
$popup.dialog({
autoOpen: false,
modal: true,
width: 800
});
// When the popup is closed, clean its HTML and bindings
$popup.bind('dialogclose', function() {
cleanup_form();
$popup.remove();
// If closing is false, that means the user closed the
// popup by clicking on the close on top of the popup.
if (closing === false) {
close.reject({});
};
});
$popup.delegate('a.open-screen', 'click', function(event) {
$popup.dialog('close');
});
$.extend(popup, {
display: function(builder) {
return $.when(builder).then(
function ($form) {
// Initialize form and widgets JS, show the popup
infrae.ui.ShowDialog($popup, {maxFactor: 0.8});
return popup;
},
function (request) {
// Request failed.
return $.Deferred().reject(request);
});
},
close: function(data) {
closing = true;
$popup.dialog('close');
return close.resolve(data);
},
promise: function() {
return close.promise();
},
from_url: function(url) {
return smi.ajax.query(url).then(
function (data) {
if (infrae.interfaces.is_implemented_by('popup', data)) {
return popup.from_data(data);
};
return popup.close(data);
},
function (request) {
// In case of error, close the popup (to
// trigger the cleaning), return an reject
// not to display it.
closing = true;
$popup.dialog('close');
return close.reject(request);
});
},
from_data: function(data) {
var buttons = {};
var submit_url = data.submit_url || data.url;
// Start by cleaning any existing form
cleanup_form();
$form = $('<form class="form-content form-fields-container" />');
$form.attr('data-form-url', data.url);
if (!data.validation) {
$form.attr('data-form-novalidation', 'true');
};
$form.attr('name', data.prefix);
$form.html(data['widgets']);
// Add an empty input submit to activate form submission with enter
$form.append('<input type="submit" style="display: none" />');
// Set the dialog content
$popup.dialog('option', 'title', data['label']);
$popup.append($form);
for (var i=0; i < data['actions'].length; i++) {
var label = data['actions'][i]['label'];
var callback = create_callback(submit_url, data['actions'][i]);
buttons[label] = callback;
if (data['actions'][i]['name'] == data['default']) {
$form.bind('submit', callback);
};
};
$popup.dialog('option', 'buttons', buttons);
$form.trigger('load-smiform', {form: $form, container: $form, popup: $popup});
return $form;
}
});
return popup;
};
/**
* Open a Form popup.
* @param url: if not undefined, the url for form.
*/
$.fn.SMIFormPopup = function(options) {
var $popup = $('<div></div>');
// Create a popup from a builder
var url = undefined;
options = $.extend(options, {});
if (options.url !== undefined) {
url = options.url;
} else {
url = $(this).attr('href');
};
var popup = Popup($popup, options.payload);
var builder = null;
if (infrae.interfaces.is_implemented_by('popup', options)) {
builder = popup.from_data(options);
} else {
builder = popup.from_url(url);
};
return popup.display(builder);
};
// You can create a popup as a view as well
infrae.views.view({
iface: 'popup',
factory: function($content, data) {
return $content.SMIFormPopup(data);
}
});
});
// Support for collection widget
$(document).on('addline-zeamform', '.field-collection-line', function() {
var $line = $(this);
$line.addClass('form-fields-container');
$line.trigger('loadwidget-smiform');
});
$(document).on('loadwidget-smiform', '.form-fields-container', function(event) {
$(this).find('div.field-collection').each(function() {
if ($(this).ZeamCollectionWidget !== undefined) {
$(this).ZeamCollectionWidget();
};
});
event.stopPropagation();
});
// Bootstrap form
var bootstrap_form = function() {
var $form = $(this);
// Select all
$form.find('.zeam-select-all').bind('change', function() {
var $select = $(this);
var status = $select.attr('checked');
$form.find('.' + $select.attr('name')).each(function() {
if (status) {
$(this).attr('checked', status);
} else {
$(this).removeAttr('checked');
};
});
});
// Invalid Validation on the form.
if ($form.is('form') && ! $form.data('form-novalidation')) {
$form.find('.form-section').each(create_validator);
};
// Inline Validation on the sub-forms.
$form.find('form').each(function() {
var $form = $(this);
if (!$form.data('form-novalidation')) {
$form.find('.form-section').each(create_validator);
};
});
};
// Prepare forms
$(document).on('load-smiform', '.form-content', bootstrap_form);
$(document).ready(function() {
$('.form-content').each(bootstrap_form);
// Prepare Popup
$(document).on('click', '.form-popup', function() {
$(this).SMIFormPopup();
return false;
});
});
})(jQuery, infrae); | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/form/static/smi.js | smi.js |
import logging
import json
from five import grok
from zope.interface import Interface
from zope.traversing.browser import absoluteURL
from zope.publisher.interfaces.browser import IDefaultBrowserLayer
from js.jqueryui import jqueryui
from infrae import rest
from silva.core import conf as silvaconf
from silva.core import interfaces
from silva.core.conf import schema as silvaschema
from silva.core.interfaces.adapters import IIconResolver
from silva.fanstatic import need
from silva.translations import translate as _
from zeam.form.base.errors import Error
from zeam.form.base.markers import NO_VALUE, NO_CHANGE
from zeam.form.base.widgets import WidgetExtractor
from zeam.form.composed.interfaces import ISubForm
from zeam.form.ztk.fields import SchemaField, SchemaFieldWidget
from zeam.form.ztk.fields import registerSchemaField
from zeam.form.silva.interfaces import ISMIForm
logger = logging.getLogger('silva.upload')
def register():
registerSchemaField(FileSchemaField, silvaschema.IBytes)
class FileSchemaField(SchemaField):
"""Field to upload a file.
"""
fileSetLabel = _('Current file.')
fileNotSetLabel = _(u'Not set, please upload a file.')
class BasicFileWidgetInput(SchemaFieldWidget):
grok.adapts(FileSchemaField, Interface, Interface)
grok.name('input')
def prepareContentValue(self, value):
formatted_value = u''
if value is not NO_VALUE:
formatted_value = self.valueToUnicode(NO_CHANGE)
return {self.identifier: formatted_value}
def prepareRequestValue(self, value, extractor):
formatted_value = u''
if (value.get(self.identifier + '.change') in ['change', 'keep'] or
bool(value.get(self.identifier))):
formatted_value = self.valueToUnicode(NO_CHANGE)
return {self.identifier: formatted_value}
def valueStatus(self):
value = self.inputValue()
if value == u'__NO_CHANGE__':
return True
return False
def valueToUnicode(self, value):
if value is NO_CHANGE:
return u'__NO_CHANGE__'
return unicode(value)
class BasicFileWidgetExtractor(WidgetExtractor):
grok.adapts(FileSchemaField, Interface, Interface)
def extract(self):
operation = self.request.form.get(self.identifier + '.change')
if operation == "keep":
return NO_CHANGE, None
if operation == "erase":
return NO_VALUE, None
if operation == "change":
value = self.request.form.get(self.identifier)
if value:
return value, None
return None, Error("Missing file", identifier=self.identifier)
value = self.request.form.get(self.identifier)
if value:
return value, None
return NO_VALUE, None
class IUploadResources(IDefaultBrowserLayer):
silvaconf.resource(jqueryui)
silvaconf.resource('upload.js')
class FileWidgetInput(SchemaFieldWidget):
grok.adapts(FileSchemaField, ISMIForm, Interface)
grok.name('input')
def update(self):
need(IUploadResources)
super(FileWidgetInput, self).update()
def uploadIdentifier(self):
manager = self.request.environ.get('infrae.fileupload.manager')
if manager is None:
raise interfaces.Error('The upload component is not available')
return manager.create_identifier()
def uploadURL(self):
manager = self.request.environ.get('infrae.fileupload.manager')
if manager is None:
raise interfaces.Error('The upload component is not available')
if manager.upload_url:
return manager.upload_url
if ISubForm.providedBy(self.form):
form = self.form.getComposedForm()
else:
form = self.form
return absoluteURL(form, self.request) + \
'/upload'
def prepareContentValue(self, value):
formatted_value = u''
if value is not NO_VALUE:
formatted_value = self.valueToUnicode(NO_CHANGE)
return {self.identifier: formatted_value}
def displayValue(self):
value = self.inputValue()
status = None
label = None
icon = IIconResolver(self.request).get_tag(None)
if value:
label = self.component.fileSetLabel
if value != u'__NO_CHANGE__':
manager = self.request.environ.get('infrae.fileupload.manager')
if manager is None:
raise interfaces.Error(
'The upload component is not available.')
bucket = manager.access_upload_bucket(value)
if bucket is not None:
status = json.dumps(bucket.get_status())
else:
label = self.component.fileNotSetLabel
return {'icon': icon,
'message': label,
'status': status,
'empty': status is None}
def valueToUnicode(self, value):
if value is NO_CHANGE:
return u'__NO_CHANGE__'
return unicode(value)
class UploadedFile(object):
def __init__(self, bucket):
metadata = bucket.get_status()
self.name = metadata.get('filename') # Python filename
self.filename = metadata.get('filename') # Zope filename
self.__descriptor = open(bucket.get_filename(), 'r')
def __getattr__(self, name):
return getattr(self.__descriptor, name)
class FileWidgetExtractor(WidgetExtractor):
grok.adapts(FileSchemaField, ISMIForm, Interface)
def extract(self):
value = self.request.form.get(self.identifier, u'')
if value == "__NO_CHANGE__":
return NO_CHANGE, None
if not value:
return NO_VALUE, None
manager = self.request.environ.get('infrae.fileupload.manager')
if manager is None:
raise interfaces.Error('The upload component is not available')
bucket = manager.access_upload_bucket(value)
if bucket is not None:
if not bucket.is_complete():
return NO_VALUE, _(u"Upload is incomplete.")
return UploadedFile(bucket), None
return NO_VALUE, _(u"Upload failed.")
class Upload(rest.REST):
""" Check security and return information about gp.fileupload upload
"""
grok.adapts(ISMIForm, Interface)
grok.require('silva.ChangeSilvaContent')
grok.name('upload')
def POST(self):
""" get information about file upload
"""
info = self.request.environ['infrae.fileupload.current'].get_status()
return """
<html>
<body data-upload-identifier="%s" data-upload-info="%s">
</body>
</html>
""" % (str(info['identifier']), json.dumps(info).replace('"', '\\"')) | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/widgets/file.py | file.py |
from __future__ import absolute_import
from datetime import datetime
from datetime import date
from DateTime import DateTime
from five import grok
from zope.interface import Interface
from zope.publisher.interfaces.browser import IDefaultBrowserLayer
from js.jqueryui import jqueryui
from silva.core import conf as silvaconf
from silva.translations import translate as _
from silva.fanstatic import need
from zeam.form.base.markers import NO_VALUE
from zeam.form.base.widgets import WidgetExtractor, FieldWidget
from zeam.form.ztk.widgets.date import DatetimeField
from zeam.form.ztk.widgets.date import DateField
class IDateTimeResources(IDefaultBrowserLayer):
silvaconf.resource(jqueryui)
silvaconf.resource('datetime.js')
class DateTimeFieldWidget(FieldWidget):
grok.adapts(DatetimeField, Interface, Interface)
defaultHtmlClass = ['field', 'field-datetime']
displayTime = True
def update(self):
need(IDateTimeResources)
super(DateTimeFieldWidget, self).update()
def prepareContentValue(self, value):
if value is NO_VALUE:
return {self.identifier + '.year': u'',
self.identifier + '.month': u'',
self.identifier + '.day': u'',
self.identifier + '.hour': u'',
self.identifier + '.min': u'',
self.identifier: u''}
if isinstance(value, DateTime):
value = value.asdatetime()
return {self.identifier + '.year': u'%d' % value.year,
self.identifier + '.month': u'%02d' % value.month,
self.identifier + '.day': u'%02d' % value.day,
self.identifier + '.hour': u'%02d' % value.hour,
self.identifier + '.min': u'%02d' % value.minute,
self.identifier: u''}
class DateTimeWidgetExtractor(WidgetExtractor):
grok.adapts(DatetimeField, Interface, Interface)
def extract(self):
identifier = self.identifier
value = self.request.form.get(identifier, None)
if value is None:
return NO_VALUE, None
def extract(key, min_value=None, max_value=None, required=True):
value = self.request.form.get('.'.join((identifier, key)), None)
if not value:
if required:
raise ValueError(u'Missing %s value.' %key)
return min_value
try:
value = int(value)
except ValueError:
raise ValueError((u'%s is not a number.' % key).capitalize())
if min_value and max_value:
if value < min_value or value > max_value:
raise ValueError((u'%s is not within %d and %d.' % (
key, min_value, max_value)).capitalize())
return value
try:
year = extract('year', None, None, self.component.required)
day = extract('day', 1, 31, year is not None)
month = extract('month', 1, 12, year is not None)
hour = extract('hour', 0, 23, False)
minute = extract('min', 0, 59, False)
except ValueError, error:
return (None, _(error))
if year is None:
return (NO_VALUE, None)
try:
return (datetime(year, month, day, hour, minute), None)
except ValueError, error:
return (None, _(str(error).capitalize()))
class DateFieldWidget(DateTimeFieldWidget):
grok.adapts(DateField, Interface, Interface)
defaultHtmlClass = ['field', 'field-date']
displayTime = False
def prepareContentValue(self, value):
if value is NO_VALUE:
return {self.identifier + '.year': u'',
self.identifier + '.month': u'',
self.identifier + '.day': u'',
self.identifier: u''}
return {self.identifier + '.year': u'%d' % value.year,
self.identifier + '.month': u'%02d' % value.month,
self.identifier + '.day': u'%02d' % value.day,
self.identifier: u''}
class DateWidgetExtractor(DateTimeWidgetExtractor):
grok.adapts(DateField, Interface, Interface)
def extract(self):
value, error = super(DateWidgetExtractor, self).extract()
if error is None:
return date(value.year, value.month, value.day), None
return value, error | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/widgets/datetime.py | datetime.py |
from five import grok
from zope.schema.interfaces import ITextLine
from zope.interface import Interface
from zope.publisher.interfaces.browser import IDefaultBrowserLayer
from js.jqueryui import jqueryui
from zeam.form.base import DISPLAY
from zeam.form.base.interfaces import IWidget, IWidgetExtractor
from zeam.form.base.markers import NO_VALUE
from zeam.form.base.widgets import WidgetExtractor, FieldWidget
from zeam.form.ztk.customizations import customize
from zeam.form.ztk.interfaces import ICollectionField
from zeam.form.ztk.widgets.collection import newCollectionWidgetFactory
from zeam.form.ztk.widgets.collection import MultiSelectFieldWidget
from zeam.form.ztk.widgets.textline import TextLineField
from zeam.form.ztk.widgets.uri import URIField
from zeam.form.ztk.widgets.object import ObjectField
from zeam.form.ztk.widgets.object import ObjectFieldWidget
from zeam.form.ztk.widgets.choice import ChoiceFieldWidget
from zeam.form.silva.interfaces import ISMIForm
from silva.core import conf as silvaconf
from silva.core.interfaces.adapters import IIconResolver
from silva.fanstatic import need
@customize(origin=ITextLine)
def customize_textline(field):
field.htmlAttributes['size'] = '40'
class IconDisplayWidget(FieldWidget):
grok.name('silva.icon')
def update(self):
super(IconDisplayWidget, self).update()
self._content = self.form.getContentData().getContent()
self.icon = IIconResolver(self.request).get_tag(self._content)
class IconEditDisplayWidget(IconDisplayWidget):
grok.name('silva.icon.edit')
screen = 'content'
def get_smi_form(self):
form = self.form
while form is not None and not ISMIForm.providedBy(form):
form = getattr(form, 'parent', None)
return form
def update(self):
super(IconEditDisplayWidget, self).update()
self.path = None
form = self.get_smi_form()
if form is not None:
self.path = form.get_content_path(self._content)
class ObjectFieldWidget(ObjectFieldWidget):
grok.adapts(ObjectField, Interface, Interface)
class DisplayObjectFieldWidget(ObjectFieldWidget):
grok.name(unicode(DISPLAY))
grok.global_adapter(
newCollectionWidgetFactory(mode='lines'),
adapts=(ICollectionField, Interface, Interface),
provides=IWidget,
name='lines')
grok.global_adapter(
newCollectionWidgetFactory(mode='multipickup'),
adapts=(ICollectionField, Interface, Interface),
provides=IWidget,
name='multipickup')
grok.global_adapter(
newCollectionWidgetFactory(mode='lines', interface=IWidgetExtractor),
adapts=(ICollectionField, Interface, Interface),
provides=IWidgetExtractor,
name='lines')
class LinesWidget(FieldWidget):
grok.adapts(ICollectionField, TextLineField, Interface, Interface)
grok.name('lines')
def __init__(self, field, value_field, form, request):
super(LinesWidget, self).__init__(field, form, request)
def valueToUnicode(self, value):
return u'\n'.join(value)
class LinesURIWidget(LinesWidget):
grok.adapts(ICollectionField, URIField, Interface, Interface)
class LinesWidgetExtractor(WidgetExtractor):
grok.adapts(ICollectionField, TextLineField, Interface, Interface)
grok.name('lines')
def __init__(self, field, value_field, form, request):
super(LinesWidgetExtractor, self).__init__(field, form, request)
def extract(self):
value, errors = super(LinesWidgetExtractor, self).extract()
if errors is None:
if value is not NO_VALUE:
value = self.component.collectionType(
filter(lambda v: v,
map(lambda s: s.strip('\r'),
value.split('\n'))))
return (value, errors)
class LinesURIWidgetExtractor(LinesWidgetExtractor):
grok.adapts(ICollectionField, URIField, Interface, Interface)
class IMultiPickupFieldResources(IDefaultBrowserLayer):
silvaconf.resource(jqueryui)
silvaconf.resource('jquery.multiselect.js')
silvaconf.resource('multipickup.js')
class MultiPickupFieldWidget(MultiSelectFieldWidget):
grok.name('multipickup')
def update(self):
need(IMultiPickupFieldResources)
super(MultiPickupFieldWidget, self).update()
def htmlClass(self):
return (super(MultiPickupFieldWidget, self).htmlClass() +
' field-multipickup')
class IComboBoxResources(IDefaultBrowserLayer):
silvaconf.resource(jqueryui)
silvaconf.resource('combobox.js')
class ComboBoxFieldWidget(ChoiceFieldWidget):
grok.name('combobox')
def update(self):
need(IComboBoxResources)
super(ComboBoxFieldWidget, self).update() | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/widgets/others.py | others.py |
(function(infrae, $) {
var create_cropping_field = function() {
var $field = $(this),
$input = $field.find('input.field-cropcoordinates'),
$opener = $field.find('a.widget-crop-popup-button'),
$template = $field.find('div.widget-crop-popup').detach();
var required = $input.hasClass('field-required');
infrae.ui.selection.disable($template);
// We use this preload image instead of the $img to get the
// size as a fix to an IE loading issue: in IE the image is
// not loaded before it is displayed, if it is created inside
// an HTML piece.
var preload = new Image();
preload.src = $template.data('image-url');
$opener.bind('click', function(event){
var $popup = $template.clone();
var $img = $popup.find('img.widget-crop-image');
var image_width = preload.width; // Use size from the preload.
var image_height = preload.height;
var original_width = Math.max(40 + image_width, 250),
original_height = 145 + image_height;
var ratio = 0;
var $proportional = $popup.find('input.crop-proportional');
var crop = undefined; //Crop coordinates
if ($input.val()) {
crop = $input.val().replace(
/^\s*(\d+)x(\d+)-(\d+)x(\d+)\s*$/,
'$1,$2,$3,$4').split(',');
};
var need_refresh = false; //Resize need a last refresh with box 0
var jCrop = undefined; //API to change keep ratio and resize
var default_cropping_options = {
aspectRatio: ratio,
onSelect: function(value) {
crop = [value.x, value.y, value.x2, value.y2];
}};
var create_cropping = function(options) {
// Create or recreate the cropping with new options
var current;
options = $.extend({}, default_cropping_options, options);
if (jCrop !== undefined) {
jCrop.destroy();
};
if (crop !== undefined) {
options['setSelect'] = crop;
};
jCrop = $.Jcrop($img, options);
};
// Define popup actions
var actions = {
Cancel: function() {
$popup.dialog('close');
},
Clear: function() {
$input.val('');
$popup.dialog('close');
},
Ok: function(){
if (crop !== undefined) {
$input.val(crop[0] + 'x' +
crop[1] + '-' +
crop[2] + 'x' +
crop[3]);
$popup.dialog('close');
}
}
};
if (required) {
delete actions['Clear'];
};
// Bind proportional option
$proportional.change(function(){
if (jCrop !== null) {
if (!!this.checked) {
ratio = image_width / image_height;
} else {
ratio = 0;
};
jCrop.setOptions({aspectRatio: ratio});
};
});
// Cleanup everything when the popup is closed
$popup.bind('dialogclose', function() {
$popup.remove();
});
$popup.bind('infrae-ui-dialog-resized', function (event, popup_size) {
var candidate_width = popup_size.width - 40;
var candidate_height = popup_size.height - 145;
if ((candidate_width < image_width) ||
(candidate_height < image_height)) {
var ratio = Math.min(
candidate_width/image_width,
candidate_height/image_height);
create_cropping({boxWidth: ratio * image_width,
boxHeight: ratio * image_height});
need_refresh = true;
} else {
if (need_refresh) {
create_cropping();
need_refresh = false;
};
};
});
$popup.dialog({
autoOpen: false,
modal: true,
width: original_width,
height: original_height,
open: create_cropping,
buttons: actions
});
infrae.ui.ShowDialog($popup, {minWidth: 250,
maxFactor: 0.9,
maxWidth: original_width + 10,
maxHeight: original_height + 10});
});
};
$(document).on('loadwidget-smiform', '.form-fields-container', function(event) {
$(this).find('div.widget-crop').each(create_cropping_field);
event.stopPropagation();
});
})(infrae, jQuery); | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/widgets/static/cropping.js | cropping.js |
(function($,infrae){var create_combobox_field=function(){var $field=$(this),$select=$field.children("select"),$input=$field.children("input.combobox-input"),$opener=$field.children("a.combobox-opener"),selected=$select.children(":selected"),value=selected.text();$input.val(value).autocomplete({delay:0,minLength:0,source:function(request,response){var matcher=RegExp($.ui.autocomplete.escapeRegex(request.term),"i");response($select.children("option").map(function(){var $option=$(this),text=$option.text();return!request.term||matcher.test(text)?{label:text.replace(RegExp("(?![^&;]+;)(?!<[^<>]*)("+$.ui.autocomplete.escapeRegex(request.term)+")(?![^<>]*>)(?![^&;]+;)","gi"),"<strong>$1</strong>"),icon:$option.data("combobox-icon"),value:text,option:this}:void 0}))},select:function(event,ui){ui.item.option.selected=!0,value=ui.item.value},change:function(event,ui){if(!ui.item){var valid=!1,matcher=RegExp("^"+$.ui.autocomplete.escapeRegex($(this).val())+"$","i");if($select.children("option").each(function(){var $option=$(this);return $option.text().match(matcher)?(this.selected=valid=!0,!1):void 0}),!valid)return $(this).val(value),$select.val(value),$input.data("autocomplete").term=value,!1}}}),$input.data("autocomplete")._resizeMenu=function(){var $ul=this.menu.element;$ul.outerWidth(Math.max($ul.width("").outerWidth()+40,this.element.outerWidth()))},$input.data("autocomplete")._renderItem=function(ul,item){var $item=$("<li><a>"+item.label+"</a></li>");if(item.icon){var $icon=$('<ins class="icon" />');infrae.ui.icon($icon,item.icon),$item.prepend($icon)}return $item.data("item.autocomplete",item).appendTo(ul)},$input.autocomplete("widget").zIndex($input.zIndex()+1),$opener.click(function(){return $input.autocomplete("widget").is(":visible")?($input.autocomplete("close"),void 0):($opener.blur(),$input.autocomplete("search",""),$input.focus(),void 0)})};$(document).on("loadwidget-smiform",".form-fields-container",function(event){$(this).find(".field-combobox").each(create_combobox_field),event.stopPropagation()})})(jQuery,infrae); | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/widgets/static/combobox.min.js | combobox.min.js |
(function($) {
$.Jcrop = function(obj,opt)
{
// Initialization {{{
// Sanitize some options {{{
var obj = obj, opt = opt;
if (typeof(obj) !== 'object') obj = $(obj)[0];
if (typeof(opt) !== 'object') opt = { };
// Some on-the-fly fixes for MSIE...sigh
if (!('trackDocument' in opt))
{
opt.trackDocument = $.browser.msie ? false : true;
if ($.browser.msie && $.browser.version.split('.')[0] == '8')
opt.trackDocument = true;
}
if (!('keySupport' in opt))
opt.keySupport = $.browser.msie ? false : true;
// }}}
// Extend the default options {{{
var defaults = {
// Basic Settings
trackDocument: false,
baseClass: 'jcrop',
addClass: null,
// Styling Options
bgColor: 'black',
bgOpacity: .6,
borderOpacity: .4,
handleOpacity: .5,
handlePad: 5,
handleSize: 9,
handleOffset: 5,
edgeMargin: 14,
aspectRatio: 0,
keySupport: true,
cornerHandles: true,
sideHandles: true,
drawBorders: true,
dragEdges: true,
boxWidth: 0,
boxHeight: 0,
boundary: 8,
animationDelay: 20,
swingSpeed: 3,
allowSelect: true,
allowMove: true,
allowResize: true,
minSelect: [ 0, 0 ],
maxSize: [ 0, 0 ],
minSize: [ 0, 0 ],
// Callbacks / Event Handlers
onChange: function() { },
onSelect: function() { }
};
var options = defaults;
setOptions(opt);
// }}}
// Initialize some jQuery objects {{{
var $origimg = $(obj);
var $img = $origimg.clone().removeAttr('id').css({ position: 'absolute' });
$img.width($origimg.width());
$img.height($origimg.height());
$origimg.after($img).hide();
presize($img,options.boxWidth,options.boxHeight);
var boundx = $img.width(),
boundy = $img.height(),
$div = $('<div />')
.width(boundx).height(boundy)
.addClass(cssClass('holder'))
.css({
position: 'relative',
backgroundColor: options.bgColor
}).insertAfter($origimg).append($img);
;
if (options.addClass) $div.addClass(options.addClass);
//$img.wrap($div);
var $img2 = $('<img />')/*{{{*/
.attr('src',$img.attr('src'))
.css('position','absolute')
.width(boundx).height(boundy)
;/*}}}*/
var $img_holder = $('<div />')/*{{{*/
.width(pct(100)).height(pct(100))
.css({
zIndex: 310,
position: 'absolute',
overflow: 'hidden'
})
.append($img2)
;/*}}}*/
var $hdl_holder = $('<div />')/*{{{*/
.width(pct(100)).height(pct(100))
.css('zIndex',320);
/*}}}*/
var $sel = $('<div />')/*{{{*/
.css({
position: 'absolute',
zIndex: 300
})
.insertBefore($img)
.append($img_holder,$hdl_holder)
;/*}}}*/
var bound = options.boundary;
var $trk = newTracker().width(boundx+(bound*2)).height(boundy+(bound*2))
.css({ position: 'absolute', top: px(-bound), left: px(-bound), zIndex: 290 })
.mousedown(newSelection);
/* }}} */
// Set more variables {{{
var xlimit, ylimit, xmin, ymin;
var xscale, yscale, enabled = true;
var docOffset = getPos($img),
// Internal states
btndown, lastcurs, dimmed, animating,
shift_down;
// }}}
// }}}
// Internal Modules {{{
var Coords = function()/*{{{*/
{
var x1 = 0, y1 = 0, x2 = 0, y2 = 0, ox, oy;
function setPressed(pos)/*{{{*/
{
var pos = rebound(pos);
x2 = x1 = pos[0];
y2 = y1 = pos[1];
};
/*}}}*/
function setCurrent(pos)/*{{{*/
{
var pos = rebound(pos);
ox = pos[0] - x2;
oy = pos[1] - y2;
x2 = pos[0];
y2 = pos[1];
};
/*}}}*/
function getOffset()/*{{{*/
{
return [ ox, oy ];
};
/*}}}*/
function moveOffset(offset)/*{{{*/
{
var ox = offset[0], oy = offset[1];
if (0 > x1 + ox) ox -= ox + x1;
if (0 > y1 + oy) oy -= oy + y1;
if (boundy < y2 + oy) oy += boundy - (y2 + oy);
if (boundx < x2 + ox) ox += boundx - (x2 + ox);
x1 += ox;
x2 += ox;
y1 += oy;
y2 += oy;
};
/*}}}*/
function getCorner(ord)/*{{{*/
{
var c = getFixed();
switch(ord)
{
case 'ne': return [ c.x2, c.y ];
case 'nw': return [ c.x, c.y ];
case 'se': return [ c.x2, c.y2 ];
case 'sw': return [ c.x, c.y2 ];
}
};
/*}}}*/
function getFixed()/*{{{*/
{
if (!options.aspectRatio) return getRect();
// This function could use some optimization I think...
var aspect = options.aspectRatio,
min_x = options.minSize[0]/xscale,
min_y = options.minSize[1]/yscale,
max_x = options.maxSize[0]/xscale,
max_y = options.maxSize[1]/yscale,
rw = x2 - x1,
rh = y2 - y1,
rwa = Math.abs(rw),
rha = Math.abs(rh),
real_ratio = rwa / rha,
xx, yy
;
if (max_x == 0) { max_x = boundx * 10 }
if (max_y == 0) { max_y = boundy * 10 }
if (real_ratio < aspect)
{
yy = y2;
w = rha * aspect;
xx = rw < 0 ? x1 - w : w + x1;
if (xx < 0)
{
xx = 0;
h = Math.abs((xx - x1) / aspect);
yy = rh < 0 ? y1 - h: h + y1;
}
else if (xx > boundx)
{
xx = boundx;
h = Math.abs((xx - x1) / aspect);
yy = rh < 0 ? y1 - h : h + y1;
}
}
else
{
xx = x2;
h = rwa / aspect;
yy = rh < 0 ? y1 - h : y1 + h;
if (yy < 0)
{
yy = 0;
w = Math.abs((yy - y1) * aspect);
xx = rw < 0 ? x1 - w : w + x1;
}
else if (yy > boundy)
{
yy = boundy;
w = Math.abs(yy - y1) * aspect;
xx = rw < 0 ? x1 - w : w + x1;
}
}
// Magic %-)
if(xx > x1) { // right side
if(xx - x1 < min_x) {
xx = x1 + min_x;
} else if (xx - x1 > max_x) {
xx = x1 + max_x;
}
if(yy > y1) {
yy = y1 + (xx - x1)/aspect;
} else {
yy = y1 - (xx - x1)/aspect;
}
} else if (xx < x1) { // left side
if(x1 - xx < min_x) {
xx = x1 - min_x
} else if (x1 - xx > max_x) {
xx = x1 - max_x;
}
if(yy > y1) {
yy = y1 + (x1 - xx)/aspect;
} else {
yy = y1 - (x1 - xx)/aspect;
}
}
if(xx < 0) {
x1 -= xx;
xx = 0;
} else if (xx > boundx) {
x1 -= xx - boundx;
xx = boundx;
}
if(yy < 0) {
y1 -= yy;
yy = 0;
} else if (yy > boundy) {
y1 -= yy - boundy;
yy = boundy;
}
return last = makeObj(flipCoords(x1,y1,xx,yy));
};
/*}}}*/
function rebound(p)/*{{{*/
{
if (p[0] < 0) p[0] = 0;
if (p[1] < 0) p[1] = 0;
if (p[0] > boundx) p[0] = boundx;
if (p[1] > boundy) p[1] = boundy;
return [ p[0], p[1] ];
};
/*}}}*/
function flipCoords(x1,y1,x2,y2)/*{{{*/
{
var xa = x1, xb = x2, ya = y1, yb = y2;
if (x2 < x1)
{
xa = x2;
xb = x1;
}
if (y2 < y1)
{
ya = y2;
yb = y1;
}
return [ Math.round(xa), Math.round(ya), Math.round(xb), Math.round(yb) ];
};
/*}}}*/
function getRect()/*{{{*/
{
var xsize = x2 - x1;
var ysize = y2 - y1;
if (xlimit && (Math.abs(xsize) > xlimit))
x2 = (xsize > 0) ? (x1 + xlimit) : (x1 - xlimit);
if (ylimit && (Math.abs(ysize) > ylimit))
y2 = (ysize > 0) ? (y1 + ylimit) : (y1 - ylimit);
if (ymin && (Math.abs(ysize) < ymin))
y2 = (ysize > 0) ? (y1 + ymin) : (y1 - ymin);
if (xmin && (Math.abs(xsize) < xmin))
x2 = (xsize > 0) ? (x1 + xmin) : (x1 - xmin);
if (x1 < 0) { x2 -= x1; x1 -= x1; }
if (y1 < 0) { y2 -= y1; y1 -= y1; }
if (x2 < 0) { x1 -= x2; x2 -= x2; }
if (y2 < 0) { y1 -= y2; y2 -= y2; }
if (x2 > boundx) { var delta = x2 - boundx; x1 -= delta; x2 -= delta; }
if (y2 > boundy) { var delta = y2 - boundy; y1 -= delta; y2 -= delta; }
if (x1 > boundx) { var delta = x1 - boundy; y2 -= delta; y1 -= delta; }
if (y1 > boundy) { var delta = y1 - boundy; y2 -= delta; y1 -= delta; }
return makeObj(flipCoords(x1,y1,x2,y2));
};
/*}}}*/
function makeObj(a)/*{{{*/
{
return { x: a[0], y: a[1], x2: a[2], y2: a[3],
w: a[2] - a[0], h: a[3] - a[1] };
};
/*}}}*/
return {
flipCoords: flipCoords,
setPressed: setPressed,
setCurrent: setCurrent,
getOffset: getOffset,
moveOffset: moveOffset,
getCorner: getCorner,
getFixed: getFixed
};
}();
/*}}}*/
var Selection = function()/*{{{*/
{
var start, end, dragmode, awake, hdep = 370;
var borders = { };
var handle = { };
var seehandles = false;
var hhs = options.handleOffset;
/* Insert draggable elements {{{*/
// Insert border divs for outline
if (options.drawBorders) {
borders = {
top: insertBorder('hline')
.css('top',$.browser.msie?px(-1):px(0)),
bottom: insertBorder('hline'),
left: insertBorder('vline'),
right: insertBorder('vline')
};
}
// Insert handles on edges
if (options.dragEdges) {
handle.t = insertDragbar('n');
handle.b = insertDragbar('s');
handle.r = insertDragbar('e');
handle.l = insertDragbar('w');
}
// Insert side handles
options.sideHandles &&
createHandles(['n','s','e','w']);
// Insert corner handles
options.cornerHandles &&
createHandles(['sw','nw','ne','se']);
/*}}}*/
// Private Methods
function insertBorder(type)/*{{{*/
{
var jq = $('<div />')
.css({position: 'absolute', opacity: options.borderOpacity })
.addClass(cssClass(type));
$img_holder.append(jq);
return jq;
};
/*}}}*/
function dragDiv(ord,zi)/*{{{*/
{
var jq = $('<div />')
.mousedown(createDragger(ord))
.css({
cursor: ord+'-resize',
position: 'absolute',
zIndex: zi
})
;
$hdl_holder.append(jq);
return jq;
};
/*}}}*/
function insertHandle(ord)/*{{{*/
{
return dragDiv(ord,hdep++)
.css({ top: px(-hhs+1), left: px(-hhs+1), opacity: options.handleOpacity })
.addClass(cssClass('handle'));
};
/*}}}*/
function insertDragbar(ord)/*{{{*/
{
var s = options.handleSize,
o = hhs,
h = s, w = s,
t = o, l = o;
switch(ord)
{
case 'n': case 's': w = pct(100); break;
case 'e': case 'w': h = pct(100); break;
}
return dragDiv(ord,hdep++).width(w).height(h)
.css({ top: px(-t+1), left: px(-l+1)});
};
/*}}}*/
function createHandles(li)/*{{{*/
{
for(i in li) handle[li[i]] = insertHandle(li[i]);
};
/*}}}*/
function moveHandles(c)/*{{{*/
{
var midvert = Math.round((c.h / 2) - hhs),
midhoriz = Math.round((c.w / 2) - hhs),
north = west = -hhs+1,
east = c.w - hhs,
south = c.h - hhs,
x, y;
'e' in handle &&
handle.e.css({ top: px(midvert), left: px(east) }) &&
handle.w.css({ top: px(midvert) }) &&
handle.s.css({ top: px(south), left: px(midhoriz) }) &&
handle.n.css({ left: px(midhoriz) });
'ne' in handle &&
handle.ne.css({ left: px(east) }) &&
handle.se.css({ top: px(south), left: px(east) }) &&
handle.sw.css({ top: px(south) });
'b' in handle &&
handle.b.css({ top: px(south) }) &&
handle.r.css({ left: px(east) });
};
/*}}}*/
function moveto(x,y)/*{{{*/
{
$img2.css({ top: px(-y), left: px(-x) });
$sel.css({ top: px(y), left: px(x) });
};
/*}}}*/
function resize(w,h)/*{{{*/
{
$sel.width(w).height(h);
};
/*}}}*/
function refresh()/*{{{*/
{
var c = Coords.getFixed();
Coords.setPressed([c.x,c.y]);
Coords.setCurrent([c.x2,c.y2]);
updateVisible();
};
/*}}}*/
// Internal Methods
function updateVisible()/*{{{*/
{ if (awake) return update(); };
/*}}}*/
function update()/*{{{*/
{
var c = Coords.getFixed();
resize(c.w,c.h);
moveto(c.x,c.y);
options.drawBorders &&
borders['right'].css({ left: px(c.w-1) }) &&
borders['bottom'].css({ top: px(c.h-1) });
seehandles && moveHandles(c);
awake || show();
options.onChange(unscale(c));
};
/*}}}*/
function show()/*{{{*/
{
$sel.show();
$img.css('opacity',options.bgOpacity);
awake = true;
};
/*}}}*/
function release()/*{{{*/
{
disableHandles();
$sel.hide();
$img.css('opacity',1);
awake = false;
};
/*}}}*/
function showHandles()//{{{
{
if (seehandles)
{
moveHandles(Coords.getFixed());
$hdl_holder.show();
}
};
//}}}
function enableHandles()/*{{{*/
{
seehandles = true;
if (options.allowResize)
{
moveHandles(Coords.getFixed());
$hdl_holder.show();
return true;
}
};
/*}}}*/
function disableHandles()/*{{{*/
{
seehandles = false;
$hdl_holder.hide();
};
/*}}}*/
function animMode(v)/*{{{*/
{
(animating = v) ? disableHandles(): enableHandles();
};
/*}}}*/
function done()/*{{{*/
{
animMode(false);
refresh();
};
/*}}}*/
var $track = newTracker().mousedown(createDragger('move'))
.css({ cursor: 'move', position: 'absolute', zIndex: 360 })
$img_holder.append($track);
disableHandles();
return {
updateVisible: updateVisible,
update: update,
release: release,
refresh: refresh,
setCursor: function (cursor) { $track.css('cursor',cursor); },
enableHandles: enableHandles,
enableOnly: function() { seehandles = true; },
showHandles: showHandles,
disableHandles: disableHandles,
animMode: animMode,
done: done
};
}();
/*}}}*/
var Tracker = function()/*{{{*/
{
var onMove = function() { },
onDone = function() { },
trackDoc = options.trackDocument;
if (!trackDoc)
{
$trk
.mousemove(trackMove)
.mouseup(trackUp)
.mouseout(trackUp)
;
}
function toFront()/*{{{*/
{
$trk.css({zIndex:450});
if (trackDoc)
{
$(document)
.mousemove(trackMove)
.mouseup(trackUp)
;
}
}
/*}}}*/
function toBack()/*{{{*/
{
$trk.css({zIndex:290});
if (trackDoc)
{
$(document)
.unbind('mousemove',trackMove)
.unbind('mouseup',trackUp)
;
}
}
/*}}}*/
function trackMove(e)/*{{{*/
{
onMove(mouseAbs(e));
};
/*}}}*/
function trackUp(e)/*{{{*/
{
e.preventDefault();
e.stopPropagation();
if (btndown)
{
btndown = false;
onDone(mouseAbs(e));
options.onSelect(unscale(Coords.getFixed()));
toBack();
onMove = function() { };
onDone = function() { };
}
return false;
};
/*}}}*/
function activateHandlers(move,done)/* {{{ */
{
btndown = true;
onMove = move;
onDone = done;
toFront();
return false;
};
/* }}} */
function setCursor(t) { $trk.css('cursor',t); };
$img.before($trk);
return {
activateHandlers: activateHandlers,
setCursor: setCursor
};
}();
/*}}}*/
var KeyManager = function()/*{{{*/
{
var $keymgr = $('<input type="radio" />')
.css({ position: 'absolute', left: '-30px' })
.keypress(parseKey)
.blur(onBlur),
$keywrap = $('<div />')
.css({
position: 'absolute',
overflow: 'hidden'
})
.append($keymgr)
;
function watchKeys()/*{{{*/
{
if (options.keySupport)
{
$keymgr.show();
$keymgr.focus();
}
};
/*}}}*/
function onBlur(e)/*{{{*/
{
$keymgr.hide();
};
/*}}}*/
function doNudge(e,x,y)/*{{{*/
{
if (options.allowMove) {
Coords.moveOffset([x,y]);
Selection.updateVisible();
};
e.preventDefault();
e.stopPropagation();
};
/*}}}*/
function parseKey(e)/*{{{*/
{
if (e.ctrlKey) return true;
shift_down = e.shiftKey ? true : false;
var nudge = shift_down ? 10 : 1;
switch(e.keyCode)
{
case 37: doNudge(e,-nudge,0); break;
case 39: doNudge(e,nudge,0); break;
case 38: doNudge(e,0,-nudge); break;
case 40: doNudge(e,0,nudge); break;
case 27: Selection.release(); break;
case 9: return true;
}
return nothing(e);
};
/*}}}*/
if (options.keySupport) $keywrap.insertBefore($img);
return {
watchKeys: watchKeys
};
}();
/*}}}*/
// }}}
// Internal Methods {{{
function px(n) { return '' + parseInt(n) + 'px'; };
function pct(n) { return '' + parseInt(n) + '%'; };
function cssClass(cl) { return options.baseClass + '-' + cl; };
function getPos(obj)/*{{{*/
{
// Updated in v0.9.4 to use built-in dimensions plugin
var pos = $(obj).offset();
return [ pos.left, pos.top ];
};
/*}}}*/
function mouseAbs(e)/*{{{*/
{
return [ (e.pageX - docOffset[0]), (e.pageY - docOffset[1]) ];
};
/*}}}*/
function myCursor(type)/*{{{*/
{
if (type != lastcurs)
{
Tracker.setCursor(type);
//Handles.xsetCursor(type);
lastcurs = type;
}
};
/*}}}*/
function startDragMode(mode,pos)/*{{{*/
{
docOffset = getPos($img);
Tracker.setCursor(mode=='move'?mode:mode+'-resize');
if (mode == 'move')
return Tracker.activateHandlers(createMover(pos), doneSelect);
var fc = Coords.getFixed();
var opp = oppLockCorner(mode);
var opc = Coords.getCorner(oppLockCorner(opp));
Coords.setPressed(Coords.getCorner(opp));
Coords.setCurrent(opc);
Tracker.activateHandlers(dragmodeHandler(mode,fc),doneSelect);
};
/*}}}*/
function dragmodeHandler(mode,f)/*{{{*/
{
return function(pos) {
if (!options.aspectRatio) switch(mode)
{
case 'e': pos[1] = f.y2; break;
case 'w': pos[1] = f.y2; break;
case 'n': pos[0] = f.x2; break;
case 's': pos[0] = f.x2; break;
}
else switch(mode)
{
case 'e': pos[1] = f.y+1; break;
case 'w': pos[1] = f.y+1; break;
case 'n': pos[0] = f.x+1; break;
case 's': pos[0] = f.x+1; break;
}
Coords.setCurrent(pos);
Selection.update();
};
};
/*}}}*/
function createMover(pos)/*{{{*/
{
var lloc = pos;
KeyManager.watchKeys();
return function(pos)
{
Coords.moveOffset([pos[0] - lloc[0], pos[1] - lloc[1]]);
lloc = pos;
Selection.update();
};
};
/*}}}*/
function oppLockCorner(ord)/*{{{*/
{
switch(ord)
{
case 'n': return 'sw';
case 's': return 'nw';
case 'e': return 'nw';
case 'w': return 'ne';
case 'ne': return 'sw';
case 'nw': return 'se';
case 'se': return 'nw';
case 'sw': return 'ne';
};
};
/*}}}*/
function createDragger(ord)/*{{{*/
{
return function(e) {
if (options.disabled) return false;
if ((ord == 'move') && !options.allowMove) return false;
btndown = true;
startDragMode(ord,mouseAbs(e));
e.stopPropagation();
e.preventDefault();
return false;
};
};
/*}}}*/
function presize($obj,w,h)/*{{{*/
{
var nw = $obj.width(), nh = $obj.height();
if ((nw > w) && w > 0)
{
nw = w;
nh = (w/$obj.width()) * $obj.height();
}
if ((nh > h) && h > 0)
{
nh = h;
nw = (h/$obj.height()) * $obj.width();
}
xscale = $obj.width() / nw;
yscale = $obj.height() / nh;
$obj.width(nw).height(nh);
};
/*}}}*/
function unscale(c)/*{{{*/
{
return {
x: parseInt(c.x * xscale), y: parseInt(c.y * yscale),
x2: parseInt(c.x2 * xscale), y2: parseInt(c.y2 * yscale),
w: parseInt(c.w * xscale), h: parseInt(c.h * yscale)
};
};
/*}}}*/
function doneSelect(pos)/*{{{*/
{
var c = Coords.getFixed();
if (c.w > options.minSelect[0] && c.h > options.minSelect[1])
{
Selection.enableHandles();
Selection.done();
}
else
{
Selection.release();
}
Tracker.setCursor( options.allowSelect?'crosshair':'default' );
};
/*}}}*/
function newSelection(e)/*{{{*/
{
if (options.disabled) return false;
if (!options.allowSelect) return false;
btndown = true;
docOffset = getPos($img);
Selection.disableHandles();
myCursor('crosshair');
var pos = mouseAbs(e);
Coords.setPressed(pos);
Tracker.activateHandlers(selectDrag,doneSelect);
KeyManager.watchKeys();
Selection.update();
e.stopPropagation();
e.preventDefault();
return false;
};
/*}}}*/
function selectDrag(pos)/*{{{*/
{
Coords.setCurrent(pos);
Selection.update();
};
/*}}}*/
function newTracker()
{
var trk = $('<div></div>').addClass(cssClass('tracker'));
$.browser.msie && trk.css({ opacity: 0, backgroundColor: 'white' });
return trk;
};
// }}}
// API methods {{{
function animateTo(a)/*{{{*/
{
var x1 = a[0] / xscale,
y1 = a[1] / yscale,
x2 = a[2] / xscale,
y2 = a[3] / yscale;
if (animating) return;
var animto = Coords.flipCoords(x1,y1,x2,y2);
var c = Coords.getFixed();
var animat = initcr = [ c.x, c.y, c.x2, c.y2 ];
var interv = options.animationDelay;
var x = animat[0];
var y = animat[1];
var x2 = animat[2];
var y2 = animat[3];
var ix1 = animto[0] - initcr[0];
var iy1 = animto[1] - initcr[1];
var ix2 = animto[2] - initcr[2];
var iy2 = animto[3] - initcr[3];
var pcent = 0;
var velocity = options.swingSpeed;
Selection.animMode(true);
var animator = function()
{
return function()
{
pcent += (100 - pcent) / velocity;
animat[0] = x + ((pcent / 100) * ix1);
animat[1] = y + ((pcent / 100) * iy1);
animat[2] = x2 + ((pcent / 100) * ix2);
animat[3] = y2 + ((pcent / 100) * iy2);
if (pcent < 100) animateStart();
else Selection.done();
if (pcent >= 99.8) pcent = 100;
setSelectRaw(animat);
};
}();
function animateStart()
{ window.setTimeout(animator,interv); };
animateStart();
};
/*}}}*/
function setSelect(rect)//{{{
{
setSelectRaw([rect[0]/xscale,rect[1]/yscale,rect[2]/xscale,rect[3]/yscale]);
};
//}}}
function setSelectRaw(l) /*{{{*/
{
Coords.setPressed([l[0],l[1]]);
Coords.setCurrent([l[2],l[3]]);
Selection.update();
};
/*}}}*/
function setOptions(opt)/*{{{*/
{
if (typeof(opt) != 'object') opt = { };
options = $.extend(options,opt);
if (typeof(options.onChange)!=='function')
options.onChange = function() { };
if (typeof(options.onSelect)!=='function')
options.onSelect = function() { };
};
/*}}}*/
function tellSelect()/*{{{*/
{
return unscale(Coords.getFixed());
};
/*}}}*/
function tellScaled()/*{{{*/
{
return Coords.getFixed();
};
/*}}}*/
function setOptionsNew(opt)/*{{{*/
{
setOptions(opt);
interfaceUpdate();
};
/*}}}*/
function disableCrop()//{{{
{
options.disabled = true;
Selection.disableHandles();
Selection.setCursor('default');
Tracker.setCursor('default');
};
//}}}
function enableCrop()//{{{
{
options.disabled = false;
interfaceUpdate();
};
//}}}
function cancelCrop()//{{{
{
Selection.done();
Tracker.activateHandlers(null,null);
};
//}}}
function destroy()//{{{
{
$div.remove();
$origimg.show();
};
//}}}
function interfaceUpdate(alt)//{{{
// This method tweaks the interface based on options object.
// Called when options are changed and at end of initialization.
{
options.allowResize ?
alt?Selection.enableOnly():Selection.enableHandles():
Selection.disableHandles();
Tracker.setCursor( options.allowSelect? 'crosshair': 'default' );
Selection.setCursor( options.allowMove? 'move': 'default' );
$div.css('backgroundColor',options.bgColor);
if ('setSelect' in options) {
setSelect(opt.setSelect);
Selection.done();
delete(options.setSelect);
}
if ('trueSize' in options) {
xscale = options.trueSize[0] / boundx;
yscale = options.trueSize[1] / boundy;
}
xlimit = options.maxSize[0] || 0;
ylimit = options.maxSize[1] || 0;
xmin = options.minSize[0] || 0;
ymin = options.minSize[1] || 0;
if ('outerImage' in options)
{
$img.attr('src',options.outerImage);
delete(options.outerImage);
}
Selection.refresh();
};
//}}}
// }}}
$hdl_holder.hide();
interfaceUpdate(true);
var api = {
animateTo: animateTo,
setSelect: setSelect,
setOptions: setOptionsNew,
tellSelect: tellSelect,
tellScaled: tellScaled,
disable: disableCrop,
enable: enableCrop,
cancel: cancelCrop,
focus: KeyManager.watchKeys,
getBounds: function() { return [ boundx * xscale, boundy * yscale ]; },
getWidgetSize: function() { return [ boundx, boundy ]; },
release: Selection.release,
destroy: destroy
};
$origimg.data('Jcrop',api);
return api;
};
$.fn.Jcrop = function(options)/*{{{*/
{
function attachWhenDone(from)/*{{{*/
{
var loadsrc = options.useImg || from.src;
var img = new Image();
img.onload = function() { $.Jcrop(from,options); };
img.src = loadsrc;
};
/*}}}*/
if (typeof(options) !== 'object') options = { };
// Iterate over each object, attach Jcrop
this.each(function()
{
// If we've already attached to this object
if ($(this).data('Jcrop'))
{
// The API can be requested this way (undocumented)
if (options == 'api') return $(this).data('Jcrop');
// Otherwise, we just reset the options...
else $(this).data('Jcrop').setOptions(options);
}
// If we haven't been attached, preload and attach
else attachWhenDone(this);
});
// Return "this" so we're chainable a la jQuery plugin-style!
return this;
};
/*}}}*/
})(jQuery); | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/widgets/static/jquery.Jcrop.js | jquery.Jcrop.js |
(function($){$.widget("ui.multiselect",{options:{sortable:!0,searchable:!0,doubleClickable:!0,animated:"fast",show:"slideDown",hide:"slideUp",dividerLocation:.6,nodeComparator:function(node1,node2){var text1=node1.text(),text2=node2.text();return text1==text2?0:text2>text1?-1:1}},_create:function(){var that=this;this.element.hide(),this.id=this.element.attr("id"),this.count=0,this.container=$('<div class="ui-multiselect ui-helper-clearfix ui-widget"></div>'),this.selectedContainer=$('<div class="ui-multiselect-selected ui-multiselect-container"></div>').appendTo(this.container),this.availableContainer=$('<div class="ui-multiselect-available ui-multiselect-container"></div>').appendTo(this.container),this.selectedActions=$('<div class="ui-multiselect-actions ui-widget-header ui-helper-clearfix"><span class="count">0 '+$.ui.multiselect.locale.itemsCount+'</span><a href="#" class="remove-all">'+$.ui.multiselect.locale.removeAll+"</a></div>").appendTo(this.selectedContainer),this.availableActions=$('<div class="ui-multiselect-actions ui-widget-header ui-helper-clearfix"><input type="search" class="search empty ui-widget-content ui-corner-all"/><a href="#" class="add-all">'+$.ui.multiselect.locale.addAll+"</a></div>").appendTo(this.availableContainer),this.selectedList=$('<ul class="ui-multiselect-selected connected-list"><li class="ui-helper-hidden-accessible"></li></ul>').bind("selectstart",function(){return!1}).appendTo(this.selectedContainer),this.availableList=$('<ul class="ui-multiselect-available connected-list"><li class="ui-helper-hidden-accessible"></li></ul>').bind("selectstart",function(){return!1}).appendTo(this.availableContainer),this.options.animated||(this.options.show="show",this.options.hide="hide"),this._populateLists(this.element.find("option")),this.options.sortable&&this.selectedList.sortable({placeholder:"ui-state-highlight",axis:"y",update:function(){that.selectedList.find("li").each(function(){$(this).data("optionLink")&&$(this).data("optionLink").remove().appendTo(that.element)})},receive:function(event,ui){ui.item.data("optionLink").attr("selected",!0),that.count+=1,that._updateCount(),that.selectedList.children(".ui-draggable").each(function(){$(this).removeClass("ui-draggable"),$(this).data("optionLink",ui.item.data("optionLink")),$(this).data("idx",ui.item.data("idx")),that._applyItemState($(this),!0)}),setTimeout(function(){ui.item.remove()},1)}}),this.options.searchable?this._registerSearchEvents(this.availableContainer.find("input.search")):$(".search").hide(),this.container.find(".remove-all").click(function(){return that._populateLists(that.element.find("option").removeAttr("selected")),!1}),this.container.find(".add-all").click(function(){var options=that.element.find("option").not(":selected");return that.availableList.children("li:hidden").length>1?that.availableList.children("li").each(function(i){$(this).is(":visible")&&$(options[i-1]).attr("selected","selected")}):options.attr("selected","selected"),that._populateLists(that.element.find("option")),!1}),this.container.insertAfter(this.element)},destroy:function(){this.element.show(),this.container.remove(),$.Widget.prototype.destroy.apply(this,arguments)},_populateLists:function(options){this.selectedList.children(".ui-element").remove(),this.availableList.children(".ui-element").remove(),this.count=0;var that=this;$(options.map(function(i){var item=that._getOptionNode(this).appendTo(this.selected?that.selectedList:that.availableList).show();return this.selected&&(that.count+=1),that._applyItemState(item,this.selected),item.data("idx",i),item[0]})),this._updateCount(),that._filter.apply(this.availableContainer.find("input.search"),[that.availableList])},_updateCount:function(){this.selectedContainer.find("span.count").text(this.count+" "+$.ui.multiselect.locale.itemsCount)},_getOptionNode:function(option){option=$(option);var node=$('<li class="ui-state-default ui-element" title="'+option.text()+'"><span class="ui-icon"/>'+option.text()+'<a href="#" class="ui-multiselect-action"><span class="ui-corner-all ui-icon"/></a></li>').hide();return node.data("optionLink",option),node},_cloneWithData:function(clonee){var clone=clonee.clone(!1,!1);return clone.data("optionLink",clonee.data("optionLink")),clone.data("idx",clonee.data("idx")),clone},_setSelected:function(item,selected){if(item.data("optionLink").attr("selected",selected),selected){var selectedItem=this._cloneWithData(item);return item[this.options.hide](this.options.animated,function(){$(this).remove()}),selectedItem.appendTo(this.selectedList).hide()[this.options.show](this.options.animated),this._applyItemState(selectedItem,!0),selectedItem}var items=this.availableList.find("li"),comparator=this.options.nodeComparator,succ=null,i=item.data("idx"),direction=comparator(item,$(items[i]));if(direction){for(;i>=0&&items.length>i;)if(direction>0?i++:i--,direction!=comparator(item,$(items[i]))){succ=items[direction>0?i:i+1];break}}else succ=items[i];var availableItem=this._cloneWithData(item);return succ?availableItem.insertBefore($(succ)):availableItem.appendTo(this.availableList),item[this.options.hide](this.options.animated,function(){$(this).remove()}),availableItem.hide()[this.options.show](this.options.animated),this._applyItemState(availableItem,!1),availableItem},_applyItemState:function(item,selected){selected?(this.options.sortable?item.children("span").addClass("ui-icon-arrowthick-2-n-s").removeClass("ui-helper-hidden").addClass("ui-icon"):item.children("span").removeClass("ui-icon-arrowthick-2-n-s").addClass("ui-helper-hidden").removeClass("ui-icon"),item.find("a.ui-multiselect-action span").addClass("ui-icon-minus").removeClass("ui-icon-plus"),this._registerRemoveEvents(item.find("a.ui-multiselect-action"))):(item.children("span").removeClass("ui-icon-arrowthick-2-n-s").addClass("ui-helper-hidden").removeClass("ui-icon"),item.find("a.ui-multiselect-action span").addClass("ui-icon-plus").removeClass("ui-icon-minus"),this._registerAddEvents(item.find("a.ui-multiselect-action"))),this._registerHoverEvents(item)},_filter:function(list){var input=$(this),rows=list.children("li"),cache=rows.map(function(){return $(this).text().toLowerCase()}),term=$.trim(input.val().toLowerCase()),scores=[];term?(rows.hide(),cache.each(function(i){this.indexOf(term)>-1&&scores.push(i)}),$.each(scores,function(){$(rows[this]).show()})):rows.show()},_registerHoverEvents:function(elements){elements.removeClass("ui-state-hover"),elements.mouseover(function(){$(this).addClass("ui-state-hover")}),elements.mouseout(function(){$(this).removeClass("ui-state-hover")})},_registerAddEvents:function(elements){var that=this;elements.click(function(){return that._setSelected($(this).parent(),!0),that.count+=1,that._updateCount(),!1}),this.options.sortable&&elements.each(function(){$(this).parent().draggable({connectToSortable:that.selectedList,helper:function(){var selectedItem=that._cloneWithData($(this)).width($(this).width()-50);return selectedItem.width($(this).width()),selectedItem},appendTo:that.container,containment:that.container,revert:"invalid"})})},_registerRemoveEvents:function(elements){var that=this;elements.click(function(){return that._setSelected($(this).parent(),!1),that.count-=1,that._updateCount(),!1})},_registerSearchEvents:function(input){var that=this;input.focus(function(){$(this).addClass("ui-state-active")}).blur(function(){$(this).removeClass("ui-state-active")}).keypress(function(e){return 13==e.keyCode?!1:void 0}).keyup(function(){that._filter.apply(this,[that.availableList])}).bind("search",function(){that._filter.apply(this,[that.availableList])})}}),$.extend($.ui.multiselect,{locale:{addAll:"Add all",removeAll:"Remove all",itemsCount:"items selected"}})})(jQuery); | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/widgets/static/jquery.multiselect.min.js | jquery.multiselect.min.js |
(function(infrae,$){var create_cropping_field=function(){var $field=$(this),$input=$field.find("input.field-cropcoordinates"),$opener=$field.find("a.widget-crop-popup-button"),$template=$field.find("div.widget-crop-popup").detach(),required=$input.hasClass("field-required");infrae.ui.selection.disable($template);var preload=new Image;preload.src=$template.data("image-url"),$opener.bind("click",function(){var $popup=$template.clone(),$img=$popup.find("img.widget-crop-image"),image_width=preload.width,image_height=preload.height,original_width=Math.max(40+image_width,250),original_height=145+image_height,ratio=0,$proportional=$popup.find("input.crop-proportional"),crop=void 0;$input.val()&&(crop=$input.val().replace(/^\s*(\d+)x(\d+)-(\d+)x(\d+)\s*$/,"$1,$2,$3,$4").split(","));var need_refresh=!1,jCrop=void 0,default_cropping_options={aspectRatio:ratio,onSelect:function(value){crop=[value.x,value.y,value.x2,value.y2]}},create_cropping=function(options){options=$.extend({},default_cropping_options,options),void 0!==jCrop&&jCrop.destroy(),void 0!==crop&&(options.setSelect=crop),jCrop=$.Jcrop($img,options)},actions={Cancel:function(){$popup.dialog("close")},Clear:function(){$input.val(""),$popup.dialog("close")},Ok:function(){void 0!==crop&&($input.val(crop[0]+"x"+crop[1]+"-"+crop[2]+"x"+crop[3]),$popup.dialog("close"))}};required&&delete actions.Clear,$proportional.change(function(){null!==jCrop&&(ratio=this.checked?image_width/image_height:0,jCrop.setOptions({aspectRatio:ratio}))}),$popup.bind("dialogclose",function(){$popup.remove()}),$popup.bind("infrae-ui-dialog-resized",function(event,popup_size){var candidate_width=popup_size.width-40,candidate_height=popup_size.height-145;if(image_width>candidate_width||image_height>candidate_height){var ratio=Math.min(candidate_width/image_width,candidate_height/image_height);create_cropping({boxWidth:ratio*image_width,boxHeight:ratio*image_height}),need_refresh=!0}else need_refresh&&(create_cropping(),need_refresh=!1)}),$popup.dialog({autoOpen:!1,modal:!0,width:original_width,height:original_height,open:create_cropping,buttons:actions}),infrae.ui.ShowDialog($popup,{minWidth:250,maxFactor:.9,maxWidth:original_width+10,maxHeight:original_height+10})})};$(document).on("loadwidget-smiform",".form-fields-container",function(event){$(this).find("div.widget-crop").each(create_cropping_field),event.stopPropagation()})})(infrae,jQuery); | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/widgets/static/cropping.min.js | cropping.min.js |
(function($, jsontemplate) {
var IDENTIFIER_KEY = 'X-Progress-ID',
POLL_NETWORK_RETRIES = 5,
POLL_NETWORK_DELAY = 500,
POLL_MISSING_RETRIES = 20,
DONT_NEED_POPUP = (function () {
// Test if we need a Javascript POPUP to display the file input or not.
var $test = $('<div style="display:none;"><form id="testform1">' +
'<input type="file" form="testform2" /></form><form id="testform2">' +
'</form></div>'),
supported = false;
$('body').append($test);
supported = ($test.find('#testform1')[0].length === 0 &&
$test.find('#testform2')[0].length === 1);
$test.remove();
return supported;
})();
/**
* Status checker report the status of the upload to the uploader.
*/
var PollStatusChecker = function(url, identifier, result) {
var poll_retries = POLL_NETWORK_RETRIES,
poll_timeout = null,
missing_retries = POLL_MISSING_RETRIES,
deferred = $.Deferred(),
poll = function() {
// Poll status from the server.
$.ajax({
type: 'GET',
dataType: 'jsonp',
url: url + '/status?' + IDENTIFIER_KEY + '=' + identifier
}).then(function(info){
var error = null;
result.notify(info);
if (info['state'] == 'starting') {
missing_retries -= 1;
if (!missing_retries) {
error = info['error'] || 'Upload does not start';
deferred.reject({message: 'Upload failed ('+ error + ').'});
};
};
if (info['state'] == 'done'|| info['state'] == 'error') {
if (info['state'] == 'done') {
deferred.resolve(info);
} else {
error = info['error'] || 'Unknow error';
deferred.reject({message: 'Upload failed ('+ error + ').'});
};
} else if (result.state() == "pending" && missing_retries) {
// Unless the file is completely uploaded or
// cancel request status again.
poll_retries = POLL_NETWORK_RETRIES;
poll_timeout = setTimeout(poll, POLL_NETWORK_DELAY);
};
}, function() {
if (result.state() == "pending") {
if (poll_retries) {
poll_retries -= 1;
poll_timeout = setTimeout(poll, POLL_NETWORK_DELAY);
} else {
deferred.reject({message: 'Upload failed (Cannot check the status of the upload).'});
};
}
});
};
return {
promise: deferred.promise,
start: function() {
poll_timeout = setTimeout(poll, POLL_NETWORK_DELAY);
},
always: function() {
if (poll_timeout !== null) {
clearTimeout(poll_timeout);
poll_timeout = null;
};
}
};
};
var IFrameStatusChecker = function($iframe, identifier, result) {
// Check the status of the upload with the iframe. This never works.
var iframe = $iframe.get(0),
iframe_window = iframe.contentWindow,
iframe_document = iframe_window.document,
deferred = $.Deferred();
var fail = function() {
setTimeout(function() {
deferred.reject({message: 'Upload failed (File too big or server error).'});
}, POLL_NETWORK_DELAY);
};
var load = function() {
var $body = $(iframe_document.body);
if ($body.data('upload-identifier') == identifier) {
deferred.resolve($body.data('upload-info'));
} else {
fail();
};
};
if (iframe_window.addEventListener) {
iframe_window.addEventListener("load", load, false);
iframe_window.addEventListener("error", fail, false);
} else {
iframe_window.attachEvent("onload", load);
iframe_window.attachEvent("onerror", fail);
};
return {
promise: deferred.promise
};
};
/**
* UI compoments.
*/
var UploadStatusMessage = function($display) {
// Manage the status message of the upload widget.
var $empty = $display.children('.upload-display-empty'),
$uploading = $display.children('.upload-display-uploading'),
$done = $display.children('.upload-display-complete');
var empty = $empty.children('i').text(),
uploading = jsontemplate.Template($uploading.children('i').text(), {}),
done = jsontemplate.Template($done.children('i').text(), {}),
state = 'empty',
defaults = {'filename': '', 'content-type': 'n/a'},
original = $display.data('upload-status');
var api = {
start: function(data) {
if (state != 'starting') {
$uploading.children('i').text(uploading.expand($.extend({}, defaults, data)));
$empty.hide();
$done.hide();
$uploading.show();
state = 'starting';
}
},
progress: function(data) {
if (state != 'uploading' && data.state == 'uploading') {
// Refresh information on the first notification of progress.
$uploading.children('i').text(uploading.expand($.extend({}, defaults, data)));
state = 'uploading';
};
},
done: function(data) {
if (state != 'done') {
$done.children('i').text(done.expand($.extend({}, defaults, data)));
$empty.hide();
$uploading.hide();
$done.show();
state = 'done';
};
},
fail: function(data) {
if (state != 'empty' || data.message) {
$empty.children('i').text(data.message || empty);
if (state != 'empty') {
$uploading.hide();
$done.hide();
$empty.show();
state = 'empty';
};
};
}
};
if (original) {
api.done(original);
};
return api;
};
var UploadProgress = function($progress) {
// Manage the progress bar of the upload widget.
var progress = 0;
return {
start: function() {
$progress.progressbar({value: 0}).show();
},
progress: function(data) {
var updated = 0;
if (data['state'] == 'uploading') {
updated = data['received'] * 100 / data['size'];
};
if (updated != progress) {
$progress.progressbar({value: updated});
progress = updated;
};
},
always: function(data) {
$progress.hide();
progress = 0;
}
};
};
var UploadUI = function($field, set_objection, get_upload) {
// Manage the controls of the upload widget (clear, cancel button).
var $input = $field.children('.upload-input'),
$cancel = $field.children('.upload-cancel'),
$clear = $field.children('.upload-clear');
var upload = null,
objection = null,
progress = UploadProgress($field.children('.upload-progress')),
status = UploadStatusMessage($field.children('.upload-display')),
api = {
get: function(create) {
if (upload == null && create) {
upload = get_upload();
upload.register(status);
upload.register(progress);
upload.register(ui);
}
return upload;
}
},
ui = {
start: function() {
if (set_objection !== undefined) {
objection = $.Deferred();
set_objection(function () {
if (objection.state() == 'pending') {
var $dialog = $('<div title="Uploading file"><p>Please wait until the upload is finished ...</p><p class="progress"></p></div>'),
$progress = $dialog.find('p.progress'),
progress = 0;
$dialog.dialog({
modal: true,
closeOnEscape: false,
resizable: false,
draggable: false,
beforeClose: function() {
return false;
}});
$progress.progressbar({value: 0});
api.get().register({
progress: function(data) {
var updated = 0;
if (data['state'] == 'uploading') {
updated = data['received'] * 100 / data['size'];
};
if (updated != progress) {
$progress.progressbar({value: updated});
progress = updated;
};
}
});
return objection.always(function() {
$dialog.dialog('close').remove();
objection = null;
});
};
return null;
});
};
$cancel.show();
},
done: function(data) {
$input.attr('value', $field.data('upload-identifier'));
},
always: function(data) {
if (objection !== null) {
objection.resolve();
};
$cancel.hide();
upload = null;
}
};
$cancel.on('click', function() {
var upload = api.get();
if (upload !== null) {
upload.cancel();
};
});
$clear.on('click', function() {
var upload = api.get(true);
upload.cancel();
$input.attr('value', '');
});
return api;
};
/**
* Implementations for the uploading (with and without popup).
*/
var UploadForm = function($field, identifier, url) {
// Upload a file input using the given identifier at the given URL.
// It will trigger callbacks uring various steps of the progress.
var $upload = $('<div style="display:none">' +
'<iframe width="0" height="0" style="display:none"' +
'src="about:blank" class="upload-iframe" name="upload-' +
identifier + '-iframe"></iframe>' +
'<form class="upload-form" enctype="multipart/form-data"' +
'method="POST" action="' + url + '?' + IDENTIFIER_KEY + '=' + identifier +
'" target="upload-' + identifier +
'-iframe" id="upload-' + identifier + '-form">' +
'<input type="reset" class="upload-reset" /></form></div>'),
result = $.Deferred().fail(function() {
$upload.find('.upload-reset').click();
$upload.find('.upload-iframe').attr('src', 'javascript:false;');
}).always(function() {
$upload.remove();
$field.removeAttr('form');
}),
start = $.Deferred(),
api = {
start: function() {
$.ajax({
type: 'GET',
dataType: 'jsonp',
url: url + '?clear&' + IDENTIFIER_KEY + '=' + identifier}).then(function(info) {
if (info['success']) {
$('body').append($upload);
$field.attr('form', 'upload-' + identifier + '-form');
start.done(function() {
api.register(IFrameStatusChecker($upload.find('iframe'), identifier, result));
api.register(PollStatusChecker(url, identifier, result));
$upload.find('form').submit();
}).resolve({state: 'starting', received: 0, size: 0});
} else {
var error = info['error'] || 'Unknow error';
result.reject({message: 'Upload failed ('+ error + ').'});
};
}, function() {
result.reject({message: 'Upload failed.'});
});
},
cancel: function() {
result.reject({});
},
register: function(plugin) {
if (plugin.start !== undefined) {
start.done(plugin.start);
};
if (plugin.promise !== undefined) {
plugin.promise().then(function(data) {
result.resolve(data);
}, function(data) {
result.reject(data);
});
};
for (var event in {progress: 1, done: 1, fail: 1, always: 1}) {
if (plugin[event] !== undefined) {
result[event](plugin[event]);
};
};
return api;
}
};
return api;
};
var UploadPopup = function(identifier, url) {
// Upload a file input using the given identifier at the given URL.
// It will trigger callbacks uring various steps of the progress.
var $popup = $('<div title="Upload a file">' +
'<form class="upload-form" enctype="multipart/form-data"' +
'method="POST" action="' + url + '?' + IDENTIFIER_KEY+ '=' + identifier +
'" target="upload-' + identifier +
'-iframe" id="upload-' + identifier + '-form">' +
'<input type="file" name="file-we-are-uploading" class="upload-file" /></form>'+
'<iframe width="0" height="0" style="display:none"' +
'src="about:blank" class="upload-iframe" name="upload-' +
identifier + '-iframe"></iframe></div>'),
result = $.Deferred().fail(function() {
$popup.find('.upload-iframe').attr('src', 'javascript:false;');
}).always(function() {
$popup.remove();
}),
start = $.Deferred(),
api = {
start: function() {
var send = function() {
$.ajax({
type: 'GET',
dataType: 'jsonp',
url: url + '?clear&' + IDENTIFIER_KEY + '=' + identifier}).then(function(info) {
if (info['success']) {
start.done(function() {
$popup.dialog('close');
api.register(IFrameStatusChecker($popup.find('iframe'), identifier, result));
api.register(PollStatusChecker(url, identifier, result));
$popup.find('form').submit();
}).resolve({state: 'starting', received: 0, size: 0});
} else {
var error = info['error'] || 'Unknow error';
result.reject({message: 'Upload failed ('+ error + ').'});
};
}, function() {
result.reject({message: 'Upload failed.'});
});
};
$popup.find('.upload-file').on('change', function() {
send();
});
$popup.dialog({
buttons: {
Send: function() {
send();
}
}
});
},
cancel: function() {
result.reject({});
},
register: function(plugin) {
if (plugin.start !== undefined) {
start.done(plugin.start);
};
if (plugin.promise !== undefined) {
plugin.promise().then(function(data) {
result.resolve(data);
}, function(data) {
result.reject(data);
});
};
for (var event in {progress: 1, done: 1, fail: 1, always: 1}) {
if (plugin[event] !== undefined) {
result[event](plugin[event]);
};
};
return api;
}
};
return api;
};
var UploadField = DONT_NEED_POPUP ?
function ($field, set_objection) {
var $trigger = $field.children('.upload-trigger'),
$file = $field.find('input.upload-file-input'),
ui = UploadUI($field, set_objection, function() {
return UploadForm($file, $field.data('upload-identifier'), $field.data('upload-url')).register({
start: function() {
$file.hide();
},
always: function() {
$file.show();
}
});
});
$trigger.remove();
$file.on('change', function() {
ui.get(true).start();
});
} : function($field, set_objection) {
var $trigger = $field.children('.upload-trigger'),
$file = $field.find('input.upload-file-input'),
ui = UploadUI($field, set_objection, function() {
return UploadPopup($field.data('upload-identifier'), $field.data('upload-url')).register({
start: function() {
$trigger.hide();
},
always: function() {
$trigger.show();
}
});
});
$file.detach();
$trigger.show();
$trigger.on('click', function(){
ui.get(true).start();
});
};
$(document).on('loadwidget-smiform', '.form-fields-container', function(event, data) {
$(this).find('.upload-file').each(function(){
UploadField($(this), data.set_objection);
});
event.stopPropagation();
});
})(jQuery, jsontemplate); | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/widgets/static/upload.js | upload.js |
(function($) {
var create_datetime_field = function() {
var $field = $(this);
if ($field.attr('readonly') == 'readonly') {
// No picker for readonly fields.
return;
};
var id = $field.attr('id');
var $year = $('#' + id + '-year');
var $month = $('#' + id + '-month');
var $day = $('#' + id + '-day');
var $hour = $('#' + id + '-hour');
var $minute = $('#' + id + '-min');
var $remove = $('#' + id + '-remove');
var hasTime = ($hour.length > 0);
var lang = $(document).find('html').attr('lang');
var field_settings = {
showOn: 'button',
// XXX need to figure out something to get image with JS
buttonImage: '/++static++/zeam.form.silva.widgets/calendar.png',
buttonImageOnly: true,
buttonText: 'Date picker',
showWeek: true,
showOtherMonths: true,
dateFormat: 'yy/mm/dd',
onSelect: function(date, picker) {
var parts = date.split('/');
$day.val(parts[2]);
$month.val(parts[1]);
$year.val(parts[0]);
if (hasTime) {
if (!$hour.val()) {
$hour.val('00');
};
if (!$minute.val()) {
$minute.val('00');
};
}
$field.trigger('change');
},
beforeShow: function() {
var selected_day = $day.val();
var selected_month = $month.val();
var selected_year = $year.val();
var date = null;
if (selected_day && selected_month && selected_year) {
date = new Date(selected_year, selected_month - 1, selected_day);
} else {
date = new Date();
};
$field.datepicker('setDate', date);
}
};
if ($remove.length) {
$remove.bind('click', function(event) {
// Reset everything
$day.val('');
$month.val('');
$year.val('');
if (hasTime) {
$hour.val('');
$minute.val('');
}
$field.datepicker('setDate', new Date());
return false;
});
};
var lang_settings = $.datepicker.regional[lang];
if (!lang_settings) {
lang_settings = $.datepicker.regional[''];
};
$field.datepicker($.extend({}, lang_settings, field_settings));
};
if (window.smi !== undefined) {
$(document).on('loadwidget-smiform', '.form-fields-container', function(event) {
$(this).find('.field-datetime, .field-date').each(create_datetime_field);
event.stopPropagation();
});
} else {
// This widget can be used on the public view as well.
$(document).ready(function() {
$(this).find('.field-datetime, .field-date').each(create_datetime_field);
});
};
})(jQuery); | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/widgets/static/datetime.js | datetime.js |
(function($){$.Jcrop=function(obj,opt){function px(n){return""+parseInt(n)+"px"}function pct(n){return""+parseInt(n)+"%"}function cssClass(cl){return options.baseClass+"-"+cl}function getPos(obj){var pos=$(obj).offset();return[pos.left,pos.top]}function mouseAbs(e){return[e.pageX-docOffset[0],e.pageY-docOffset[1]]}function myCursor(type){type!=lastcurs&&(Tracker.setCursor(type),lastcurs=type)}function startDragMode(mode,pos){if(docOffset=getPos($img),Tracker.setCursor("move"==mode?mode:mode+"-resize"),"move"==mode)return Tracker.activateHandlers(createMover(pos),doneSelect);var fc=Coords.getFixed(),opp=oppLockCorner(mode),opc=Coords.getCorner(oppLockCorner(opp));Coords.setPressed(Coords.getCorner(opp)),Coords.setCurrent(opc),Tracker.activateHandlers(dragmodeHandler(mode,fc),doneSelect)}function dragmodeHandler(mode,f){return function(pos){if(options.aspectRatio)switch(mode){case"e":pos[1]=f.y+1;break;case"w":pos[1]=f.y+1;break;case"n":pos[0]=f.x+1;break;case"s":pos[0]=f.x+1}else switch(mode){case"e":pos[1]=f.y2;break;case"w":pos[1]=f.y2;break;case"n":pos[0]=f.x2;break;case"s":pos[0]=f.x2}Coords.setCurrent(pos),Selection.update()}}function createMover(pos){var lloc=pos;return KeyManager.watchKeys(),function(pos){Coords.moveOffset([pos[0]-lloc[0],pos[1]-lloc[1]]),lloc=pos,Selection.update()}}function oppLockCorner(ord){switch(ord){case"n":return"sw";case"s":return"nw";case"e":return"nw";case"w":return"ne";case"ne":return"sw";case"nw":return"se";case"se":return"nw";case"sw":return"ne"}}function createDragger(ord){return function(e){return options.disabled?!1:"move"!=ord||options.allowMove?(btndown=!0,startDragMode(ord,mouseAbs(e)),e.stopPropagation(),e.preventDefault(),!1):!1}}function presize($obj,w,h){var nw=$obj.width(),nh=$obj.height();nw>w&&w>0&&(nw=w,nh=w/$obj.width()*$obj.height()),nh>h&&h>0&&(nh=h,nw=h/$obj.height()*$obj.width()),xscale=$obj.width()/nw,yscale=$obj.height()/nh,$obj.width(nw).height(nh)}function unscale(c){return{x:parseInt(c.x*xscale),y:parseInt(c.y*yscale),x2:parseInt(c.x2*xscale),y2:parseInt(c.y2*yscale),w:parseInt(c.w*xscale),h:parseInt(c.h*yscale)}}function doneSelect(){var c=Coords.getFixed();c.w>options.minSelect[0]&&c.h>options.minSelect[1]?(Selection.enableHandles(),Selection.done()):Selection.release(),Tracker.setCursor(options.allowSelect?"crosshair":"default")}function newSelection(e){if(options.disabled)return!1;if(!options.allowSelect)return!1;btndown=!0,docOffset=getPos($img),Selection.disableHandles(),myCursor("crosshair");var pos=mouseAbs(e);return Coords.setPressed(pos),Tracker.activateHandlers(selectDrag,doneSelect),KeyManager.watchKeys(),Selection.update(),e.stopPropagation(),e.preventDefault(),!1}function selectDrag(pos){Coords.setCurrent(pos),Selection.update()}function newTracker(){var trk=$("<div></div>").addClass(cssClass("tracker"));return $.browser.msie&&trk.css({opacity:0,backgroundColor:"white"}),trk}function animateTo(a){function animateStart(){window.setTimeout(animator,interv)}var x1=a[0]/xscale,y1=a[1]/yscale,x2=a[2]/xscale,y2=a[3]/yscale;if(!animating){var animto=Coords.flipCoords(x1,y1,x2,y2),c=Coords.getFixed(),animat=initcr=[c.x,c.y,c.x2,c.y2],interv=options.animationDelay,x=animat[0],y=animat[1],x2=animat[2],y2=animat[3],ix1=animto[0]-initcr[0],iy1=animto[1]-initcr[1],ix2=animto[2]-initcr[2],iy2=animto[3]-initcr[3],pcent=0,velocity=options.swingSpeed;Selection.animMode(!0);var animator=function(){return function(){pcent+=(100-pcent)/velocity,animat[0]=x+pcent/100*ix1,animat[1]=y+pcent/100*iy1,animat[2]=x2+pcent/100*ix2,animat[3]=y2+pcent/100*iy2,100>pcent?animateStart():Selection.done(),pcent>=99.8&&(pcent=100),setSelectRaw(animat)}}();animateStart()}}function setSelect(rect){setSelectRaw([rect[0]/xscale,rect[1]/yscale,rect[2]/xscale,rect[3]/yscale])}function setSelectRaw(l){Coords.setPressed([l[0],l[1]]),Coords.setCurrent([l[2],l[3]]),Selection.update()}function setOptions(opt){"object"!=typeof opt&&(opt={}),options=$.extend(options,opt),"function"!=typeof options.onChange&&(options.onChange=function(){}),"function"!=typeof options.onSelect&&(options.onSelect=function(){})}function tellSelect(){return unscale(Coords.getFixed())}function tellScaled(){return Coords.getFixed()}function setOptionsNew(opt){setOptions(opt),interfaceUpdate()}function disableCrop(){options.disabled=!0,Selection.disableHandles(),Selection.setCursor("default"),Tracker.setCursor("default")}function enableCrop(){options.disabled=!1,interfaceUpdate()}function cancelCrop(){Selection.done(),Tracker.activateHandlers(null,null)}function destroy(){$div.remove(),$origimg.show()}function interfaceUpdate(alt){options.allowResize?alt?Selection.enableOnly():Selection.enableHandles():Selection.disableHandles(),Tracker.setCursor(options.allowSelect?"crosshair":"default"),Selection.setCursor(options.allowMove?"move":"default"),$div.css("backgroundColor",options.bgColor),"setSelect"in options&&(setSelect(opt.setSelect),Selection.done(),delete options.setSelect),"trueSize"in options&&(xscale=options.trueSize[0]/boundx,yscale=options.trueSize[1]/boundy),xlimit=options.maxSize[0]||0,ylimit=options.maxSize[1]||0,xmin=options.minSize[0]||0,ymin=options.minSize[1]||0,"outerImage"in options&&($img.attr("src",options.outerImage),delete options.outerImage),Selection.refresh()}var obj=obj,opt=opt;"object"!=typeof obj&&(obj=$(obj)[0]),"object"!=typeof opt&&(opt={}),"trackDocument"in opt||(opt.trackDocument=$.browser.msie?!1:!0,$.browser.msie&&"8"==$.browser.version.split(".")[0]&&(opt.trackDocument=!0)),"keySupport"in opt||(opt.keySupport=$.browser.msie?!1:!0);var defaults={trackDocument:!1,baseClass:"jcrop",addClass:null,bgColor:"black",bgOpacity:.6,borderOpacity:.4,handleOpacity:.5,handlePad:5,handleSize:9,handleOffset:5,edgeMargin:14,aspectRatio:0,keySupport:!0,cornerHandles:!0,sideHandles:!0,drawBorders:!0,dragEdges:!0,boxWidth:0,boxHeight:0,boundary:8,animationDelay:20,swingSpeed:3,allowSelect:!0,allowMove:!0,allowResize:!0,minSelect:[0,0],maxSize:[0,0],minSize:[0,0],onChange:function(){},onSelect:function(){}},options=defaults;setOptions(opt);var $origimg=$(obj),$img=$origimg.clone().removeAttr("id").css({position:"absolute"});$img.width($origimg.width()),$img.height($origimg.height()),$origimg.after($img).hide(),presize($img,options.boxWidth,options.boxHeight);var boundx=$img.width(),boundy=$img.height(),$div=$("<div />").width(boundx).height(boundy).addClass(cssClass("holder")).css({position:"relative",backgroundColor:options.bgColor}).insertAfter($origimg).append($img);options.addClass&&$div.addClass(options.addClass);var xlimit,ylimit,xmin,ymin,xscale,yscale,btndown,lastcurs,animating,shift_down,$img2=$("<img />").attr("src",$img.attr("src")).css("position","absolute").width(boundx).height(boundy),$img_holder=$("<div />").width(pct(100)).height(pct(100)).css({zIndex:310,position:"absolute",overflow:"hidden"}).append($img2),$hdl_holder=$("<div />").width(pct(100)).height(pct(100)).css("zIndex",320),$sel=$("<div />").css({position:"absolute",zIndex:300}).insertBefore($img).append($img_holder,$hdl_holder),bound=options.boundary,$trk=newTracker().width(boundx+2*bound).height(boundy+2*bound).css({position:"absolute",top:px(-bound),left:px(-bound),zIndex:290}).mousedown(newSelection),docOffset=getPos($img),Coords=function(){function setPressed(pos){var pos=rebound(pos);x2=x1=pos[0],y2=y1=pos[1]}function setCurrent(pos){var pos=rebound(pos);ox=pos[0]-x2,oy=pos[1]-y2,x2=pos[0],y2=pos[1]}function getOffset(){return[ox,oy]}function moveOffset(offset){var ox=offset[0],oy=offset[1];0>x1+ox&&(ox-=ox+x1),0>y1+oy&&(oy-=oy+y1),y2+oy>boundy&&(oy+=boundy-(y2+oy)),x2+ox>boundx&&(ox+=boundx-(x2+ox)),x1+=ox,x2+=ox,y1+=oy,y2+=oy}function getCorner(ord){var c=getFixed();switch(ord){case"ne":return[c.x2,c.y];case"nw":return[c.x,c.y];case"se":return[c.x2,c.y2];case"sw":return[c.x,c.y2]}}function getFixed(){if(!options.aspectRatio)return getRect();var xx,yy,aspect=options.aspectRatio,min_x=options.minSize[0]/xscale,max_x=(options.minSize[1]/yscale,options.maxSize[0]/xscale),max_y=options.maxSize[1]/yscale,rw=x2-x1,rh=y2-y1,rwa=Math.abs(rw),rha=Math.abs(rh),real_ratio=rwa/rha;return 0==max_x&&(max_x=10*boundx),0==max_y&&(max_y=10*boundy),aspect>real_ratio?(yy=y2,w=rha*aspect,xx=0>rw?x1-w:w+x1,0>xx?(xx=0,h=Math.abs((xx-x1)/aspect),yy=0>rh?y1-h:h+y1):xx>boundx&&(xx=boundx,h=Math.abs((xx-x1)/aspect),yy=0>rh?y1-h:h+y1)):(xx=x2,h=rwa/aspect,yy=0>rh?y1-h:y1+h,0>yy?(yy=0,w=Math.abs((yy-y1)*aspect),xx=0>rw?x1-w:w+x1):yy>boundy&&(yy=boundy,w=Math.abs(yy-y1)*aspect,xx=0>rw?x1-w:w+x1)),xx>x1?(min_x>xx-x1?xx=x1+min_x:xx-x1>max_x&&(xx=x1+max_x),yy=yy>y1?y1+(xx-x1)/aspect:y1-(xx-x1)/aspect):x1>xx&&(min_x>x1-xx?xx=x1-min_x:x1-xx>max_x&&(xx=x1-max_x),yy=yy>y1?y1+(x1-xx)/aspect:y1-(x1-xx)/aspect),0>xx?(x1-=xx,xx=0):xx>boundx&&(x1-=xx-boundx,xx=boundx),0>yy?(y1-=yy,yy=0):yy>boundy&&(y1-=yy-boundy,yy=boundy),last=makeObj(flipCoords(x1,y1,xx,yy))}function rebound(p){return 0>p[0]&&(p[0]=0),0>p[1]&&(p[1]=0),p[0]>boundx&&(p[0]=boundx),p[1]>boundy&&(p[1]=boundy),[p[0],p[1]]}function flipCoords(x1,y1,x2,y2){var xa=x1,xb=x2,ya=y1,yb=y2;return x1>x2&&(xa=x2,xb=x1),y1>y2&&(ya=y2,yb=y1),[Math.round(xa),Math.round(ya),Math.round(xb),Math.round(yb)]}function getRect(){var xsize=x2-x1,ysize=y2-y1;if(xlimit&&Math.abs(xsize)>xlimit&&(x2=xsize>0?x1+xlimit:x1-xlimit),ylimit&&Math.abs(ysize)>ylimit&&(y2=ysize>0?y1+ylimit:y1-ylimit),ymin&&ymin>Math.abs(ysize)&&(y2=ysize>0?y1+ymin:y1-ymin),xmin&&xmin>Math.abs(xsize)&&(x2=xsize>0?x1+xmin:x1-xmin),0>x1&&(x2-=x1,x1-=x1),0>y1&&(y2-=y1,y1-=y1),0>x2&&(x1-=x2,x2-=x2),0>y2&&(y1-=y2,y2-=y2),x2>boundx){var delta=x2-boundx;x1-=delta,x2-=delta}if(y2>boundy){var delta=y2-boundy;y1-=delta,y2-=delta}if(x1>boundx){var delta=x1-boundy;y2-=delta,y1-=delta}if(y1>boundy){var delta=y1-boundy;y2-=delta,y1-=delta}return makeObj(flipCoords(x1,y1,x2,y2))}function makeObj(a){return{x:a[0],y:a[1],x2:a[2],y2:a[3],w:a[2]-a[0],h:a[3]-a[1]}}var ox,oy,x1=0,y1=0,x2=0,y2=0;return{flipCoords:flipCoords,setPressed:setPressed,setCurrent:setCurrent,getOffset:getOffset,moveOffset:moveOffset,getCorner:getCorner,getFixed:getFixed}}(),Selection=function(){function insertBorder(type){var jq=$("<div />").css({position:"absolute",opacity:options.borderOpacity}).addClass(cssClass(type));return $img_holder.append(jq),jq}function dragDiv(ord,zi){var jq=$("<div />").mousedown(createDragger(ord)).css({cursor:ord+"-resize",position:"absolute",zIndex:zi});return $hdl_holder.append(jq),jq}function insertHandle(ord){return dragDiv(ord,hdep++).css({top:px(-hhs+1),left:px(-hhs+1),opacity:options.handleOpacity}).addClass(cssClass("handle"))}function insertDragbar(ord){var s=options.handleSize,o=hhs,h=s,w=s,t=o,l=o;switch(ord){case"n":case"s":w=pct(100);break;case"e":case"w":h=pct(100)}return dragDiv(ord,hdep++).width(w).height(h).css({top:px(-t+1),left:px(-l+1)})}function createHandles(li){for(i in li)handle[li[i]]=insertHandle(li[i])}function moveHandles(c){var midvert=Math.round(c.h/2-hhs),midhoriz=Math.round(c.w/2-hhs),east=(west=-hhs+1,c.w-hhs),south=c.h-hhs;"e"in handle&&handle.e.css({top:px(midvert),left:px(east)})&&handle.w.css({top:px(midvert)})&&handle.s.css({top:px(south),left:px(midhoriz)})&&handle.n.css({left:px(midhoriz)}),"ne"in handle&&handle.ne.css({left:px(east)})&&handle.se.css({top:px(south),left:px(east)})&&handle.sw.css({top:px(south)}),"b"in handle&&handle.b.css({top:px(south)})&&handle.r.css({left:px(east)})}function moveto(x,y){$img2.css({top:px(-y),left:px(-x)}),$sel.css({top:px(y),left:px(x)})}function resize(w,h){$sel.width(w).height(h)}function refresh(){var c=Coords.getFixed();Coords.setPressed([c.x,c.y]),Coords.setCurrent([c.x2,c.y2]),updateVisible()}function updateVisible(){return awake?update():void 0}function update(){var c=Coords.getFixed();resize(c.w,c.h),moveto(c.x,c.y),options.drawBorders&&borders.right.css({left:px(c.w-1)})&&borders.bottom.css({top:px(c.h-1)}),seehandles&&moveHandles(c),awake||show(),options.onChange(unscale(c))}function show(){$sel.show(),$img.css("opacity",options.bgOpacity),awake=!0}function release(){disableHandles(),$sel.hide(),$img.css("opacity",1),awake=!1}function showHandles(){seehandles&&(moveHandles(Coords.getFixed()),$hdl_holder.show())}function enableHandles(){return seehandles=!0,options.allowResize?(moveHandles(Coords.getFixed()),$hdl_holder.show(),!0):void 0}function disableHandles(){seehandles=!1,$hdl_holder.hide()}function animMode(v){(animating=v)?disableHandles():enableHandles()}function done(){animMode(!1),refresh()}var awake,hdep=370,borders={},handle={},seehandles=!1,hhs=options.handleOffset;options.drawBorders&&(borders={top:insertBorder("hline").css("top",$.browser.msie?px(-1):px(0)),bottom:insertBorder("hline"),left:insertBorder("vline"),right:insertBorder("vline")}),options.dragEdges&&(handle.t=insertDragbar("n"),handle.b=insertDragbar("s"),handle.r=insertDragbar("e"),handle.l=insertDragbar("w")),options.sideHandles&&createHandles(["n","s","e","w"]),options.cornerHandles&&createHandles(["sw","nw","ne","se"]);var $track=newTracker().mousedown(createDragger("move")).css({cursor:"move",position:"absolute",zIndex:360});return $img_holder.append($track),disableHandles(),{updateVisible:updateVisible,update:update,release:release,refresh:refresh,setCursor:function(cursor){$track.css("cursor",cursor)},enableHandles:enableHandles,enableOnly:function(){seehandles=!0},showHandles:showHandles,disableHandles:disableHandles,animMode:animMode,done:done}}(),Tracker=function(){function toFront(){$trk.css({zIndex:450}),trackDoc&&$(document).mousemove(trackMove).mouseup(trackUp)}function toBack(){$trk.css({zIndex:290}),trackDoc&&$(document).unbind("mousemove",trackMove).unbind("mouseup",trackUp)}function trackMove(e){onMove(mouseAbs(e))}function trackUp(e){return e.preventDefault(),e.stopPropagation(),btndown&&(btndown=!1,onDone(mouseAbs(e)),options.onSelect(unscale(Coords.getFixed())),toBack(),onMove=function(){},onDone=function(){}),!1}function activateHandlers(move,done){return btndown=!0,onMove=move,onDone=done,toFront(),!1}function setCursor(t){$trk.css("cursor",t)}var onMove=function(){},onDone=function(){},trackDoc=options.trackDocument;return trackDoc||$trk.mousemove(trackMove).mouseup(trackUp).mouseout(trackUp),$img.before($trk),{activateHandlers:activateHandlers,setCursor:setCursor}}(),KeyManager=function(){function watchKeys(){options.keySupport&&($keymgr.show(),$keymgr.focus())}function onBlur(){$keymgr.hide()}function doNudge(e,x,y){options.allowMove&&(Coords.moveOffset([x,y]),Selection.updateVisible()),e.preventDefault(),e.stopPropagation()}function parseKey(e){if(e.ctrlKey)return!0;shift_down=e.shiftKey?!0:!1;var nudge=shift_down?10:1;switch(e.keyCode){case 37:doNudge(e,-nudge,0);break;case 39:doNudge(e,nudge,0);break;case 38:doNudge(e,0,-nudge);break;case 40:doNudge(e,0,nudge);break;case 27:Selection.release();break;case 9:return!0}return nothing(e)}var $keymgr=$('<input type="radio" />').css({position:"absolute",left:"-30px"}).keypress(parseKey).blur(onBlur),$keywrap=$("<div />").css({position:"absolute",overflow:"hidden"}).append($keymgr);return options.keySupport&&$keywrap.insertBefore($img),{watchKeys:watchKeys}}();$hdl_holder.hide(),interfaceUpdate(!0);var api={animateTo:animateTo,setSelect:setSelect,setOptions:setOptionsNew,tellSelect:tellSelect,tellScaled:tellScaled,disable:disableCrop,enable:enableCrop,cancel:cancelCrop,focus:KeyManager.watchKeys,getBounds:function(){return[boundx*xscale,boundy*yscale]},getWidgetSize:function(){return[boundx,boundy]},release:Selection.release,destroy:destroy};return $origimg.data("Jcrop",api),api},$.fn.Jcrop=function(options){function attachWhenDone(from){var loadsrc=options.useImg||from.src,img=new Image;img.onload=function(){$.Jcrop(from,options)},img.src=loadsrc}return"object"!=typeof options&&(options={}),this.each(function(){if($(this).data("Jcrop")){if("api"==options)return $(this).data("Jcrop");$(this).data("Jcrop").setOptions(options)}else attachWhenDone(this)}),this}})(jQuery); | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/widgets/static/jquery.Jcrop.min.js | jquery.Jcrop.min.js |
(function($) {
$.widget("ui.multiselect", {
options: {
sortable: true,
searchable: true,
doubleClickable: true,
animated: 'fast',
show: 'slideDown',
hide: 'slideUp',
dividerLocation: 0.6,
nodeComparator: function(node1,node2) {
var text1 = node1.text(),
text2 = node2.text();
return text1 == text2 ? 0 : (text1 < text2 ? -1 : 1);
}
},
_create: function() {
var that = this;
this.element.hide();
this.id = this.element.attr("id");
this.count = 0; // number of currently selected options
this.container = $('<div class="ui-multiselect ui-helper-clearfix ui-widget"></div>');
this.selectedContainer = $('<div class="ui-multiselect-selected ui-multiselect-container"></div>').appendTo(this.container);
this.availableContainer = $('<div class="ui-multiselect-available ui-multiselect-container"></div>').appendTo(this.container);
this.selectedActions = $('<div class="ui-multiselect-actions ui-widget-header ui-helper-clearfix"><span class="count">0 '+$.ui.multiselect.locale.itemsCount+'</span><a href="#" class="remove-all">'+$.ui.multiselect.locale.removeAll+'</a></div>').appendTo(this.selectedContainer);
this.availableActions = $('<div class="ui-multiselect-actions ui-widget-header ui-helper-clearfix"><input type="search" class="search empty ui-widget-content ui-corner-all"/><a href="#" class="add-all">'+$.ui.multiselect.locale.addAll+'</a></div>').appendTo(this.availableContainer);
this.selectedList = $('<ul class="ui-multiselect-selected connected-list"><li class="ui-helper-hidden-accessible"></li></ul>').bind('selectstart', function(){return false;}).appendTo(this.selectedContainer);
this.availableList = $('<ul class="ui-multiselect-available connected-list"><li class="ui-helper-hidden-accessible"></li></ul>').bind('selectstart', function(){return false;}).appendTo(this.availableContainer);
if ( !this.options.animated ) {
this.options.show = 'show';
this.options.hide = 'hide';
}
// init lists
this._populateLists(this.element.find('option'));
// make selection sortable
if (this.options.sortable) {
this.selectedList.sortable({
placeholder: 'ui-state-highlight',
axis: 'y',
update: function(event, ui) {
// apply the new sort order to the original selectbox
that.selectedList.find('li').each(function() {
if ($(this).data('optionLink'))
$(this).data('optionLink').remove().appendTo(that.element);
});
},
receive: function(event, ui) {
ui.item.data('optionLink').attr('selected', true);
// increment count
that.count += 1;
that._updateCount();
// workaround, because there's no way to reference
// the new element, see http://dev.jqueryui.com/ticket/4303
that.selectedList.children('.ui-draggable').each(function() {
$(this).removeClass('ui-draggable');
$(this).data('optionLink', ui.item.data('optionLink'));
$(this).data('idx', ui.item.data('idx'));
that._applyItemState($(this), true);
});
// workaround according to http://dev.jqueryui.com/ticket/4088
setTimeout(function() { ui.item.remove(); }, 1);
}
});
}
// set up livesearch
if (this.options.searchable) {
this._registerSearchEvents(this.availableContainer.find('input.search'));
} else {
$('.search').hide();
}
// batch actions
this.container.find(".remove-all").click(function() {
that._populateLists(that.element.find('option').removeAttr('selected'));
return false;
});
this.container.find(".add-all").click(function() {
var options = that.element.find('option').not(":selected");
if (that.availableList.children('li:hidden').length > 1) {
that.availableList.children('li').each(function(i) {
if ($(this).is(":visible")) $(options[i-1]).attr('selected', 'selected');
});
} else {
options.attr('selected', 'selected');
}
that._populateLists(that.element.find('option'));
return false;
});
this.container.insertAfter(this.element);
},
destroy: function() {
this.element.show();
this.container.remove();
$.Widget.prototype.destroy.apply(this, arguments);
},
_populateLists: function(options) {
this.selectedList.children('.ui-element').remove();
this.availableList.children('.ui-element').remove();
this.count = 0;
var that = this;
var items = $(options.map(function(i) {
var item = that._getOptionNode(this).appendTo(this.selected ? that.selectedList : that.availableList).show();
if (this.selected) that.count += 1;
that._applyItemState(item, this.selected);
item.data('idx', i);
return item[0];
}));
// update count
this._updateCount();
that._filter.apply(this.availableContainer.find('input.search'), [that.availableList]);
},
_updateCount: function() {
this.selectedContainer.find('span.count').text(this.count+" "+$.ui.multiselect.locale.itemsCount);
},
_getOptionNode: function(option) {
option = $(option);
var node = $('<li class="ui-state-default ui-element" title="'+option.text()+'"><span class="ui-icon"/>'+option.text()+'<a href="#" class="ui-multiselect-action"><span class="ui-corner-all ui-icon"/></a></li>').hide();
node.data('optionLink', option);
return node;
},
// clones an item with associated data
// didn't find a smarter away around this
_cloneWithData: function(clonee) {
var clone = clonee.clone(false,false);
clone.data('optionLink', clonee.data('optionLink'));
clone.data('idx', clonee.data('idx'));
return clone;
},
_setSelected: function(item, selected) {
item.data('optionLink').attr('selected', selected);
if (selected) {
var selectedItem = this._cloneWithData(item);
item[this.options.hide](this.options.animated, function() { $(this).remove(); });
selectedItem.appendTo(this.selectedList).hide()[this.options.show](this.options.animated);
this._applyItemState(selectedItem, true);
return selectedItem;
} else {
// look for successor based on initial option index
var items = this.availableList.find('li'), comparator = this.options.nodeComparator;
var succ = null, i = item.data('idx'), direction = comparator(item, $(items[i]));
// TODO: test needed for dynamic list populating
if ( direction ) {
while (i>=0 && i<items.length) {
direction > 0 ? i++ : i--;
if ( direction != comparator(item, $(items[i])) ) {
// going up, go back one item down, otherwise leave as is
succ = items[direction > 0 ? i : i+1];
break;
}
}
} else {
succ = items[i];
}
var availableItem = this._cloneWithData(item);
succ ? availableItem.insertBefore($(succ)) : availableItem.appendTo(this.availableList);
item[this.options.hide](this.options.animated, function() { $(this).remove(); });
availableItem.hide()[this.options.show](this.options.animated);
this._applyItemState(availableItem, false);
return availableItem;
}
},
_applyItemState: function(item, selected) {
if (selected) {
if (this.options.sortable)
item.children('span').addClass('ui-icon-arrowthick-2-n-s').removeClass('ui-helper-hidden').addClass('ui-icon');
else
item.children('span').removeClass('ui-icon-arrowthick-2-n-s').addClass('ui-helper-hidden').removeClass('ui-icon');
item.find('a.ui-multiselect-action span').addClass('ui-icon-minus').removeClass('ui-icon-plus');
this._registerRemoveEvents(item.find('a.ui-multiselect-action'));
} else {
item.children('span').removeClass('ui-icon-arrowthick-2-n-s').addClass('ui-helper-hidden').removeClass('ui-icon');
item.find('a.ui-multiselect-action span').addClass('ui-icon-plus').removeClass('ui-icon-minus');
this._registerAddEvents(item.find('a.ui-multiselect-action'));
}
this._registerHoverEvents(item);
},
// taken from John Resig's liveUpdate script
_filter: function(list) {
var input = $(this);
var rows = list.children('li'),
cache = rows.map(function(){
return $(this).text().toLowerCase();
});
var term = $.trim(input.val().toLowerCase()), scores = [];
if (!term) {
rows.show();
} else {
rows.hide();
cache.each(function(i) {
if (this.indexOf(term)>-1) { scores.push(i); }
});
$.each(scores, function() {
$(rows[this]).show();
});
}
},
_registerHoverEvents: function(elements) {
elements.removeClass('ui-state-hover');
elements.mouseover(function() {
$(this).addClass('ui-state-hover');
});
elements.mouseout(function() {
$(this).removeClass('ui-state-hover');
});
},
_registerAddEvents: function(elements) {
var that = this;
elements.click(function() {
var item = that._setSelected($(this).parent(), true);
that.count += 1;
that._updateCount();
return false;
});
// make draggable
if (this.options.sortable) {
elements.each(function() {
$(this).parent().draggable({
connectToSortable: that.selectedList,
helper: function() {
var selectedItem = that._cloneWithData($(this)).width($(this).width() - 50);
selectedItem.width($(this).width());
return selectedItem;
},
appendTo: that.container,
containment: that.container,
revert: 'invalid'
});
});
}
},
_registerRemoveEvents: function(elements) {
var that = this;
elements.click(function() {
that._setSelected($(this).parent(), false);
that.count -= 1;
that._updateCount();
return false;
});
},
_registerSearchEvents: function(input) {
var that = this;
input.focus(function() {
$(this).addClass('ui-state-active');
})
.blur(function() {
$(this).removeClass('ui-state-active');
})
.keypress(function(e) {
if (e.keyCode == 13)
return false;
})
.keyup(function() {
that._filter.apply(this, [that.availableList]);
})
.bind('search', function() {
that._filter.apply(this, [that.availableList]);
});
}
});
$.extend($.ui.multiselect, {
locale: {
addAll:'Add all',
removeAll:'Remove all',
itemsCount:'items selected'
}
});
})(jQuery); | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/widgets/static/jquery.multiselect.js | jquery.multiselect.js |
(function($, infrae) {
var create_combobox_field = function() {
var $field = $(this);
var $select = $field.children('select');
var $input = $field.children('input.combobox-input');
var $opener = $field.children('a.combobox-opener');
var selected = $select.children(":selected");
var value = selected.text();
$input.val(value).autocomplete({
delay: 0,
minLength: 0,
source: function(request, response) {
var matcher = new RegExp($.ui.autocomplete.escapeRegex(request.term), "i");
response($select.children("option").map(function() {
var $option = $(this);
var text = $option.text();
if (!request.term || matcher.test(text)) {
return {
label: text.replace(
new RegExp(
"(?![^&;]+;)(?!<[^<>]*)(" +
$.ui.autocomplete.escapeRegex(request.term) +
")(?![^<>]*>)(?![^&;]+;)", "gi"
), "<strong>$1</strong>" ),
icon: $option.data('combobox-icon'),
value: text,
option: this
};
};
}));
},
select: function(event, ui) {
ui.item.option.selected = true;
value = ui.item.value;
},
change: function(event, ui) {
if (!ui.item) {
var valid = false;
var matcher = new RegExp("^" + $.ui.autocomplete.escapeRegex($(this).val()) + "$", "i");
$select.children("option").each(function() {
var $option = $(this);
if ($option.text().match(matcher)) {
this.selected = valid = true;
return false;
}
});
if (!valid) {
// Clean invalid value, set original back one.
$(this).val(value);
$select.val(value);
$input.data("autocomplete").term = value;
return false;
}
}
}
});
$input.data("autocomplete")._resizeMenu = function() {
var $ul = this.menu.element;
// 20 pixels to let place for icon, 20 for scroll bar
$ul.outerWidth( Math.max(
$ul.width( "" ).outerWidth() + 40,
this.element.outerWidth()
) );
};
$input.data("autocomplete")._renderItem = function(ul, item) {
var $item = $('<li><a>' + item.label + "</a></li>");
if (item.icon) {
var $icon = $('<ins class="icon" />');
infrae.ui.icon($icon, item.icon);
$item.prepend($icon);
};
return $item.data("item.autocomplete", item).appendTo(ul);
};
$input.autocomplete('widget').zIndex($input.zIndex() + 1);
$opener.click(function() {
// close if already visible
if ($input.autocomplete("widget").is(":visible") ) {
$input.autocomplete("close");
return;
};
$opener.blur();
$input.autocomplete("search", "");
$input.focus();
});
};
$(document).on('loadwidget-smiform', '.form-fields-container', function(event) {
$(this).find('.field-combobox').each(create_combobox_field);
event.stopPropagation();
});
})(jQuery, infrae); | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/widgets/static/combobox.js | combobox.js |
(function($,jsontemplate){var IDENTIFIER_KEY="X-Progress-ID",POLL_NETWORK_RETRIES=5,POLL_NETWORK_DELAY=500,POLL_MISSING_RETRIES=20,DONT_NEED_POPUP=function(){var $test=$('<div style="display:none;"><form id="testform1"><input type="file" form="testform2" /></form><form id="testform2"></form></div>'),supported=!1;return $("body").append($test),supported=0===$test.find("#testform1")[0].length&&1===$test.find("#testform2")[0].length,$test.remove(),supported}(),PollStatusChecker=function(url,identifier,result){var poll_retries=POLL_NETWORK_RETRIES,poll_timeout=null,missing_retries=POLL_MISSING_RETRIES,deferred=$.Deferred(),poll=function(){$.ajax({type:"GET",dataType:"jsonp",url:url+"/status?"+IDENTIFIER_KEY+"="+identifier}).then(function(info){var error=null;result.notify(info),"starting"==info.state&&(missing_retries-=1,missing_retries||(error=info.error||"Upload does not start",deferred.reject({message:"Upload failed ("+error+")."}))),"done"==info.state||"error"==info.state?"done"==info.state?deferred.resolve(info):(error=info.error||"Unknow error",deferred.reject({message:"Upload failed ("+error+")."})):"pending"==result.state()&&missing_retries&&(poll_retries=POLL_NETWORK_RETRIES,poll_timeout=setTimeout(poll,POLL_NETWORK_DELAY))},function(){"pending"==result.state()&&(poll_retries?(poll_retries-=1,poll_timeout=setTimeout(poll,POLL_NETWORK_DELAY)):deferred.reject({message:"Upload failed (Cannot check the status of the upload)."}))})};return{promise:deferred.promise,start:function(){poll_timeout=setTimeout(poll,POLL_NETWORK_DELAY)},always:function(){null!==poll_timeout&&(clearTimeout(poll_timeout),poll_timeout=null)}}},IFrameStatusChecker=function($iframe,identifier){var iframe=$iframe.get(0),iframe_window=iframe.contentWindow,iframe_document=iframe_window.document,deferred=$.Deferred(),fail=function(){setTimeout(function(){deferred.reject({message:"Upload failed (File too big or server error)."})},POLL_NETWORK_DELAY)},load=function(){var $body=$(iframe_document.body);$body.data("upload-identifier")==identifier?deferred.resolve($body.data("upload-info")):fail()};return iframe_window.addEventListener?(iframe_window.addEventListener("load",load,!1),iframe_window.addEventListener("error",fail,!1)):(iframe_window.attachEvent("onload",load),iframe_window.attachEvent("onerror",fail)),{promise:deferred.promise}},UploadStatusMessage=function($display){var $empty=$display.children(".upload-display-empty"),$uploading=$display.children(".upload-display-uploading"),$done=$display.children(".upload-display-complete"),empty=$empty.children("i").text(),uploading=jsontemplate.Template($uploading.children("i").text(),{}),done=jsontemplate.Template($done.children("i").text(),{}),state="empty",defaults={filename:"","content-type":"n/a"},original=$display.data("upload-status"),api={start:function(data){"starting"!=state&&($uploading.children("i").text(uploading.expand($.extend({},defaults,data))),$empty.hide(),$done.hide(),$uploading.show(),state="starting")},progress:function(data){"uploading"!=state&&"uploading"==data.state&&($uploading.children("i").text(uploading.expand($.extend({},defaults,data))),state="uploading")},done:function(data){"done"!=state&&($done.children("i").text(done.expand($.extend({},defaults,data))),$empty.hide(),$uploading.hide(),$done.show(),state="done")},fail:function(data){("empty"!=state||data.message)&&($empty.children("i").text(data.message||empty),"empty"!=state&&($uploading.hide(),$done.hide(),$empty.show(),state="empty"))}};return original&&api.done(original),api},UploadProgress=function($progress){var progress=0;return{start:function(){$progress.progressbar({value:0}).show()},progress:function(data){var updated=0;"uploading"==data.state&&(updated=100*data.received/data.size),updated!=progress&&($progress.progressbar({value:updated}),progress=updated)},always:function(){$progress.hide(),progress=0}}},UploadUI=function($field,set_objection,get_upload){var $input=$field.children(".upload-input"),$cancel=$field.children(".upload-cancel"),$clear=$field.children(".upload-clear"),upload=null,objection=null,progress=UploadProgress($field.children(".upload-progress")),status=UploadStatusMessage($field.children(".upload-display")),api={get:function(create){return null==upload&&create&&(upload=get_upload(),upload.register(status),upload.register(progress),upload.register(ui)),upload}},ui={start:function(){void 0!==set_objection&&(objection=$.Deferred(),set_objection(function(){if("pending"==objection.state()){var $dialog=$('<div title="Uploading file"><p>Please wait until the upload is finished ...</p><p class="progress"></p></div>'),$progress=$dialog.find("p.progress"),progress=0;return $dialog.dialog({modal:!0,closeOnEscape:!1,resizable:!1,draggable:!1,beforeClose:function(){return!1}}),$progress.progressbar({value:0}),api.get().register({progress:function(data){var updated=0;"uploading"==data.state&&(updated=100*data.received/data.size),updated!=progress&&($progress.progressbar({value:updated}),progress=updated)}}),objection.always(function(){$dialog.dialog("close").remove(),objection=null})}return null})),$cancel.show()},done:function(){$input.attr("value",$field.data("upload-identifier"))},always:function(){null!==objection&&objection.resolve(),$cancel.hide(),upload=null}};return $cancel.on("click",function(){var upload=api.get();null!==upload&&upload.cancel()}),$clear.on("click",function(){var upload=api.get(!0);upload.cancel(),$input.attr("value","")}),api},UploadForm=function($field,identifier,url){var $upload=$('<div style="display:none"><iframe width="0" height="0" style="display:none"src="about:blank" class="upload-iframe" name="upload-'+identifier+'-iframe"></iframe>'+'<form class="upload-form" enctype="multipart/form-data"'+'method="POST" action="'+url+"?"+IDENTIFIER_KEY+"="+identifier+'" target="upload-'+identifier+'-iframe" id="upload-'+identifier+'-form">'+'<input type="reset" class="upload-reset" /></form></div>'),result=$.Deferred().fail(function(){$upload.find(".upload-reset").click(),$upload.find(".upload-iframe").attr("src","javascript:false;")}).always(function(){$upload.remove(),$field.removeAttr("form")}),start=$.Deferred(),api={start:function(){$.ajax({type:"GET",dataType:"jsonp",url:url+"?clear&"+IDENTIFIER_KEY+"="+identifier}).then(function(info){if(info.success)$("body").append($upload),$field.attr("form","upload-"+identifier+"-form"),start.done(function(){api.register(IFrameStatusChecker($upload.find("iframe"),identifier,result)),api.register(PollStatusChecker(url,identifier,result)),$upload.find("form").submit()}).resolve({state:"starting",received:0,size:0});else{var error=info.error||"Unknow error";result.reject({message:"Upload failed ("+error+")."})}},function(){result.reject({message:"Upload failed."})})},cancel:function(){result.reject({})},register:function(plugin){void 0!==plugin.start&&start.done(plugin.start),void 0!==plugin.promise&&plugin.promise().then(function(data){result.resolve(data)},function(data){result.reject(data)});for(var event in{progress:1,done:1,fail:1,always:1})void 0!==plugin[event]&&result[event](plugin[event]);return api}};return api},UploadPopup=function(identifier,url){var $popup=$('<div title="Upload a file"><form class="upload-form" enctype="multipart/form-data"method="POST" action="'+url+"?"+IDENTIFIER_KEY+"="+identifier+'" target="upload-'+identifier+'-iframe" id="upload-'+identifier+'-form">'+'<input type="file" name="file-we-are-uploading" class="upload-file" /></form>'+'<iframe width="0" height="0" style="display:none"'+'src="about:blank" class="upload-iframe" name="upload-'+identifier+'-iframe"></iframe></div>'),result=$.Deferred().fail(function(){$popup.find(".upload-iframe").attr("src","javascript:false;")}).always(function(){$popup.remove()}),start=$.Deferred(),api={start:function(){var send=function(){$.ajax({type:"GET",dataType:"jsonp",url:url+"?clear&"+IDENTIFIER_KEY+"="+identifier}).then(function(info){if(info.success)start.done(function(){$popup.dialog("close"),api.register(IFrameStatusChecker($popup.find("iframe"),identifier,result)),api.register(PollStatusChecker(url,identifier,result)),$popup.find("form").submit()}).resolve({state:"starting",received:0,size:0});else{var error=info.error||"Unknow error";result.reject({message:"Upload failed ("+error+")."})}},function(){result.reject({message:"Upload failed."})})};$popup.find(".upload-file").on("change",function(){send()}),$popup.dialog({buttons:{Send:function(){send()}}})},cancel:function(){result.reject({})},register:function(plugin){void 0!==plugin.start&&start.done(plugin.start),void 0!==plugin.promise&&plugin.promise().then(function(data){result.resolve(data)},function(data){result.reject(data)});for(var event in{progress:1,done:1,fail:1,always:1})void 0!==plugin[event]&&result[event](plugin[event]);return api}};return api},UploadField=DONT_NEED_POPUP?function($field,set_objection){var $trigger=$field.children(".upload-trigger"),$file=$field.find("input.upload-file-input"),ui=UploadUI($field,set_objection,function(){return UploadForm($file,$field.data("upload-identifier"),$field.data("upload-url")).register({start:function(){$file.hide()},always:function(){$file.show()}})});$trigger.remove(),$file.on("change",function(){ui.get(!0).start()})}:function($field,set_objection){var $trigger=$field.children(".upload-trigger"),$file=$field.find("input.upload-file-input"),ui=UploadUI($field,set_objection,function(){return UploadPopup($field.data("upload-identifier"),$field.data("upload-url")).register({start:function(){$trigger.hide()},always:function(){$trigger.show()}})});$file.detach(),$trigger.show(),$trigger.on("click",function(){ui.get(!0).start()})};$(document).on("loadwidget-smiform",".form-fields-container",function(event,data){$(this).find(".upload-file").each(function(){UploadField($(this),data.set_objection)}),event.stopPropagation()})})(jQuery,jsontemplate); | zeam.form.silva | /zeam.form.silva-2.0.5.tar.gz/zeam.form.silva-2.0.5/src/zeam/form/silva/widgets/static/upload.min.js | upload.min.js |
from zeam.form.base.fields import Fields
from zeam.form.base.form import FormCanvas
from zeam.form.base.form import StandaloneForm, cloneFormData
from zeam.form.base.widgets import Widgets
from zeam.form.composed.form import SubFormBase
from zeam.form.table.select import SelectField
from zeam.form.table.actions import TableActions
from zeam.form.table import interfaces
from zeam.utils.batch import Batch, IBatching
from zope.component import queryMultiAdapter
from grokcore import component as grok
from megrok import pagetemplate as pt
from zope.i18nmessageid import MessageFactory
_ = MessageFactory('zeam.form.base')
pt.templatedir('default_templates')
class TableFormCanvas(FormCanvas):
"""A form which is able to edit more than one content as a table.
"""
grok.baseclass()
grok.implements(interfaces.ITableFormCanvas)
batchSize = 0
batchFactory = Batch
batchItemFactory = lambda f, x: x
tableFields = Fields()
tableActions = TableActions()
emptyDescription = _(u"There are no items.")
def __init__(self, context, request):
super(TableFormCanvas, self).__init__(context, request)
self.lines = []
self.lineWidgets = []
self.batching = None
def createSelectedField(self, item):
"""Return a field to select the line.
"""
return SelectField(identifier='select')
def updateLines(self, mark_selected=False):
self.lines = []
self.lineWidgets = []
self.batching = None
items = self.getItems()
if self.batchSize:
items = self.batchFactory(
items,
name=self.prefix,
factory=self.batchItemFactory,
count=self.batchSize,
request=self.request)
self.batching = queryMultiAdapter(
(self.getFormForTable(), items, self.request), IBatching)()
for position, item in enumerate(items):
prefix = '%s.line-%s' % (self.prefix,
self.getItemIdentifier(item, position))
form = cloneFormData(self, content=item, prefix=prefix)
form.selected = False
# Checkbox to select the line
form.selectedField = self.createSelectedField(item)
if mark_selected:
# Mark selected lines
selectedExtractor = form.widgetFactory.extractor(
form.selectedField)
if selectedExtractor is not None:
value, error = selectedExtractor.extract()
if value:
form.selected = True
lineWidget = Widgets(form=form, request=self.request)
lineWidget.extend(form.selectedField)
self.lines.append(form)
self.lineWidgets.append(lineWidget)
def updateActions(self):
form, action, status = self.tableActions.process(self, self.request)
if action is None:
form, action, status = self.actions.process(self, self.request)
return form, action, status
def updateWidgets(self):
self.updateLines()
for widgets in self.lineWidgets:
widgets.extend(self.tableFields)
self.fieldWidgets.extend(self.fields)
self.actionWidgets.extend(self.tableActions)
self.actionWidgets.extend(self.actions)
for widgets in self.lineWidgets:
widgets.update()
self.fieldWidgets.update()
self.actionWidgets.update()
def getItems(self):
return self.context.values()
def getItemIdentifier(self, item, position):
return str(position)
class TableForm(TableFormCanvas, StandaloneForm):
"""A full standalone TableForm.
"""
grok.baseclass()
grok.implements(interfaces.ITableForm)
def getFormForTable(self):
return self
class SubTableForm(SubFormBase, TableFormCanvas):
"""A table form which can be used in a composed form.
"""
grok.baseclass()
grok.implements(interfaces.ISubTableForm)
def getFormForTable(self):
return self.getComposedForm()
class SubTableFormTemplate(pt.PageTemplate):
"""A default template for a SubTableForm
"""
pt.view(SubTableForm) | zeam.form.table | /zeam.form.table-1.1.1.tar.gz/zeam.form.table-1.1.1/src/zeam/form/table/form.py | form.py |
from zeam.form.base.markers import NO_VALUE, SUCCESS, FAILURE, NOTHING_DONE
from zeam.form.base.markers import getValue
from zeam.form.base.actions import Actions
from zeam.form.base.errors import Error
from zeam.form.base.interfaces import IWidgetExtractor, ActionError
from zeam.form.table import interfaces
from zope import component
from zope.i18nmessageid import MessageFactory
_ = MessageFactory('zeam.form.base')
class TableActions(Actions):
"""Actions that can be applied on a table line.
Actions are applied for each selected table line.
"""
def process(self, form, request):
assert interfaces.ITableFormCanvas.providedBy(form)
one_selected = False
ready = False
for action in self:
extractor = component.getMultiAdapter(
(action, form, request), IWidgetExtractor)
value, error = extractor.extract()
if value is not NO_VALUE:
isPostOnly = getValue(action, 'postOnly', form)
if isPostOnly and request.method != 'POST':
form.errors.append(
Error('This form was not submitted properly.',
form.prefix))
return form, None, FAILURE
if not ready:
form.updateLines(mark_selected=True)
ready = True
for line in form.lines:
if not line.selected:
continue
one_selected = True
try:
if action.validate(form):
content = line.getContentData().getContent()
action(form, content, line)
except ActionError, e:
line.errors.append(Error(e.args[0], line.prefix))
if not one_selected:
form.errors.append(
Error(_(u"You didn't select any item!"), None))
return form, action, FAILURE
return form, action, SUCCESS
return form, None, NOTHING_DONE
class TableSelectionActions(Actions):
"""Actions that manage a selection of table lines.
Actions are applied only one time with a list of changes regarding
which lines have been selected and unselected from the original
content selection.
"""
def process(self, form, request):
assert interfaces.ITableFormCanvas.providedBy(form)
selected_lines = []
deselected_lines = []
unchanged_lines = []
# mark selected by request
form.updateLines(mark_selected=True)
for line in form.lines:
data = line.getContentData()
content_selected = data.get(line.selectedField.identifier)
if content_selected:
if line.selected:
unchanged_lines.append(line)
else:
deselected_lines.append(line)
else:
if line.selected:
selected_lines.append(line)
else:
unchanged_lines.append(line)
status = NOTHING_DONE
for action in self:
extractor = component.getMultiAdapter(
(action, form, request), IWidgetExtractor)
value, error = extractor.extract()
if value is NO_VALUE:
continue
isPostOnly = getValue(action, 'postOnly', form)
if isPostOnly and request.method != 'POST':
form.errors.append(
Error('This form was not submitted properly.',
form.prefix))
return form, None, FAILURE
try:
if action.validate(form):
return form, action, action(
form,
selected_lines,
deselected_lines,
unchanged_lines)
except ActionError, e:
form.errors.append(Error(e.args[0], form.prefix))
return form, action, FAILURE
return form, None, status
class TableMultiActions(Actions):
"""Actions that manage multiple table lines.
Actions are applied one time with a list of currently selected and
unselected lines.
"""
def process(self, form, request):
assert interfaces.ITableFormCanvas.providedBy(form)
selected_lines = []
unselected_lines = []
ready = False
for action in self:
extractor = component.getMultiAdapter(
(action, form, request), IWidgetExtractor)
value, error = extractor.extract()
if value is not NO_VALUE:
isPostOnly = getValue(action, 'postOnly', form)
if isPostOnly and request.method != 'POST':
form.errors.append(
Error('This form was not submitted properly.',
form.prefix))
return form, None, FAILURE
if not ready:
form.updateLines(mark_selected=True)
for line in form.lines:
if line.selected:
selected_lines.append(line)
else:
unselected_lines.append(line)
ready = True
try:
if action.validate(form):
return form, action, action(
form,
selected_lines,
unselected_lines)
except ActionError, e:
form.errors.append(Error(e.args[0], form.prefix))
return form, action, FAILURE
return form, None, NOTHING_DONE | zeam.form.table | /zeam.form.table-1.1.1.tar.gz/zeam.form.table-1.1.1/src/zeam/form/table/actions.py | actions.py |
from zeam.form.base.form import FormCanvas
from zeam.form.viewlet.interfaces import IInlineForm
from megrok import pagetemplate as pt
from grokcore import viewlet as grok
pt.templatedir('default_templates')
class ViewletManagerForm(grok.ViewletManager, FormCanvas):
grok.baseclass()
grok.implements(IInlineForm)
i18nLanguage = None
prefix = None
def __init__(self, context, request, view):
grok.ViewletManager.__init__(self, context, request, view)
FormCanvas.__init__(self, context, request)
def update(self):
# We are interested by the viewlet manager feature
# here. should we call super ?
# grok.ViewletManager.update(self)
FormCanvas.update(self)
self.updateForm()
def default_namespace(self):
namespace = super(ViewletManagerForm, self).default_namespace()
namespace['form'] = self
if self.i18nLanguage is not None:
namespace['target_language'] = self.i18nLanguage
return namespace
def updateForm(self):
self.updateActions()
self.updateWidgets()
def render(self):
return FormCanvas.render(self)
render.base_method = True
class ViewletForm(grok.Viewlet, FormCanvas):
"""A form as a viewlet.
"""
grok.baseclass()
grok.implements(IInlineForm)
i18nLanguage = None
def __init__(self, context, request, view, manager):
grok.Viewlet.__init__(self, context, request, view, manager)
FormCanvas.__init__(self, context, request)
def update(self):
grok.Viewlet.update(self)
FormCanvas.update(self)
self.updateForm()
def default_namespace(self):
namespace = super(ViewletForm, self).default_namespace()
namespace['form'] = self
if self.i18nLanguage is not None:
namespace['target_language'] = self.i18nLanguage
return namespace
def updateForm(self):
self.updateActions()
self.updateWidgets()
def render(self):
return FormCanvas.render(self)
render.base_method = True
class FormTemplate(pt.PageTemplate):
"""Default tempalte for ViewletForm
"""
pt.view(IInlineForm) | zeam.form.viewlet | /zeam.form.viewlet-1.2.1.tar.gz/zeam.form.viewlet-1.2.1/src/zeam/form/viewlet/form.py | form.py |
=============
zeam.form.ztk
=============
``zeam.form.ztk`` help you to integrate `zeam.form.base`_ with the
Zope Tool Kit. It provides:
- Form fields generation out of zope.schema fields, and zope.schema
fields listed in a Zope interface,
- Widgets for those fields,
- Default action to Add, Edit a content, Cancel a current action by
returning on the default view of a content.
Like `zeam.form.base`_ the focus is to have an API usable by the
developer, not a support of theorical use-cases that you don't need.
.. contents::
Example
=======
Let's create a form to edit a content. Here we have an interface for
our content::
from zope import schema, interface
class IClan(interface.Interface):
pass
class IPerson(interface.Interface):
first_name = schema.TextLine(title=u"First Name")
last_name = schema.TextLine(title=u"Last Name")
age = schema.Int(title=u"Age", required=False)
single = schema.Bool(title=u"Is single ?", default=True)
We assume that a Person is in a Clan. We can implement a Person::
from persistence import Persistent
class Person(Persistent):
interface.implements(IPerson)
first_name = None
last_name = None
age = None
single = True
Add form
--------
You can add a new Person in a clan like this::
import zeam.form.ztk as form
class Add(form.Form):
form.context(IClan)
label = u"New person"
fields = form.Fields(IPerson)
actions = form.Actions(
form.AddAction("Add", factory=Person),
form.CancelAction("Cancel"))
actions['add'].fieldName = 'last_name'
Edit form
---------
You can edit a Person like this::
class Edit(form.Form):
form.context(IPerson)
label = u"Change person details"
fields = form.Fields(IPerson)
actions = form.Actions(
form.EditAction("Update"),
form.CancelAction("Cancel"))
ignoreContent = False
API
===
All the API of ``zeam.form.base`` is exported as well.
Actions
-------
``AddAction``
Action which take an extra parameter, factory, to create an object
stored on the content object. The created object is added with the
help of ``INameChooser`` to get its identifier. The option
``fieldName`` will be used to lookup a value in the form data to
give as potential identifier to ``INameChooser``. Afterwards the
created object is edited (like EditAction does) with the form data.
``EditAction``
Action which use the form data to change values on the content
object, designated by the form fields, after validation of the form
submission.
``CancelAction``
Simple action which return on default view of the content without
validating the form submission.
Fields
------
Currently supported fields:
- Date, Datetime: generate a text line input and parse/display the
date using the locale,
- TextLine, Text, Boolean, URI, Email, and numbers (Int, Float ...),
- Password,
- Choice: generate a select or a radio boxes (widget mode ``radio``),
- Object,
- Collections: List, Set, Tuple in input and display mode:
- Collection of choices: generate a widget with a list of checkboxes,
- Collection of objects: generate a table to edit multiple objects,
- Other collection: generate a widget with generic add an remove actions.
For more documentation, please report to the doctests included in the code.
.. _zeam.form.base: http://pypi.python.org/pypi/zeam.form.base
| zeam.form.ztk | /zeam.form.ztk-1.4.0.tar.gz/zeam.form.ztk-1.4.0/README.txt | README.txt |
from zope import interface
from zope.schema.interfaces import ISource
from zeam.form.base.interfaces import IField, IZeamFormBaseAPI
class IFormSourceBinder(ISource):
"""Marker interface used with zope.schema Choice in order to give
a factory that takes the source.
"""
class ISchemaField(IField):
"""This is a field for zope schema field.
"""
def fromUnicode(value):
"""This convert a value from a unicode string (or not).
"""
class IFieldCreatedEvent(interface.Interface):
"""A zeam.form Field have been created (out of a zope.schema
Field).
"""
field = interface.Attribute(
u"Created field")
interface = interface.Attribute(
u"Interface on which the field have been crated")
class ICollectionField(IField):
"""This is a field for zope schema collection field. It is defined
in order to be able to have a generic behavior on collections.
"""
collectionType = interface.Attribute(
u"Python type represented by this collection (like set, list...)")
valueField = interface.Attribute(
u"Field corresponding to the value type contained in the collection")
allowAdding = interface.Attribute(
u"Boolean flag to allow adding of values to the collection")
allowRemove = interface.Attribute(
u"Boolean flag to allow removing of values from the collection")
inlineValidation = interface.Attribute(
u"Boolean flag to validate data when a value is added or removed")
class IListField(ICollectionField):
"""This is a field for zope schema list field.
"""
allowOrdering = interface.Attribute(
u"Boolean flag to allow ordering of values")
class IObjectField(IField):
"""This field is mapped to the zope.schema Object schema field.
"""
objectFactory = interface.Attribute(
u"Default factory used to create new objects for the field")
objectSchema = interface.Attribute(
u"Zope Interface that should be implemented by the object")
objectFields = interface.Attribute(
u"Zeam fields for the object")
def getObjectFactory():
"""Return the object factory used to create new objects for
the field.
"""
class IZeamFormZTKAPI(IZeamFormBaseAPI):
"""API exported by zeam.form.ztk.
"""
customize = interface.Attribute(
u"Decorator used to customize created fields")
AddAction = interface.Attribute(
u"Action to add a new content to one other")
EditAction = interface.Attribute(
u"Action to edit the values of a content")
CancelAction = interface.Attribute(
u"Action to cancel the submission of the form") | zeam.form.ztk | /zeam.form.ztk-1.4.0.tar.gz/zeam.form.ztk-1.4.0/src/zeam/form/ztk/interfaces.py | interfaces.py |
import sys
import martian
from martian.util import frame_is_module
from martian.error import GrokImportError
from zope.event import subscribers
from zope.interface.adapter import AdapterRegistry
from zope.interface import providedBy, implementedBy, Interface
from zeam.form.ztk.interfaces import IFieldCreatedEvent
class CustomizationRegistry(object):
"""Register and execute customization handlers.
"""
def __init__(self):
self._scheduled = False
self._events = []
self._origin = AdapterRegistry()
self._field = AdapterRegistry()
subscribers.append(self.watch)
def watch(self, *events):
if len(events) > 0 and IFieldCreatedEvent.providedBy(events[0]):
self._events.append(events[0])
def register(self, handler, options):
if 'origin' in options:
self._origin.register(
(options['origin'], options.get('schema')),
Interface,
options.get('name', u''),
handler)
elif 'field' in options:
self._field.register(
(options['field'], options.get('schema')),
Interface,
options.get('name', u''),
handler)
elif 'schema' in options:
self._origin.register(
(Interface, options['schema']),
Interface,
options.get('name', u''),
handler)
else:
raise AssertionError('Invalid customization')
def execute(self, clear=True):
for event in self._events:
handler = None
if event.origin is not None:
# 1. Lookup customization with the original field
required = (providedBy(event.origin), event.interface)
# 1.a Original field and name
handler = self._origin.lookup(
required, Interface, event.field.identifier)
if handler is None:
# 1.b Original field without name
handler = self._origin.lookup(required, Interface)
if handler is not None:
handler(event.field)
if handler is None:
# 2. No customization found, lookup with the zeam.form field
required = (providedBy(event.field), event.interface)
# 2.a zeam.form field and name
handler = self._field.lookup(
required, Interface, event.field.identifier)
if handler is None:
# 2.b zeam.form field without name
handler = self._field.lookup(required, Interface)
if handler is not None:
handler(event.field)
if clear:
del self._events[:]
self._scheduled = False
def schedule(self, config):
if not self._scheduled:
config.action(
discriminator=('customize fields',),
callable=self.execute,
args=tuple(),
order=sys.maxint-1)
self._scheduled = True
registry = CustomizationRegistry()
class customize:
def __init__(self, origin=None, schema=None, field=None, name=u''):
self.options = {'origin': origin, 'schema': schema,
'field':field, 'name': name}
def __call__(self, handler):
frame = sys._getframe(1)
if not frame_is_module(frame):
raise GrokImportError(
'@customize can only be used on module level')
if not self.options:
raise GrokImportError(
'@customize options are missing')
customizations = frame.f_locals.get(
'__zeam_form_customizations__', None)
if customizations is None:
frame.f_locals['__zeam_form_customizations__'] = customizations = []
customizations.append((handler, self.options))
return handler
class CustomizationGrokker(martian.GlobalGrokker):
def grok(self, name, module, module_info, config, *kw):
customizations = module_info.getAnnotation(
'zeam.form.customizations', [])
if customizations:
for customization in customizations:
registry.register(customization[0], customization[1])
registry.schedule(config)
return True
return False | zeam.form.ztk | /zeam.form.ztk-1.4.0.tar.gz/zeam.form.ztk-1.4.0/src/zeam/form/ztk/customizations.py | customizations.py |
from zeam.form.base import Action
from zeam.form.base.datamanager import ObjectDataManager
from zeam.form.base.markers import NO_CHANGE, SUCCESS, FAILURE
from zope.container.interfaces import INameChooser
from zope.event import notify
from zope.i18nmessageid import MessageFactory
from zope.lifecycleevent import ObjectCreatedEvent, ObjectModifiedEvent
_ = MessageFactory("zeam.form.base")
class CancelAction(Action):
"""Cancel the current form and return on the default content view.
"""
def __call__(self, form):
form.redirect(form.url())
class EditAction(Action):
"""Edit the form content using the form fields.
"""
def applyData(self, form, content, data):
for field in form.fields:
value = data.getWithDefault(field.identifier, default=NO_CHANGE)
if value is not NO_CHANGE:
content.set(field.identifier, value)
def __call__(self, form):
data, errors = form.extractData()
if errors:
return FAILURE
content = form.getContentData()
self.applyData(form, content, data)
notify(ObjectModifiedEvent(content.content))
form.status = _(u"Modification saved.")
return SUCCESS
class AddAction(EditAction):
"""Add a new content in the form content, saving the form fields
on the newly created content.
"""
fieldName = 'title'
def __init__(self, title, factory):
super(AddAction, self).__init__(title)
self.factory = factory
def create(self, form, data):
content = self.factory()
self.applyData(form, ObjectDataManager(content), data)
notify(ObjectCreatedEvent(content))
return content
def add(self, form, content, data):
container = form.getContent()
default_name = None
if self.fieldName is not None:
default_name = getattr(content, self.fieldName)
chooser = INameChooser(container)
name = chooser.chooseName(default_name, content)
container[name] = content
def nextURL(self, form, content):
return form.url(content)
def __call__(self, form):
data, errors = form.extractData()
if errors:
return FAILURE
content = self.create(form, data)
self.add(form, content, data)
form.redirect(self.nextURL(form, content))
return SUCCESS | zeam.form.ztk | /zeam.form.ztk-1.4.0.tar.gz/zeam.form.ztk-1.4.0/src/zeam/form/ztk/actions.py | actions.py |
from zeam.form.base import interfaces
from zeam.form.base.fields import Field as BaseField
from zeam.form.base.markers import NO_VALUE
from zeam.form.base.widgets import FieldWidget, WidgetExtractor
from zeam.form.ztk.interfaces import ISchemaField, IFieldCreatedEvent
from grokcore import component as grok
from zope import schema, component
from zope.event import notify
from zope.i18nmessageid import MessageFactory
from zope.interface import Interface, Invalid, implementer
from zope.schema import interfaces as schema_interfaces
from zope.schema._bootstrapinterfaces import IContextAwareDefaultFactory
import zope.interface.interfaces
_ = MessageFactory("zeam.form.base")
@implementer(IFieldCreatedEvent)
class FieldCreatedEvent:
def __init__(self, field, interface=None, origin=None):
self.interface = interface
self.field = field
self.origin = origin
@implementer(interfaces.IFieldFactory)
class SchemaFieldFactory:
"""Create form fields from a zope.schema field (by adapting it).
"""
def __init__(self, context):
self.context = context
def produce(self):
interface = self.context.interface
if interface is None and not getattr(self.context, '__name__', None):
raise AssertionError("Field has no interface or __name__")
result = interfaces.IField(self.context)
notify(FieldCreatedEvent(result, interface, self.context))
yield result
@implementer(interfaces.IFieldFactory)
class InterfaceSchemaFieldFactory:
"""Create a set of form fields from a zope.interface by looking
each zope.schema fields defined on it and adapting them.
"""
def __init__(self, context):
self.context = context
def produce(self):
for name, field in schema.getFieldsInOrder(self.context):
result = interfaces.IField(field)
notify(FieldCreatedEvent(result, self.context, field))
yield result
class Field(BaseField):
def getDefaultValue(self, form):
if self.defaultFactory is not None:
if IContextAwareDefaultFactory.providedBy(self.defaultFactory):
if form is None:
raise TypeError('defaultFactory context required.')
default = self.defaultFactory(form.getContent())
else:
default = self.defaultFactory()
else:
default = super(Field, self).getDefaultValue(form)
if default is NO_VALUE:
default = self.defaultValue
if default is None:
return NO_VALUE
return default
@implementer(ISchemaField)
class SchemaField(BaseField):
"""A form field using a zope.schema field as settings.
"""
def __init__(self, field):
super(SchemaField, self).__init__(
field.title or None, field.__name__,
description=field.description,
required=field.required,
readonly=field.readonly,
interface=field.interface)
self._field = field
def get_field(self):
return self._field
def clone(self, new_identifier=None):
copy = self.__class__(self._field)
copy.__dict__.update(self.__dict__)
if new_identifier is not None:
copy.identifier = new_identifier
return copy
def validate(self, value, form):
error = super(SchemaField, self).validate(value, form)
if error is not None:
return error
if value is not NO_VALUE:
context = None
if form is not None:
context = form.context
try:
binded_field = self._field.bind(context)
binded_field.validate(value)
except schema_interfaces.ValidationError as error:
return error.doc()
except Invalid as error:
return error.args[0]
return None
def fromUnicode(self, value):
if schema_interfaces.IFromUnicode.providedBy(self._field):
return self._field.fromUnicode(value)
return value
def getDefaultValue(self, form):
default = super(SchemaField, self).getDefaultValue(form)
if default is not NO_VALUE:
return default
default = self._field.default
if default is None: # Zope schema use None to say no default
return NO_VALUE
return default
def registerSchemaField(factory, schema_field):
# We register it by hand to have the adapter available when loading ZCML.
component.provideAdapter(factory, (schema_field,), interfaces.IField)
class SchemaFieldWidget(FieldWidget):
grok.adapts(ISchemaField, Interface, Interface)
def htmlClass(self):
css_class = ['field']
if ISchemaField.providedBy(self.component):
# Prevent old FieldWidget to fail if they haven't been
# updated to the new API.
css_class.append('field-%s' % (
self.component._field.__class__.__name__.lower()))
if self.required:
css_class.append('field-required')
return ' '.join(css_class)
class SchemaWidgetExtractor(WidgetExtractor):
grok.adapts(ISchemaField, Interface, Interface)
def extract(self):
value, error = super(SchemaWidgetExtractor, self).extract()
if error is not None:
return value, error
if value is not NO_VALUE:
try:
value = self.component.fromUnicode(value)
except schema_interfaces.ValidationError as e:
return None, e.doc()
except Invalid as e:
return None, e.args[0]
except ValueError as e:
return None, _(u"Invalid value.")
return value, None
class HiddenSchemaWidgetExtractor(SchemaWidgetExtractor):
grok.name('hidden')
class ReadOnlySchemaWidgetExtractor(SchemaWidgetExtractor):
grok.name('readonly')
def registerDefault():
"""Register default fields factories.
"""
component.provideAdapter(
SchemaFieldFactory,
(zope.schema.interfaces.IField,))
component.provideAdapter(
InterfaceSchemaFieldFactory,
(zope.interface.interfaces.IInterface,))
registerSchemaField(SchemaField, schema_interfaces.IField) | zeam.form.ztk | /zeam.form.ztk-1.4.0.tar.gz/zeam.form.ztk-1.4.0/src/zeam/form/ztk/fields.py | fields.py |
try:
import hashlib
md5hash = lambda s: hashlib.md5(s).hexdigest()
except ImportError:
import md5
md5hash = lambda s: md5.new(s).hexdigest()
try:
# If you have the fanstatic extra, add support to include widget JS
import fanstatic
import js.jquery
import zeam.jsontemplate
library = fanstatic.Library('zeam.form.ztk.widgets', 'static')
collection = fanstatic.Resource(
library, 'collection.js', depends=[js.jquery.jquery,
zeam.jsontemplate.jsontemplate])
requireCollectionResources = collection.need
except ImportError:
class Library(object):
name = ""
def init_library_nr(self):
pass
@property
def library_nr(self):
return 20000
@property
def known_assets(self):
return []
library = Library()
requireCollectionResources = lambda: None
from zeam.form.base.datamanager import NoneDataManager
from zeam.form.base.errors import Errors, Error
from zeam.form.base.fields import Fields
from zeam.form.base.markers import Marker
from zeam.form.base.form import cloneFormData
from zeam.form.base.interfaces import IField, IWidget, IWidgetExtractor
from zeam.form.base.markers import NO_VALUE
from zeam.form.base.widgets import WidgetExtractor, FieldWidget, Widgets
from zeam.form.ztk.fields import Field, registerSchemaField
from zeam.form.ztk.interfaces import ICollectionField, IListField
from zeam.form.ztk.widgets.choice import ChoiceField, ChoiceFieldWidget
from zeam.form.ztk.widgets.object import ObjectField
from grokcore import component as grok
from zope import component
from zope.i18nmessageid import MessageFactory
from zope.interface import Interface, implementer
from zope.schema import interfaces as schema_interfaces
_ = MessageFactory("zeam.form.base")
@implementer(ICollectionField)
class CollectionField(Field):
"""A collection field.
"""
collectionType = list
allowAdding = True
allowRemove = True
inlineValidation = False
def __init__(self, title,
valueField=None,
minLength=0,
maxLength=None,
**options):
super(CollectionField, self).__init__(title, **options)
self._valueField = IField(valueField, None)
self.minLength = minLength
self.maxLength = maxLength
@property
def valueField(self):
return self._valueField
def validate(self, value, form):
error = super(CollectionField, self).validate(value, form)
if error is not None:
return error
if not isinstance(value, Marker):
assert isinstance(value, self.collectionType)
if self.minLength and len(value) < self.minLength:
return _(u"There are too few items.")
if self.maxLength and len(value) > self.maxLength:
return _(u"There are too many items.")
return None
def isEmpty(self, value):
return value is NO_VALUE or not len(value)
# BBB
CollectionSchemaField = CollectionField
@implementer(IListField)
class ListField(CollectionField):
"""A list field
"""
collectionType = list
allowOrdering = True
# BBB
ListSchemaField = ListField
class SetField(CollectionField):
"""A set field
"""
collectionType = set
# BBB
SetSchemaField = SetField
class TupleField(CollectionField):
"""A tuple field.
"""
collectionType = tuple
# BBB
TupleSchemaField = TupleField
def newCollectionWidgetFactory(mode=u"", interface=IWidget):
def collectionWidgetFactory(field, form, request):
"""A widget of a collection is a bit advanced. We have to adapt
the sub-type of the field as well.
"""
widget = component.getMultiAdapter(
(field, field.valueField, form, request), interface, name=mode)
return widget
return collectionWidgetFactory
grok.global_adapter(
newCollectionWidgetFactory(mode='input'),
adapts=(ICollectionField, Interface, Interface),
provides=IWidget,
name='input')
grok.global_adapter(
newCollectionWidgetFactory(mode='input-list'),
adapts=(ICollectionField, Interface, Interface),
provides=IWidget,
name='input-list')
grok.global_adapter(
newCollectionWidgetFactory(mode='display'),
adapts=(ICollectionField, Interface, Interface),
provides=IWidget,
name='display')
grok.global_adapter(
newCollectionWidgetFactory(interface=IWidgetExtractor),
adapts=(ICollectionField, Interface, Interface),
provides=IWidgetExtractor)
class MultiGenericFieldWidget(FieldWidget):
grok.adapts(ICollectionField, Interface, Interface, Interface)
allowAdding = True
allowRemove = True
inlineValidation = False
def __init__(self, field, value_field, form, request):
super(MultiGenericFieldWidget, self).__init__(field, form, request)
self.allowAdding = field.allowAdding
self.allowRemove = field.allowRemove
self.inlineValidation = field.inlineValidation
self.valueField = value_field
self.valueWidgets = Widgets()
self.haveValues = False
def createValueWidget(self, new_identifier, value):
field = self.valueField.clone(new_identifier=str(new_identifier))
form = cloneFormData(self.form, prefix=self.identifier)
if value is not None:
form.ignoreContent = False
form.setContentData(NoneDataManager(value))
else:
form.ignoreRequest = False
form.ignoreContent = True
return form.widgetFactory.widget(field)
def addValueWidget(self, new_identifier, value):
widget = self.createValueWidget(new_identifier, value)
if widget is not None:
self.valueWidgets.append(widget)
return widget
def prepareContentValue(self, values):
count = 0
if values is not NO_VALUE:
for position, value in enumerate(values):
# Create new widgets for each value
self.addValueWidget(position, value)
count += len(values)
if self.allowAdding and self.required and not count:
self.addValueWidget(count, None)
count += 1
if count:
self.haveValues = True
return {self.identifier: str(count)}
def prepareRequestValue(self, values, extractor):
value_count = 0
errors = None
identifier_count = int(values.get(self.identifier, '0'))
remove_something = self.identifier + '.remove' in values
add_something = self.identifier + '.add' in values
if self.inlineValidation:
# If inlineValidation is on, and we removed or added
# something, we extract this field to get the
# validation messages right away (if the user clicked
# on add or remove, he cannot have clicked on an
# action button)
if add_something or remove_something:
ignored, errors = extractor.extract()
if errors:
self.form.errors.append(errors)
for position in range(0, identifier_count):
value_marker = (self.identifier, position,)
value_present = '%s.present.%d' % value_marker in values
if not value_present:
continue
value_identifier = '%s.field.%d' % value_marker
value_selected = '%s.checked.%d' % value_marker in values
if remove_something and value_selected:
if errors and value_identifier in errors:
# If the field have an error, remove it
del errors[value_identifier]
continue
# We need to provide the widget error now, but cannot set
# all of them on the form now, as we might remove them
# with delete
self.addValueWidget(position, None)
value_count += 1
if (add_something or
(self.allowAdding and self.required and not value_count)):
self.addValueWidget(identifier_count, None)
value_count += 1
values[self.identifier] = str(identifier_count + 1)
if value_count:
self.haveValues = True
if errors:
if len(errors) > 1:
self.form.errors.append(
Error(_(u"There were errors."), self.form.prefix))
else:
# If no errors are left, remove from the form (top level error)
del self.form.errors[self.identifier]
return values
@property
def jsonTemplateWidget(self):
widgets = Widgets()
widgets.append(self.createValueWidget('{identifier}', None))
widgets.update()
return list(widgets)[0]
def update(self):
super(MultiGenericFieldWidget, self).update()
self.valueWidgets.update()
requireCollectionResources()
self.jsonAddIdentifier = None
self.jsonAddTemplate = None
self.includeEmptyMessage = self.allowRemove
if self.allowAdding:
self.jsonAddIdentifier = 'id' + md5hash(
self.identifier.encode('utf-8'))
widgets = Widgets()
widgets.append(self.createValueWidget(
'{' + self.jsonAddIdentifier + '}', None))
widgets.update()
self.jsonAddTemplate = list(widgets)[0]
class ListGenericFieldWidget(MultiGenericFieldWidget):
grok.adapts(ListField, Interface, Interface, Interface)
def __init__(self, field, value_field, form, request):
super(ListGenericFieldWidget, self).__init__(
field, value_field, form, request)
self.allowOrdering = field.allowOrdering
class MultiGenericDisplayFieldWidget(MultiGenericFieldWidget):
grok.name('display')
# For collection of objects, generate a different widget (with a table)
class MultiObjectFieldWidget(MultiGenericFieldWidget):
grok.adapts(ICollectionField, ObjectField, Interface, Interface)
def getFields(self):
return self.valueField.objectFields
class ListObjectFieldWidget(MultiObjectFieldWidget):
grok.adapts(ListField, ObjectField, Interface, Interface)
def __init__(self, field, value_field, form, request):
super(ListObjectFieldWidget, self).__init__(
field, value_field, form, request)
self.allowOrdering = field.allowOrdering
# Still make possible to have the non-table implementation
class RegularMultiObjectFieldWidget(MultiGenericFieldWidget):
grok.adapts(ICollectionField, ObjectField, Interface, Interface)
grok.name('input-list')
class RegularListObjectFieldWidget(ListGenericFieldWidget):
grok.adapts(ListField, ObjectField, Interface, Interface)
grok.name('input-list')
class MultiGenericWidgetExtractor(WidgetExtractor):
grok.adapts(ICollectionField, Interface, Interface, Interface)
def __init__(self, field, value_field, form, request):
super(MultiGenericWidgetExtractor, self).__init__(
field, form, request)
self.valueField = value_field
def extract(self):
value = self.request.form.get(self.identifier, NO_VALUE)
if value is not NO_VALUE:
try:
value = int(value)
except ValueError:
return (None, u"Invalid internal input")
collectedValues = []
collectedErrors = Errors(identifier=self.identifier)
for position in range(0, value):
value_present = '%s.present.%d' % (
self.identifier, position) in self.request.form
if not value_present:
# This value have been removed
continue
field = self.valueField.clone(new_identifier=str(position))
form = cloneFormData(self.form, prefix=self.identifier)
data, errors = form.extractData(Fields(field))
if errors:
collectedErrors.extend(errors)
else:
collectedValues.append(data[field.identifier])
if collectedErrors:
return (None, collectedErrors)
value = self.component.collectionType(collectedValues)
return (value, None)
# Multi-Choice widget
class MultiChoiceFieldWidget(ChoiceFieldWidget):
grok.adapts(SetField, ChoiceField, Interface, Interface)
defaultHtmlClass = ['field', 'field-multichoice']
def __init__(self, field, value_field, form, request):
super(MultiChoiceFieldWidget, self).__init__(field, form, request)
self.source = value_field
def prepareContentValue(self, value):
form_value = []
if value is NO_VALUE:
return {self.identifier: form_value}
choices = self.choices()
for entry in value:
try:
term = choices.getTerm(entry)
form_value.append(term.token)
except LookupError:
pass
return {self.identifier: form_value}
def renderableChoice(self):
current = self.inputValue()
base_id = self.htmlId()
for i, choice in enumerate(self.choices()):
yield {'token': choice.token,
'title': choice.title,
'checked': choice.token in current,
'id': base_id + '-' + str(i)}
grok.global_adapter(
newCollectionWidgetFactory(mode='multiselect'),
adapts=(ICollectionField, Interface, Interface),
provides=IWidget,
name='multiselect')
class MultiSelectFieldWidget(MultiChoiceFieldWidget):
grok.name('multiselect')
class MultiChoiceDisplayFieldWidget(MultiChoiceFieldWidget):
grok.name('display')
def renderableChoice(self):
current = self.inputValue()
base_id = self.htmlId()
for i, choice in enumerate(self.choices()):
if choice.token in current:
yield {'title': choice.title,
'id': base_id + '-' + str(i)}
class MultiChoiceWidgetExtractor(WidgetExtractor):
grok.adapts(SetField, ChoiceField, Interface, Interface)
def __init__(self, field, value_field, form, request):
super(MultiChoiceWidgetExtractor, self).__init__(field, form, request)
self.source = value_field
def extract(self):
value, errors = super(MultiChoiceWidgetExtractor, self).extract()
if errors is None:
is_present = self.request.form.get(
self.identifier + '.present', NO_VALUE)
if is_present is NO_VALUE:
# Not in the request
return (NO_VALUE, None)
if value is NO_VALUE:
# Nothing selected
return (self.component.collectionType(), None)
choices = self.source.getChoices(self.form)
try:
if not isinstance(value, list):
value = [value]
value = self.component.collectionType(
[choices.getTermByToken(t).value for t in value])
except LookupError:
return (None, _(u'The selected value is not available.'))
return (value, errors)
def makeCollectionSchemaFactory(factory):
def CollectionSchemaFactory(schema):
field = factory(
schema.title or None,
identifier=schema.__name__,
description=schema.description,
required=schema.required,
readonly=schema.readonly,
minLength=schema.min_length,
maxLength=schema.max_length,
valueField=schema.value_type,
interface=schema.interface,
constrainValue=schema.constraint,
defaultFactory=schema.defaultFactory,
defaultValue=schema.__dict__['default'] or NO_VALUE)
return field
return CollectionSchemaFactory
def register():
registerSchemaField(
makeCollectionSchemaFactory(CollectionField),
schema_interfaces.ICollection)
registerSchemaField(
makeCollectionSchemaFactory(ListField),
schema_interfaces.IList)
registerSchemaField(
makeCollectionSchemaFactory(SetField),
schema_interfaces.ISet)
registerSchemaField(
makeCollectionSchemaFactory(TupleField),
schema_interfaces.ITuple) | zeam.form.ztk | /zeam.form.ztk-1.4.0.tar.gz/zeam.form.ztk-1.4.0/src/zeam/form/ztk/widgets/collection.py | collection.py |
import zeam.form.ztk.compat
from zeam.form.base.fields import Field
from zeam.form.base.widgets import FieldWidget
from zeam.form.ztk.fields import registerSchemaField
from zeam.form.base.markers import Marker, NO_VALUE
from grokcore import component as grok
from zope.i18nmessageid import MessageFactory
from zope.interface import Interface
_ = MessageFactory("zeam.form.base")
rfc822_specials = '()<>@,;:\\"[]'
def isMailAddress(addr):
"""Returns True if the email address is valid and False if not."""
# First we validate the name portion (name@domain)
c = 0
while c < len(addr):
if addr[c] == '@':
break
# Make sure there are only ASCII characters
if ord(addr[c]) <= 32 or ord(addr[c]) >= 127:
return False
# A RFC-822 address cannot contain certain ASCII characters
if addr[c] in rfc822_specials:
return False
c = c + 1
# check whether we have any input and that the name did not end with a dot
if not c or addr[c - 1] == '.':
return False
# check also starting and ending dots in (name@domain)
if addr.startswith('.') or addr.endswith('.'):
return False
# Next we validate the domain portion (name@domain)
domain = c = c + 1
# Ensure that the domain is not empty (name@)
if domain >= len(addr):
return False
count = 0
while c < len(addr):
# Make sure that domain does not end with a dot or has two dots in a row
if addr[c] == '.':
if c == domain or addr[c - 1] == '.':
return False
count = count + 1
# Make sure there are only ASCII characters
if ord(addr[c]) <= 32 or ord(addr[c]) >= 127:
return False
# A RFC-822 address cannot contain certain ASCII characters
if addr[c] in rfc822_specials:
return False
c = c + 1
if count >= 1:
return True
return False
class EmailField(Field):
def __init__(self, title,
minLength=0,
maxLength=None,
**options):
super(EmailField, self).__init__(title, **options)
self.minLength = minLength
self.maxLength = maxLength
def isEmpty(self, value):
return value is NO_VALUE or not len(value)
def validate(self, value, form):
error = super(EmailField, self).validate(value, form)
if error is not None:
return error
if not isinstance(value, Marker) and len(value):
assert isinstance(value, zeam.form.ztk.compat.string_types)
if not isMailAddress(value):
return _(u"This email is not valid.")
if self.minLength and len(value) < self.minLength:
return _(u"This email is too short.")
if self.maxLength and len(value) > self.maxLength:
return _(u"This email is too long.")
return None
class EmailWidget(FieldWidget):
grok.adapts(EmailField, Interface, Interface)
defaultHtmlClass = ['field', 'field-email']
defaultHtmlAttributes = set(['readonly', 'required', 'autocomplete',
'maxlength', 'pattern', 'placeholder',
'size', 'style'])
class EmailDisplayWidget(FieldWidget):
grok.adapts(EmailField, Interface, Interface)
grok.name('display')
def EmailSchemaFactory(schema):
field = EmailField(
schema.title or None,
identifier=schema.__name__,
description=schema.description,
required=schema.required,
readonly=schema.readonly,
minLength=schema.min_length,
maxLength=schema.max_length,
interface=schema.interface,
constrainValue=schema.constraint,
defaultValue=schema.default or NO_VALUE)
return field
try:
from z3c.schema.email.interfaces import IRFC822MailAddress
def register():
registerSchemaField(EmailSchemaFactory, IRFC822MailAddress)
except ImportError:
def register():
pass | zeam.form.ztk | /zeam.form.ztk-1.4.0.tar.gz/zeam.form.ztk-1.4.0/src/zeam/form/ztk/widgets/email.py | email.py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.