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 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 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 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 CoreTaxonomiesMixin(IdeiaModelForm): taxonomies = forms.ModelMultipleChoiceField(required=False, queryset=Taxonomy.objects.all(),) communities = forms.ModelMultipleChoiceField(required=False, queryset=Community.objects.all(),) def __init__(self, *args, **kwargs): kwargs['initial'] = kwargs.get('initial', {}) instance = kwargs.get('instance', None) if instance is not None: self.__load_other_fields(instance, kwargs) # Load article communities and update the initial data super(CoreTaxonomiesMixin, self).__init__(*args, **kwargs) def __load_other_fields(self, instance, kwargs): feed_item = FeedBusiness.feed_get_or_create(instance) initial = { 'communities': feed_item.communities.all(), 'taxonomies': feed_item.taxonomies.all() } kwargs['initial'].update(initial) def filter_comunities(self, author, extra=None): communities = self.fields.get('communities') if extra is None: try: extra = self.instance.feed.all().first().communities.all() except Exception as e: pass if communities: communities.queryset = Community.objects.all() if extra is not None and isinstance(extra, (QuerySet)): communities.queryset = communities.queryset | extra def save_taxonomies(self, target_object, form_data): process_communities = CoreFeedBusiness.save_communities(target_object, self.cleaned_data) process_core = CoreFeedBusiness.save_taxonomies(target_object, self.cleaned_data) return process_communities and process_core def delete_taxonomies(self, target_object, form_data): CoreFeedBusiness.delete_taxonomies(target_object, self.cleaned_data) CoreFeedBusiness.delete_communities(target_object, self.cleaned_data)
class CoreRemoveSocialActionForm(IdeiaForm): items_to_remove = forms.ModelMultipleChoiceField(queryset=UserAction.objects.all()) def __init__(self, action, *args, **kwargs): self.action = action self.processed = False self.author = None self.target_user = None super(CoreRemoveSocialActionForm, self).__init__(*args, **kwargs) def is_valid(self): is_valid = super(CoreRemoveSocialActionForm, 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): self.processed = CoreBusinessSocialActions.remove_social_actions( self.action, self.cleaned_data.get('items_to_remove'), self.author, self.target_user ) return self.processed
class CoreArticleBaseForm(ArticleForm, CoreTaxonomiesMixin): tags = forms.ModelMultipleChoiceField( queryset=Tags.objects.all().order_by('tag_order'), required=False, widget=CheckboxSelectMultiple) def __init__(self, *args, **kwargs): kwargs['initial'] = kwargs.get('initial', {}) instance = kwargs.get('instance', None) self.instance = instance if instance: kwargs['initial'].update(self.get_feed_initial(instance)) super(CoreArticleBaseForm, self).__init__(*args, **kwargs) def get_feed_initial(self, instance): feed_item = FeedBusiness.feed_get_or_create(instance) initial = { 'tags': feed_item.tags.all(), } return initial def set_author(self, author): super(CoreArticleBaseForm, self).set_author(author) extra = None try: extra = self.instance.feed.all().first().communities.all() except Exception as e: print(e.message) pass self.filter_comunities(author, extra=extra) @transaction.atomic() @reversion.create_revision() def __process__(self): process_article = super(CoreArticleBaseForm, self).__process__() if process_article: reversion.set_user(self._author) process_feed = Business.save_feed_item(self.instance, self.cleaned_data) process_taxonomies = None if self.cleaned_data['communities']: process_taxonomies = self.save_taxonomies(process_feed, self.cleaned_data) else: self.delete_taxonomies(process_feed, self.cleaned_data) process_tags = BusinessTags.save_feed_tags(process_feed, self.cleaned_data) if process_feed: clear_article_cache.send(sender=process_feed.__class__, instance=process_feed) if self.cleaned_data['communities']: return process_article if (process_article and process_taxonomies and process_tags) else False else: return process_article if (process_article and process_tags) else False