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)