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