class Meta: exclude = () widgets = { 'description': SummernoteWidget(editor_conf='responsibility'), 'about': SummernoteWidget(editor_conf='responsibility'), 'where_get': SummernoteWidget(editor_conf='responsibility'), 'more_info': SummernoteWidget(editor_conf='responsibility'), }
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 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 Meta: excludes = () widgets = { 'text': SummernoteWidget(editor_conf='article_admin'), # 'author': SelectizeSelectSingle( # unique_name='admin_authors', # label_field='username', # search_fields=( # 'username__unaccent__icontains', # 'first_name__unaccent__icontains', # 'last_name__unaccent__icontains', # ) # ), }
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)
class EditCommentForm(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)) def __init__(self, user=None, instance=None, *args, **kargs): self.user = user self.instance = instance super(EditCommentForm, self).__init__(*args, **kargs) def is_valid(self): valid = super(EditCommentForm, self).is_valid() if 'content' in self.cleaned_data: content = strip_tags(self.cleaned_data['content']) if content == '': self.add_error( 'content', ValidationError( ('Is not possible to comment only with white spaces.'), code='white_spaces')) valid = False if self.user and self.instance.author and self.instance.author != self.user: self.add_error( None, ValidationError(('comment edit permission denied!'), code='is_not_authenticated')) valid = False return valid def __process__(self): return Business.edit_comment(self.instance, self.cleaned_data)
class SummernoteFormField(CharField): def __init__(self, editor_conf='default', load_init=True, async=False, *args, **kwargs): kwargs.update({'widget': SummernoteWidget(editor_conf=editor_conf, load_init=load_init, async=async)})
class Meta: excludes = () widgets = {'description': SummernoteWidget(editor_conf='community')}
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 Meta: widgets = { 'content': SummernoteWidget(editor_conf='article_admin') }
class ArticleForm(IdeiaModelForm): title = forms.CharField(required=True, max_length=settings.ARTICLE_TITLE_LIMIT if hasattr( settings, "ARTICLE_TITLE_LIMIT") else 100) slug = forms.SlugField(max_length=150, required=False) text = forms.CharField(required=True, widget=SummernoteWidget(editor_conf='article'), max_length=settings.ARTICLE_TEXT_LIMIT if hasattr( settings, "ARTICLE_TEXT_LIMIT") else 10000) # image = forms.ImageField(required=False) publishin = forms.DateTimeField(required=False) # status = forms.ChoiceField(required=False, choices=Business.Article.STATUS_CHOICES) # author = forms.IntegerField(required=False) # Actions: save, publish, schedule ACTION_SAVE = 1 ACTION_PUBLISH = 2 ACTION_SCHEDULE = 3 action = ACTION_SAVE _author = None class Meta: model = Business.Article exclude = [ 'first_slug', 'slug', 'status', 'search_vector', 'author', 'comment_count', 'like_count', 'dislike_count' ] def __init__(self, data=None, files=None, author=False, *args, **kwargs): super(ArticleForm, self).__init__(data, files, *args, **kwargs) # if author: # self.set_author(author) def clean_text(self): regex = re.compile(r'<p> </p>') _text = regex.sub('', self.cleaned_data.get('text')) return _text def clean_publishin(self): _date = self.cleaned_data.get('publishin') _instance_date = self.instance.publishin _now = timezone.now() if not _date and _instance_date: _date = _instance_date if self.action == self.ACTION_SCHEDULE: if not _date: self.add_error('publishin', ValidationError(_('Publish date has invalid'))) elif _date < _now: self.add_error('publishin', ValidationError(_('Publish date has invalid'))) else: _date = _date if _date else _now elif self.action == self.ACTION_PUBLISH: _date = _now return _date def clean_slug(self): slug = self.cleaned_data.get('slug', None) title = self.cleaned_data.get('title') slug = slug if bool(slug) else Business.get_valid_slug( self.instance, title) return slug # def clean_author(self): # _author = self.cleaned_data.get('author') # return _author if _author else self._author def is_valid(self): valid = True old_status_is_published = False if not super(ArticleForm, self).is_valid(): valid = False if self.instance.status == Business.Article.STATUS_PUBLISH: old_status_is_published = Business.Article.STATUS_PUBLISH slug = self.cleaned_data.get('slug', None) if bool(slug) and self.is_author(): title = self.cleaned_data.get('title') slug = slug if bool(slug) else Business.get_valid_slug( self.instance, title) self.instance.slug = slug if bool(self.instance.slug) and not self.is_author(): self.cleaned_data.pop('slug') image = self.cleaned_data.get('image', False) if image and 'image' in self.changed_data: if image.content_type not in settings.IMAGES_ALLOWED: self.add_error( 'image', ValidationError(_('Image format is not allowed.'), code='image_format_incorrect')) valid = False if image and 'image' in self.changed_data: if image.size > 2621440: #2,5 MB self.add_error( 'image', ValidationError(_('Image size is too long.'), code='image_size_soo_long')) valid = False if 'submit-publish' in self.data: ''' Publishing action ''' self.action = self.ACTION_PUBLISH self.instance.do_publish() elif 'submit-save' in self.data: ''' Save action ''' self.instance.action = self.ACTION_SAVE if self.instance.status == Business.Article.STATUS_TEMP: self.instance.status = Business.Article.STATUS_DRAFT self.instance.do_save() # self.cleaned_data.update({ # 'status': self.instance.status # }) if old_status_is_published and 'publishin' in self.cleaned_data: del self.cleaned_data['publishin'] return valid def is_author(self): return bool(self.instance.author == self._author) def set_author(self, author): self._author = author def __process__(self): if not self.instance.author: self.instance.author = self._author self.instance = self.save() return Business.save_article(self.instance, self.cleaned_data)
class Meta: excludes = () widgets = {'text': SummernoteWidget(editor_conf='article_admin')}
class Meta: model = UserAlert exclude = () widgets = {'content': SummernoteWidget(editor_conf='article')}