class CoreUserProfileFullEditForm(EditProfileForm):
first_name = forms.CharField(max_length=100)
last_name = forms.CharField(max_length=100)
responsibility = forms.ModelMultipleChoiceField(queryset=Responsibility.objects.all().order_by('name'))
state = forms.ModelChoiceField(queryset=State.objects.filter(country=1))
state_hometown = forms.ModelChoiceField(queryset=State.objects.filter(country=1))
city_hometown = forms.ModelChoiceField(queryset='')
def __init__(self, user=None, data_model=None, *args, **kwargs):
super(CoreUserProfileFullEditForm, self).__init__(user, data_model, *args, **kwargs)
if self.data and 'state_hometown' in self.data:
self.fields['city_hometown'].queryset = City.objects.filter(state=self.data['state_hometown'])
def is_valid(self):
is_valid = super(CoreUserProfileFullEditForm, self).is_valid()
return is_valid
@transaction.atomic()
def __process__(self):
process_profile = super(CoreUserProfileFullEditForm, self).__process__()
process_user = BusinessUserProfile.update_user(self.user, data={
'first_name': self.cleaned_data['first_name'],
'last_name': self.cleaned_data['last_name']
})
process_occupation = BusinessUserProfile.update_or_create_occupation(profile=process_profile, responsibilities=self.cleaned_data.get('responsibility'))
return process_profile if (process_profile and process_occupation and process_user) else False
class ComplaintForm(IdeiaForm):
description = forms.CharField(max_length=512, required=False)
complaint_type = forms.ModelChoiceField(queryset=Business.get_type_complaint(), required=True)
content_type = forms.CharField(max_length=20, required=True)
object_id = forms.IntegerField(required=True)
community_complaint = forms.ModelMultipleChoiceField(queryset=Community.objects.all(), required=False)
def __init__(self, user=None, *args, **kwargs):
super(ComplaintForm, self).__init__(*args, **kwargs)
self.user = user
def is_valid(self):
valid = super(ComplaintForm, self).is_valid()
try:
entity_to_complaint = settings.ENTITY_TO_COMPLAINT
except AttributeError:
entity_to_complaint = False
if not entity_to_complaint or self.cleaned_data['content_type'] not in entity_to_complaint:
self.add_error(None,
ValidationError(('Content Type is not specified.'),
code='content_is_not_specified'))
valid = False
return valid
def __process__(self):
return Business.create_complaint(parameters=self.cleaned_data, user=self.user)
class RecoveryPasswordForm(IdeiaForm):
new_password = forms.CharField(max_length=30, required=True)
new_password_confirmation = forms.CharField(max_length=30, required=True)
def __init__(self, token=None, *args, **kwargs):
self.token = token
super(RecoveryPasswordForm, self).__init__(*args, **kwargs)
def is_valid(self):
valid = super(RecoveryPasswordForm, self).is_valid()
if 'new_password' in self.cleaned_data and 'new_password_confirmation' in self.cleaned_data and \
self.cleaned_data['new_password'] != self.cleaned_data['new_password_confirmation']:
self.add_error(
'new_password_confirmation',
ValidationError(_('Passwords are not the same.'),
code='new_password_confirmation'))
valid = False
if not self.token or not self.token.is_valid():
self.add_error(
'password',
ValidationError(_('Token is no longer valid.'),
code='password'))
valid = False
return valid
def __process__(self):
return Business.recovery_password(self.token,
self.cleaned_data['new_password'])
class NotificationSend(SearchNotificationSubscribe):
title = forms.CharField(required=True)
message = forms.CharField(required=True, widget=forms.Textarea)
url = forms.URLField(required=True)
def __process__(self):
queryset = self._get_queryset()
title = self.cleaned_data['title']
message = self.cleaned_data['message']
url = self.cleaned_data['url']
icon_url = "https://www.portalgsti.com.br/static/images/favicon-96x96.png"
icon_url = generate_url(icon_url, width=60, height=60)
per_page = 25
seconds = 0
batch = 3
paginated = paginator.Paginator(queryset, per_page)
for index, page in enumerate(paginated.page_range):
send_queryset = self._get_queryset()
id_list = [item.id for item in paginated.page(page).object_list]
send_queryset = send_queryset.filter(id__in=id_list)
extra = {'click_action': url, "icon": icon_url}
send_push_async.apply_async(
args=[send_queryset, title, message, extra], countdown=seconds)
if index % batch == 0:
seconds += 1
return queryset
class CreateCommentForm(IdeiaForm):
content = forms.CharField(
max_length=settings.COMMENT_TEXT_LIMIT if hasattr(
settings, "COMMENT_TEXT_LIMIT") else 10000,
required=True,
widget=SummernoteWidget(editor_conf='comment', load_init=False))
content_type = forms.CharField(max_length=20, required=True)
content_object_id = forms.IntegerField(required=True)
def __init__(self, user=None, *args, **kwargs):
self.user = user
super(CreateCommentForm, self).__init__(*args, **kwargs)
def __process__(self):
return Business.create_comment(self.user, self.cleaned_data)
def clean(self):
self.cleaned_data = super(CreateCommentForm, self).clean()
if 'content' in self.cleaned_data:
self.cleaned_data['content'] = self.cleaned_data['content'].strip()
return self.cleaned_data
def is_valid(self):
valid = super(CreateCommentForm, self).is_valid()
if not self.user or not self.user.is_authenticated:
self.add_error(
None,
ValidationError(('User must be authenticated.'),
code='is_not_authenticated'))
valid = False
if 'content' in self.cleaned_data and self.cleaned_data[
'content'] == '':
self.add_error(
'content',
ValidationError(
('Is not possible to comment only with white spaces.'),
code='white_spaces'))
valid = False
try:
entity_to_comment = settings.ENTITY_TO_COMMENT
except AttributeError:
entity_to_comment = False
if not entity_to_comment or self.cleaned_data[
'content_type'] not in entity_to_comment:
self.add_error(
None,
ValidationError(('Content Type is not specified.'),
code='content_is_not_specified'))
valid = False
return valid
class EditProfileForm(IdeiaForm):
birth = forms.DateField(input_formats=['%d/%m/%Y'])
gender = forms.CharField(max_length=1, required=True)
city = forms.ModelChoiceField(queryset='', required=False)
city_hometown = forms.ModelChoiceField(queryset='')
profile_picture = forms.ImageField(required=False)
description = forms.CharField(required=False, widget=forms.Textarea, max_length=255)
def __init__(self, user=None, data_model=None, *args, **kwargs):
self.user = user
self.data_model = data_model
super(EditProfileForm, self).__init__(*args, **kwargs)
self.fields['city'].queryset = City.objects.all()
if self.data and 'state' in self.data:
self.fields['city_hometown'].queryset = City.objects.filter(state=self.data['state'])
def is_valid(self):
is_valid = super(EditProfileForm, self).is_valid()
image = self.cleaned_data.get('profile_picture', False)
birth = self.cleaned_data.get('birth', None)
if birth and birth.year > timezone.now().year:
is_valid = False
self.add_error('birth', ValidationError(_('Birth invalid.'), code='birth'))
if 'gender' in self.cleaned_data:
if self.cleaned_data['gender'].upper() not in ['M', 'F']:
is_valid = False
self.add_error('gender',
ValidationError(_('Gênero não permitido.'), code='gender'))
if image and 'image' in self.changed_data:
if image.content_type not in settings.IMAGES_ALLOWED:
self.add_error('profile_picture',
ValidationError(_('Image format is not allowed.'), code='profile_picture'))
is_valid = False
if image._size > 1024 * 1024:
self.add_error('profile_picture',
ValidationError(_('Image size more than 1mb.'), code='profile_picture'))
is_valid = False
return is_valid
def __process__(self):
self.instance = Business.edit_profile(self.user, self.cleaned_data)
return self.instance
def __init__(self, *args, **kwargs):
list_fields = [
forms.CharField(
error_messages={'incomplete': 'Enter a responsibility.'},
validators=[RegexValidator(r'^[\w\d](?:[\w\d\s])*$', 'Just text and numbers.')],
initial="Responsability"
),
forms.CharField(
error_messages={'incomplete': 'Enter a description of responsibility.'},
validators=[RegexValidator(r'^[\w\d](?:[\w\d\s])*$', 'Just text and numbers.')],
initial="Description"
)
]
super(OccupationField, self).__init__(list_fields, *args, **kwargs)
class CreateQuestionForm(IdeiaModelForm):
title = forms.CharField(max_length=settings.QUESTION_TITLE_LIMIT if hasattr(settings, "QUESTION_TITLE_LIMIT") else 100, required=True)
slug = forms.SlugField(max_length=300, required=False)
description = forms.CharField(max_length=settings.QUESTION_TEXT_LIMIT if hasattr(settings, "QUESTION_TEXT_LIMIT") else 10000, widget=SummernoteWidget(editor_conf='question'), required=True)
user = None
class Meta:
model = Business.Question
exclude = ['author', 'question_date', 'slug', 'search_vector', 'like_count', 'dislike_count', 'comment_count']
def is_valid(self):
valid = super(CreateQuestionForm, self).is_valid()
return valid
def __init__(self, data=None, files=None, user=None, *args, **kargs):
super(CreateQuestionForm, self).__init__(data, files, *args, **kargs)
self.set_author(user)
def set_author(self, user):
self.user = user
def clean_description(self):
regex = re.compile(r'<p> </p>')
_description = regex.sub('', self.cleaned_data.get('description'))
return _description
def clean_slug(self):
slug = self.cleaned_data.get('slug', None)
title = self.cleaned_data.get('title')
slug = slug if bool(slug) else slugify(title)
return slug
@transaction.atomic()
def __process__(self):
self.instance.author = self.user
# self.instance = Business.save_question(self.user, self.cleaned_data)
self.instance = self.save()
# TODO: [POG] Protect for error in oldest questions without slug
if not bool(self.instance.slug):
self.instance.slug = slugify(self.instance.title)
self.instance.save()
return self.instance
class CoreSearchCommunitiesForm(IdeiaForm):
criteria = forms.CharField(required=False)
__term = None
try:
__term = Term.objects.get(description__icontains='categoria')
except:
pass
category = forms.ModelChoiceField(queryset=Taxonomy.objects.filter(term=__term), required=False)
page = forms.IntegerField(required=False)
def __init__(self, author, items_per_page, *args, **kwargs):
self.author = author
self.items_per_page = items_per_page
super(CoreSearchCommunitiesForm, self).__init__(*args, **kwargs)
def clean(self):
cleaned_data = super(CoreSearchCommunitiesForm, self).clean()
cleaned_data['page'] = cleaned_data['page'] \
if 'page' in cleaned_data and cleaned_data['page'] else 1
return cleaned_data
def __process__(self):
return BusinessSocialActions.get_users_acted_by_author_with_parameters(
author=self.author,
action=settings.SOCIAL_FOLLOW,
content_type='community',
items_per_page=self.items_per_page,
page=self.cleaned_data.get('page', 1),
criteria=self.cleaned_data.get('criteria'),
category=self.cleaned_data.get('category')
)
class SearchBaseForm(IdeiaForm):
category = forms.CharField(required=False)
q = forms.CharField(required=False)
page = forms.IntegerField(required=False)
def __init__(self, items_per_page=None, startswith=False, *args, **kwargs):
self.items_per_page = items_per_page
self.startswith = startswith
super(SearchBaseForm, self).__init__(*args, **kwargs)
def clean(self):
cleaned_data = super(SearchBaseForm, self).clean()
cleaned_data['page'] = cleaned_data['page'] if 'page' in cleaned_data and cleaned_data['page'] else 1
return cleaned_data
class CoreCommunitySearchVideosForm(IdeiaForm):
criteria = forms.CharField(required=False)
page = forms.IntegerField(required=False)
def __init__(self, community=None, items_per_page=10, *args, **kwargs):
self.community = community
self.items_per_page = items_per_page
super(CoreCommunitySearchVideosForm, self).__init__(*args, **kwargs)
def clean(self):
cleaned_data = super(CoreCommunitySearchVideosForm, self).clean()
cleaned_data['page'] = cleaned_data['page'] \
if 'page' in cleaned_data and cleaned_data['page'] else 1
return cleaned_data
def __process__(self):
return Business.get_articles_with_videos(
self.community,
self.cleaned_data.get('criteria'),
self.items_per_page,
self.cleaned_data.get('page', 1)
)
class CoreSearchArticlesForm(IdeiaForm):
criteria = forms.CharField(required=False)
status = forms.ChoiceField(required=False, choices=Article.STATUS_CHOICES)
page = forms.IntegerField(required=False)
def __init__(self, author=None, items_per_page=10, order=None, *args, **kwargs):
self.items_per_page = items_per_page
self.author = author
self.order = order
super(CoreSearchArticlesForm, self).__init__(*args, **kwargs)
def clean(self):
cleaned_data = super(CoreSearchArticlesForm, self).clean()
cleaned_data['page'] = cleaned_data['page'] \
if 'page' in cleaned_data and cleaned_data['page'] else 1
return cleaned_data
def __process__(self):
return Business.get_feed_articles(
self.author,
self.cleaned_data.get('criteria'),
self.cleaned_data.get('status'),
self.items_per_page,
self.cleaned_data.get('page', 1),
)
class CoreCommunityFollowersForm(IdeiaForm):
community = forms.ModelChoiceField(queryset=Community.objects.all(), required=True)
criteria = forms.CharField(required=False)
state = forms.ModelChoiceField(queryset=State.objects.filter(country=1), required=False)
city = forms.ModelChoiceField(queryset=City.objects.all(), required=False)
page = forms.IntegerField(required=False)
def __init__(self, startswith=False, items_per_page=None, *args, **kwargs):
self.startswith = startswith
self.items_per_page = items_per_page
super(CoreCommunityFollowersForm, self).__init__(*args, **kwargs)
if self.data and 'state' in self.data and self.data.get('state'):
self.fields['city'].queryset = City.objects.filter(state=self.data['state'])
def clean(self):
cleaned_data = super(CoreCommunityFollowersForm, self).clean()
cleaned_data['page'] = cleaned_data['page'] if 'page' in cleaned_data and cleaned_data['page'] else 1
return cleaned_data
def __process__(self):
return Business.get_followers(
self.cleaned_data,
self.items_per_page,
self.cleaned_data.get('page'),
self.startswith
)
class CoreCommunitySearchMaterialsForm(IdeiaForm):
criteria = forms.CharField(required=False)
page = forms.IntegerField(required=False)
tags = forms.ModelChoiceField(queryset=Business.get_avaiable_tags(), required=False,
empty_label=_("All"))
def __init__(self, community=None, items_per_page=10, *args, **kwargs):
self.community = community
self.items_per_page = items_per_page
super(CoreCommunitySearchMaterialsForm, self).__init__(*args, **kwargs)
def get_avaiable_tags(self):
return Business.get_avaiable_tags()
def clean(self):
cleaned_data = super(CoreCommunitySearchMaterialsForm, self).clean()
cleaned_data['page'] = cleaned_data['page'] \
if 'page' in cleaned_data and cleaned_data['page'] else 1
return cleaned_data
def __process__(self):
return Business.get_articles_with_tags(
self.community,
self.cleaned_data.get('criteria'),
self.items_per_page,
self.cleaned_data.get('page', 1),
self.cleaned_data.get('tags')
)
class CoreCommunityFormSearch(IdeiaForm):
criteria = forms.CharField(required=False)
page = forms.IntegerField(required=False)
taxonomies = forms.ModelMultipleChoiceField(queryset=Taxonomy.objects.all(), required=False)
def __init__(self, items_per_page=None, *args, **kwargs):
self.items_per_page = items_per_page
super(CoreCommunityFormSearch, self).__init__(*args, **kwargs)
def clean(self):
cleaned_data = super(CoreCommunityFormSearch, self).clean()
cleaned_data['page'] = cleaned_data['page'] if 'page' in cleaned_data and cleaned_data['page'] else 1
return cleaned_data
def __process__(self):
return Business.get_communities(
self.cleaned_data['taxonomies'],
self.cleaned_data['criteria'],
self.items_per_page,
self.cleaned_data['page']
)
class CoreUserSearchForm(IdeiaForm):
criterio = forms.CharField(required=False)
page = forms.IntegerField(required=False)
def __init__(self, profile_instance=None, content_types=None,
itens_by_page=None, user=None, *args, **kwargs):
self.profile_instance = profile_instance
self.content_types = content_types
self.itens_by_page = itens_by_page
self.user = user
super(CoreUserSearchForm, self).__init__(*args, **kwargs)
def clean(self):
cleaned_data = super(CoreUserSearchForm, self).clean()
cleaned_data['page'] = cleaned_data['page']\
if 'page' in cleaned_data and cleaned_data['page'] else 1
return cleaned_data
def __process__(self):
return Business.get_feed_objects(
self.profile_instance,
self.cleaned_data['criterio'],
self.content_types,
self.itens_by_page,
self.cleaned_data['page'],
self.user
)
class CoreSearchFavouriteForm(IdeiaForm):
criteria = forms.CharField(required=False)
page = forms.IntegerField(required=False)
def __init__(self, author, items_per_page, *args, **kwargs):
self.author = author
self.items_per_page = items_per_page
super(CoreSearchFavouriteForm, self).__init__(*args, **kwargs)
def clean(self):
cleaned_data = super(CoreSearchFavouriteForm, self).clean()
cleaned_data['page'] = cleaned_data['page'] \
if 'page' in cleaned_data and cleaned_data['page'] else 1
return cleaned_data
def __process__(self):
return CoreBusinessSocialActions.get_favourite_content(
self.author,
self.cleaned_data.get('criteria'),
self.items_per_page,
self.cleaned_data.get('page', 1)
)
class GeographyListForm(IdeiaForm):
name = forms.CharField(required=False)
page = forms.IntegerField(min_value=1, required=False)
def __init__(self, itens_per_page=10, model=None, *args, **kwargs):
self.itens_per_page = itens_per_page
self.model = model
super(GeographyListForm, self).__init__(*args, **kwargs)
def clean(self):
cleaned_data = super(GeographyListForm, self).clean()
cleaned_data['page'] = cleaned_data['page']\
if 'page' in cleaned_data and cleaned_data['page'] else 1
return cleaned_data
def __process__(self):
return get_geography(
self.model,
self.cleaned_data['name'],
self.itens_per_page,
self.cleaned_data['page']
)
class ListCommentForm(IdeiaForm):
content_id = forms.IntegerField(min_value=1, required=True)
content_type = forms.CharField(required=True)
page = forms.IntegerField(min_value=1, required=False)
def __init__(self, itens_per_page=10, *args, **kwargs):
self.itens_per_page = itens_per_page
super(ListCommentForm, self).__init__(*args, **kwargs)
def clean(self):
cleaned_data = super(ListCommentForm, self).clean()
cleaned_data['page'] = cleaned_data['page']\
if 'page' in cleaned_data and cleaned_data['page'] else 1
return cleaned_data
def is_valid(self):
valid = super(ListCommentForm, self).is_valid()
if 'content_type' in self.cleaned_data and self.cleaned_data[
'content_type'] not in settings.ENTITY_TO_COMMENT:
self.add_error(
None,
ValidationError(
('ContentType not found in comment contentType list.'),
code='comment_content_type_not_found'))
return valid
def __process__(self):
return Business.get_comments_by_content_type_and_id(
self.cleaned_data['content_type'], self.cleaned_data['content_id'],
self.itens_per_page, self.cleaned_data['page'])
class CoreCommunityFeedFormSearch(IdeiaForm):
criterio = forms.CharField(required=False)
page = forms.IntegerField(required=False)
official = forms.BooleanField(required=False)
def __init__(self, community_instance=None, content_types=None, itens_by_page=None, *args, **kwargs):
self.community_instance=community_instance
self.content_types = content_types
self.itens_by_page = itens_by_page
super(CoreCommunityFeedFormSearch, self).__init__(*args, **kwargs)
def clean(self):
cleaned_data = super(CoreCommunityFeedFormSearch, self).clean()
cleaned_data['page'] = cleaned_data['page']\
if 'page' in cleaned_data and cleaned_data['page'] else 1
cleaned_data['official'] = cleaned_data.get('official', False)
return cleaned_data
def __process__(self):
return Business.get_feed_objects(
self.community_instance,
self.cleaned_data['criterio'],
self.content_types,
self.itens_by_page,
self.cleaned_data['page'],
self.cleaned_data.get('official')
)
class CoreSearchQuestionsForm(IdeiaForm):
criteria = forms.CharField(required=False)
deleted = forms.NullBooleanField(required=False)
page = forms.IntegerField(required=False)
def __init__(self, author=None, items_per_page=10, *args, **kwargs):
self.items_per_page = items_per_page
self.author = author
super(CoreSearchQuestionsForm, self).__init__(*args, **kwargs)
def clean(self):
cleaned_data = super(CoreSearchQuestionsForm, self).clean()
cleaned_data['page'] = cleaned_data['page'] \
if 'page' in cleaned_data and cleaned_data['page'] else 1
return cleaned_data
def __process__(self):
return Business.get_questions(
self.author,
self.cleaned_data.get('criteria'),
self.cleaned_data.get('deleted'),
self.items_per_page,
self.cleaned_data.get('page', 1)
)
class CommentReplyForm(IdeiaForm):
description = forms.CharField(widget=SummernoteWidget(editor_conf='reply'), max_length=settings.ANSWER_TEXT_LIMIT if hasattr(settings, "ANSWER_TEXT_LIMIT") else 10000, required=True)
def __init__(self, instance=None, user=None, *args, **kargs):
super(CommentReplyForm, self).__init__(instance, *args, **kargs)
self.instance = instance
self.user = user
self.question = instance["question_id"]
self.description = instance["description"]
def is_valid(self):
is_valid = super(CommentReplyForm, self).is_valid()
description = self.cleaned_data.get('description', '').strip()
if description == '' or description is None:
self.add_error('description', ValidationError(_('Your answer can not be blank'), code='description'))
is_valid = False
return is_valid
def clean_description(self):
description = self.cleaned_data.get('description', '').strip()
return description
def __process__(self):
return Business.comment_reply(self.cleaned_data, self.user, self.question)
class ContactFormNoAuthenticated(ContactForm):
name = forms.CharField(max_length=100, required=True)
email = forms.EmailField(required=True)
captcha = NoReCaptchaField()
def __process__(self):
return super(ContactFormNoAuthenticated, self).__process__()
class SignUpForm(BaseSignupForm):
username = forms.SlugField(max_length=100, required=True)
password = forms.CharField(max_length=50, required=True)
password_confirmation = forms.CharField(max_length=50, required=True)
captcha = NoReCaptchaField(required=True)
def clean_password(self):
_pass = self.cleaned_data.get('password')
validate_password(_pass)
return _pass
def clean_username(self):
username = self.cleaned_data.get('username')
username = username.lower()
return username
def is_valid(self):
valid = super(SignUpForm, self).is_valid()
if 'password' in self.cleaned_data and 'password_confirmation' in self.cleaned_data and \
self.cleaned_data['password'] != self.cleaned_data['password_confirmation']:
self.add_error(
'password',
ValidationError(_('Passwords are not the same.'),
code='password'))
valid = False
if 'username' in self.cleaned_data and User.objects.filter(
username=self.cleaned_data['username']).exists():
self.add_error(
'username',
ValidationError(_('Username is already in use.'),
code='username'))
valid = False
return valid
def __process__(self):
return Business.register_user(self.cleaned_data)
class SearchNotificationSubscribe(IdeiaForm):
q = forms.CharField(required=False)
communities = forms.ModelMultipleChoiceField(
queryset=Community.objects.all().order_by("title"), required=False)
team = forms.ModelMultipleChoiceField(
Responsibility.objects.all().order_by("name"), required=False)
HAS_USER_CHOICES = (("", "Todos"), (True, "Registrados"), (False,
"Sem registro"))
has_user = forms.ChoiceField(required=False, choices=HAS_USER_CHOICES)
def __has_search_field(self, key):
if key in self.cleaned_data and self.cleaned_data[
key] is not None and self.cleaned_data[key] != '':
return self.cleaned_data[key]
else:
return None
def _get_queryset(self):
q = self.__has_search_field("q")
communities = self.__has_search_field("communities")
responsibility = self.__has_search_field("responsibility")
has_user = self.__has_search_field("has_user")
queryset = GCMDevice.objects.filter(active=True)
if q:
queryset = queryset.filter(Q(user__username=q))
if has_user == "True":
queryset = queryset.filter(Q(user__isnull=False))
elif has_user == "False":
queryset = queryset.filter(Q(user__isnull=True))
if communities:
communities_id = [community.id for community in communities]
user_action_queryset = UserAction.objects.filter(
content_type=ContentTypeCached.objects.get(model='community'),
object_id__in=communities_id,
action_type=get_by_label('follow')).prefetch_related(
"author").only("author")
users_id = [item.author.id for item in user_action_queryset]
user_queryset = get_user_model().objects.filter(id__in=users_id)
queryset = queryset.filter(user__in=user_queryset)
if responsibility:
queryset = queryset.filter(
user__profile__occupation__responsibility__in=responsibility)
return queryset
def __process__(self):
return self._get_queryset().count()
class ContactForm(IdeiaForm):
subject = forms.ModelChoiceField(queryset=Business.get_contact_subjects(),
required=True)
message = forms.CharField(max_length=1024, required=True)
def __init__(self, user=None, *args, **kwargs):
self.user = user
super(ContactForm, self).__init__(*args, **kwargs)
def __process__(self):
self.instance = Business.save(self.cleaned_data, self.user)
return self.instance
class LoginForm(IdeiaForm):
username = forms.CharField(max_length=100, required=True)
password = forms.CharField(max_length=50, required=True)
instance = None
def __init__(self, request=None, *args, **kwargs):
self.request = request
self.redirect_to_wizard = False
super(LoginForm, self).__init__(*args, **kwargs)
def is_valid(self):
valid = super(LoginForm, self).is_valid()
if 'password' in self.cleaned_data and 'username' in self.cleaned_data:
self.instance = Business.authenticate_user(
username_or_email=self.cleaned_data.get('username'),
password=self.cleaned_data.get('password'))
if not self.instance:
self.add_error(
None,
ValidationError(_('Wrong password or username.'),
code='password'))
valid = False
else:
if self.instance.is_active is False:
self.account_is_active = False
valid = False
else:
self.account_is_active = True
if self.instance and self.instance.profile and self.instance.profile.wizard_step < settings.WIZARD_STEPS_TOTAL:
self.redirect_to_wizard = True
return valid
def __process__(self):
return Business.log_in_user(self.request, self.instance)
class ChangePasswordForm(IdeiaForm):
old_password = forms.CharField(max_length=30, required=True)
new_password = forms.CharField(max_length=30, required=True)
new_password_confirmation = forms.CharField(max_length=30, required=True)
def __init__(self, request=None, *args, **kwargs):
self.request = request
self.user = request.user
super(ChangePasswordForm, self).__init__(*args, **kwargs)
def is_valid(self):
valid = super(ChangePasswordForm, self).is_valid()
if 'old_password' in self.cleaned_data:
is_authenticated = Business.authenticate_user(
self.user.username, self.cleaned_data['old_password'])
if not is_authenticated:
self.add_error(
'old_password',
ValidationError(_('Wrong old password.'),
code='old_password'))
valid = False
if 'new_password' in self.cleaned_data and 'new_password_confirmation' in self.cleaned_data and \
self.cleaned_data['new_password'] != self.cleaned_data['new_password_confirmation']:
self.add_error(
'new_password',
ValidationError(_('Passwords are not the same.'),
code='new_password'))
valid = False
return valid
def __process__(self):
return Business.update_password(self.request, self.user,
self.cleaned_data['new_password'])
class CoreSearchSocialActionsForm(IdeiaForm):
criteria = forms.CharField(required=False)
page = forms.IntegerField(required=False)
def __init__(self, action, items_per_page, *args, **kwargs):
self.action = action
self.items_per_page = items_per_page
self.author = None
self.target_user = None
super(CoreSearchSocialActionsForm, self).__init__(*args, **kwargs)
def clean(self):
cleaned_data = super(CoreSearchSocialActionsForm, self).clean()
cleaned_data['page'] = cleaned_data['page'] \
if 'page' in cleaned_data and cleaned_data['page'] else 1
return cleaned_data
def is_valid(self):
is_valid = super(CoreSearchSocialActionsForm, self).is_valid()
action_allowed = [settings.SOCIAL_SUGGEST, settings.SOCIAL_FAVOURITE, settings.SOCIAL_SEE_LATER]
if self.action not in action_allowed:
is_valid = False
return is_valid
def set_author(self, author):
self.author = author
def set_target_user(self, user):
self.target_user = user
def __process__(self):
return CoreBusinessSocialActions.get_content_by_action(
self.cleaned_data.get('criteria'),
self.action,
self.items_per_page,
self.cleaned_data.get('page', 1),
self.author,
self.target_user
)
class EditAnswerForm(IdeiaForm):
description = forms.CharField(widget=SummernoteWidget(editor_conf='reply'), max_length=settings.ANSWER_TEXT_LIMIT if hasattr(settings, "ANSWER_TEXT_LIMIT") else 10000, required=True)
user = None
def __init__(self, instance=None, user=None, *args, **kwargs):
self.instance = instance
self.user = user
if self.instance:
initial = kwargs.get('initial', {})
initial.update({
'description': self.instance.description
})
kwargs.update({
'initial': initial
})
super(EditAnswerForm, self).__init__(*args, **kwargs)
def set_author(self, user):
self.user = user
def is_valid(self):
is_valid = super(EditAnswerForm, self).is_valid()
if not self.user or not self.user.is_authenticated():
self.add_error(None,
ValidationError(('User must be authenticated.'),
code='is_not_authenticated'))
is_valid = False
if self.user != self.instance.author:
self.add_error(None,
ValidationError(('User dont have access'),
code='is_not_permission'))
is_valid = False
return is_valid
def __process__(self):
return Business.update_reply(self.cleaned_data, self.instance)
