class CaseSerializer(serializers.ModelSerializer): account = AccountSerializer(read_only=True, many=True) contacts = ContactSerializer(read_only=True, many=True) assigned_to = UserSerializer(read_only=True, many=True) created_by = UserSerializer(read_only=True) teams = TeamsSerializer(read_only=True, many=True) company = CompanySerializer() get_team_users = UserSerializer(read_only=True, many=True) get_team_and_assigned_users = UserSerializer(read_only=True, many=True) get_assigned_users_not_in_teams = UserSerializer(read_only=True, many=True) class Meta: model = Case fields = ( 'id', 'name', 'status', 'priority', 'case_type', 'account', 'contacts', 'closed_on', 'description', 'assigned_to', 'created_by', 'created_on', 'is_active', 'teams', 'company', 'get_team_users', 'get_team_and_assigned_users', "get_assigned_users_not_in_teams", "created_on_arrow", )
class CaseSerializer(serializers.ModelSerializer): account = AccountSerializer() contacts = ContactSerializer(read_only=True, many=True) assigned_to = ProfileSerializer(read_only=True, many=True) created_by = ProfileSerializer(read_only=True) teams = TeamsSerializer(read_only=True, many=True) org = OrganizationSerializer() class Meta: model = Case fields = ( "id", "name", "status", "priority", "case_type", "closed_on", "description", "created_by", "created_on", "is_active", "account", "contacts", "teams", "assigned_to", "org", "created_on_arrow", )
def get(self, request, format=None): accounts = Account.objects.filter(status="open", company=request.company) contacts = Contact.objects.filter(company=request.company) leads = Lead.objects.filter(company=request.company).exclude( Q(status="converted") | Q(status="closed")) opportunities = Opportunity.objects.filter(company=request.company) if self.request.user.role == "ADMIN" or self.request.user.is_superuser: pass else: accounts = accounts.filter( Q(assigned_to__id__in=[self.request.user.id]) | Q(created_by=self.request.user.id)) contacts = contacts.filter( Q(assigned_to__id__in=[self.request.user.id]) | Q(created_by=self.request.user.id)) leads = leads.filter( Q(assigned_to__id__in=[self.request.user.id]) | Q(created_by=self.request.user.id)).exclude(status="closed") opportunities = opportunities.filter( Q(assigned_to__id__in=[self.request.user.id]) | Q(created_by=self.request.user.id)) context = {} context["accounts_count"] = accounts.count() context["contacts_count"] = contacts.count() context["leads_count"] = leads.count() context["opportunities_count"] = opportunities.count() context["accounts"] = AccountSerializer(accounts, many=True).data context["contacts"] = ContactSerializer(contacts, many=True).data context["leads"] = LeadSerializer(leads, many=True).data context["opportunities"] = OpportunitySerializer(opportunities, many=True).data return Response(context, status=status.HTTP_200_OK)
class CaseSerializer(serializers.ModelSerializer): account = AccountSerializer(read_only=True, many=True) contacts = ContactSerializer(read_only=True, many=True) assigned_to = UserSerializer(read_only=True, many=True) created_by = UserSerializer(read_only=True) teams = TeamsSerializer(read_only=True, many=True) company = CompanySerializer() get_team_users = UserSerializer(read_only=True, many=True) get_team_and_assigned_users = UserSerializer(read_only=True, many=True) get_assigned_users_not_in_teams = UserSerializer(read_only=True, many=True) class Meta: model = Case fields = ( "id", "name", "status", "priority", "case_type", "account", "contacts", "closed_on", "description", "assigned_to", "created_by", "created_on", "is_active", "teams", "company", "get_team_users", "get_team_and_assigned_users", "get_assigned_users_not_in_teams", "created_on_arrow", )
class OpportunitySerializer(serializers.ModelSerializer): account = AccountSerializer() closed_by = UserSerializer() created_by = UserSerializer() class Meta: model = Opportunity # fields = ‘__all__’ fields = ( 'id', "name", "account", "stage", "currency", "amount", "lead_source", "probability", "contacts", "closed_by", "closed_on", "description", "assigned_to", "created_by", "created_on", "is_active", "tags", "teams", "company", "created_on_arrow", # "get_team_users", # "get_team_and_assigned_users", # "get_assigned_users_not_in_teams", )
def get_context_data(self, **kwargs): params = (self.request.query_params if len(self.request.data) == 0 else self.request.data) queryset = self.model.objects.filter(company=self.request.company) accounts = Account.objects.filter(company=self.request.company) contacts = Contact.objects.filter(company=self.request.company) if self.request.user.role != "ADMIN" and not self.request.user.is_superuser: queryset = queryset.filter( Q(assigned_to__in=[self.request.user]) | Q(created_by=self.request.user)) accounts = accounts.filter( Q(created_by=self.request.user) | Q(assigned_to=self.request.user)).distinct() contacts = contacts.filter( Q(created_by=self.request.user) | Q(assigned_to=self.request.user)).distinct() request_post = params if request_post: if request_post.get("title"): queryset = queryset.filter( title__icontains=request_post.get("title")) if request_post.get("status"): queryset = queryset.filter(status=request_post.get("status")) if request_post.get("priority"): queryset = queryset.filter( priority=request_post.get("priority")) context = {} search = False if (params.get("title") or params.get("status") or params.get("priority")): search = True context["search"] = search if search: context["tasks"] = TaskSerializer(queryset.distinct(), many=True).data return context context["tasks"] = TaskSerializer(queryset.distinct(), many=True).data context["status"] = STATUS_CHOICES context["priority"] = PRIORITY_CHOICES users = [] if self.request.user.role == "ADMIN" or self.request.user.is_superuser: users = User.objects.filter( is_active=True, company=self.request.company).order_by("email") elif self.request.user.google.all(): users = [] else: users = User.objects.filter( role="ADMIN", company=self.request.company).order_by("email") context["users"] = UserSerializer(users, many=True).data if self.request.user == "ADMIN": context["teams_list"] = TeamsSerializer( Teams.objects.filter(company=self.request.company), many=True).data context["accounts_list"] = AccountSerializer(accounts, many=True).data context["contacts_list"] = ContactSerializer(contacts, many=True).data return context
def get_context_data(self, **kwargs): params = (self.request.query_params if len(self.request.data) == 0 else self.request.data) queryset = self.model.objects.filter( org=self.request.org).order_by('-id') accounts = Account.objects.filter(org=self.request.org) contacts = Contact.objects.filter(org=self.request.org) if self.request.profile.role != "ADMIN" and not self.request.user.is_superuser: queryset = queryset.filter( Q(created_by=self.request.profile) | Q(assigned_to=self.request.profile)).distinct() accounts = accounts.filter( Q(created_by=self.request.profile) | Q(assigned_to=self.request.profile)).distinct() contacts = contacts.filter( Q(created_by=self.request.profile) | Q(assigned_to=self.request.profile)).distinct() if params: if params.get("name"): queryset = queryset.filter(name__icontains=params.get("name")) if params.get("account"): queryset = queryset.filter(account=params.get("account")) if params.get("stage"): queryset = queryset.filter(stage__contains=params.get("stage")) if params.get("lead_source"): queryset = queryset.filter( lead_source__contains=params.get("lead_source")) if params.get("tags"): queryset = queryset.filter( tags__in=json.loads(params.get("tags"))).distinct() context = {} results_opportunities = self.paginate_queryset(queryset.distinct(), self.request, view=self) opportunities = OpportunitySerializer(results_opportunities, many=True).data if results_opportunities: offset = queryset.filter( id__gte=results_opportunities[-1].id).count() if offset == queryset.count(): offset = None else: offset = 0 context.update({ "opportunities_count": self.count, "offset": offset, }) context["opportunities"] = opportunities context["accounts_list"] = AccountSerializer(accounts, many=True).data context["contacts_list"] = ContactSerializer(contacts, many=True).data context['tags'] = TagsSerailizer(Tags.objects.filter(), many=True).data context["stage"] = STAGES context["lead_source"] = SOURCES context["currency"] = CURRENCY_CODES return context
def get_context_data(self, **kwargs): context = {} open_accounts = AccountSerializer( self.get_queryset().filter(status="open"), many=True).data close_accounts = AccountSerializer( self.get_queryset().filter(status="close"), many=True).data context["users"] = UserSerializer(User.objects.filter( is_active=True, company=self.request.company).order_by("email"), many=True).data context["open_accounts"] = open_accounts context["close_accounts"] = close_accounts context["industries"] = INDCHOICES context["per_page"] = self.request.POST.get("per_page") tag_ids = list( set( Account.objects.filter( company=self.request.company).values_list("tags", flat=True))) context["tags"] = TagsSerailizer(Tags.objects.filter(id__in=tag_ids), many=True).data if self.request.POST.get("tag", None): context["request_tags"] = self.request.POST.getlist("tag") elif self.request.GET.get("tag", None): context["request_tags"] = self.request.GET.getlist("tag") else: context["request_tags"] = None search = False if (self.request.POST.get("name") or self.request.POST.get("city") or self.request.POST.get("industry") or self.request.POST.get("tag")): search = True context["search"] = search tab_status = "Open" if self.request.POST.get("tab_status"): tab_status = self.request.POST.get("tab_status") context["tab_status"] = tab_status TIMEZONE_CHOICES = [(tz, tz) for tz in pytz.common_timezones] context["timezones"] = TIMEZONE_CHOICES context["settings_timezone"] = settings.TIME_ZONE return context
def get_context_data(self, **kwargs): params = ( self.request.query_params if len(self.request.data) == 0 else self.request.data ) queryset = self.model.objects.filter( org=self.request.org).order_by('-id') accounts = Account.objects.filter(org=self.request.org) contacts = Contact.objects.filter(org=self.request.org) if self.request.profile.role != "ADMIN" and not self.request.profile.is_admin: queryset = queryset.filter( Q(assigned_to__in=[self.request.profile]) | Q( created_by=self.request.profile) ) accounts = accounts.filter( Q(created_by=self.request.profile) | Q( assigned_to=self.request.profile) ).distinct() contacts = contacts.filter( Q(created_by=self.request.profile) | Q( assigned_to=self.request.profile) ).distinct() if params: if params.get("title"): queryset = queryset.filter( title__icontains=params.get("title")) if params.get("status"): queryset = queryset.filter(status=params.get("status")) if params.get("priority"): queryset = queryset.filter( priority=params.get("priority")) context = {} results_tasks = self.paginate_queryset( queryset.distinct(), self.request, view=self ) tasks = TaskSerializer(results_tasks, many=True).data if results_tasks: offset = queryset.filter(id__gte=results_tasks[-1].id).count() if offset == queryset.count(): offset = None else: offset = 0 context.update( { "tasks_count": self.count, "offset": offset, } ) context["tasks"] = tasks context["status"] = STATUS_CHOICES context["priority"] = PRIORITY_CHOICES context["accounts_list"] = AccountSerializer(accounts, many=True).data context["contacts_list"] = ContactSerializer(contacts, many=True).data return context
def post(self, request, pk, **kwargs): params = (self.request.query_params if len(self.request.data) == 0 else self.request.data) context = {} self.account_obj = Account.objects.get(pk=pk) if self.account_obj.org != request.org: return Response( { "error": True, "errors": "User company does not match with header...." }, status=status.HTTP_403_FORBIDDEN) if self.request.profile.role != "ADMIN" and not self.request.profile.is_admin: if not ( (self.request.profile == self.account_obj.created_by) or (self.request.profile in self.account_obj.assigned_to.all())): return Response( { "error": True, "errors": "You do not have Permission to perform this action", }, status=status.HTTP_403_FORBIDDEN, ) comment_serializer = CommentSerializer(data=params) if comment_serializer.is_valid(): if params.get("comment"): comment_serializer.save( account_id=self.account_obj.id, commented_by=self.request.profile, ) if self.request.FILES.get("account_attachment"): attachment = Attachments() attachment.created_by = self.request.profile attachment.file_name = self.request.FILES.get( "account_attachment").name attachment.account = self.account_obj attachment.attachment = self.request.FILES.get( "account_attachment") attachment.save() comments = Comment.objects.filter( account__id=self.account_obj.id).order_by("-id") attachments = Attachments.objects.filter( account__id=self.account_obj.id).order_by("-id") context.update({ "account_obj": AccountSerializer(self.account_obj).data, "attachments": AttachmentsSerializer(attachments, many=True).data, "comments": CommentSerializer(comments, many=True).data, }) return Response(context)
def create(self, request): a = Account() a_id, msg = a.register(request.data) if a_id: try: account = Account.objects.get(pk=a_id) except: return Response({'error': 'Not found'}, status=status.HTTP_404_NOT_FOUND) result = AccountSerializer(account) return Response(result.data) return Response({'error': msg}, status=status.HTTP_400_BAD_REQUEST)
class OpportunitySerializer(serializers.ModelSerializer): account = AccountSerializer() closed_by = UserSerializer() created_by = UserSerializer() company = CompanySerializer() tags = TagsSerializer(read_only=True, many=True) assigned_to = UserSerializer(read_only=True, many=True) contacts = ContactSerializer(read_only=True, many=True) teams = TeamsSerializer(read_only=True, many=True) opportunity_attachment = AttachmentsSerializer(read_only=True, many=True) class Meta: model = Opportunity # fields = ‘__all__’ fields = ( "id", "name", "stage", "currency", "amount", "lead_source", "probability", "contacts", "closed_by", "closed_on", "description", "assigned_to", "created_by", "created_on", "is_active", "tags", "opportunity_attachment", "teams", "company", "created_on_arrow", "account", # "get_team_users", # "get_team_and_assigned_users", # "get_assigned_users_not_in_teams", )
def get_context_data(self, **kwargs): params = (self.request.query_params if len(self.request.data) == 0 else self.request.data) queryset = self.model.objects.all() accounts = Account.objects.all() contacts = Contact.objects.all() if self.request.user.role != "ADMIN" and not self.request.user.is_superuser: queryset = queryset.filter( Q(assigned_to__in=[self.request.user]) | Q(created_by=self.request.user)) accounts = accounts.filter( Q(created_by=self.request.user) | Q(assigned_to=self.request.user)).distinct() contacts = contacts.filter( Q(created_by=self.request.user) | Q(assigned_to=self.request.user)).distinct() request_post = params if request_post: if request_post.get("title"): queryset = queryset.filter( title__icontains=request_post.get("title")) if request_post.get("status"): queryset = queryset.filter(status=request_post.get("status")) if request_post.get("priority"): queryset = queryset.filter( priority=request_post.get("priority")) context = {} search = False if params.get("title") or params.get("status") or params.get( "priority"): search = True context["search"] = search results_tasks = self.paginate_queryset(queryset.distinct(), self.request, view=self) tasks = TaskSerializer(results_tasks, many=True).data context["per_page"] = 10 context.update({ "tasks_count": self.count, "next": self.get_next_link(), "previous": self.get_previous_link(), "page_number": int(self.offset / 10) + 1, }) context["tasks"] = tasks context["status"] = STATUS_CHOICES context["priority"] = PRIORITY_CHOICES users = [] if self.request.user.role == "ADMIN" or self.request.user.is_superuser: users = User.objects.filter(is_active=True, ).order_by("email") elif self.request.user.google.all(): users = [] else: users = User.objects.filter(role="ADMIN", ).order_by("email") context["users"] = UserSerializer(users, many=True).data if self.request.user == "ADMIN": context["teams_list"] = TeamsSerializer(Teams.objects.all(), many=True).data context["accounts_list"] = AccountSerializer(accounts, many=True).data context["contacts_list"] = ContactSerializer(contacts, many=True).data return context
def get_context_data(self, **kwargs): params = ( self.request.query_params if len(self.request.data) == 0 else self.request.data ) queryset = self.model.objects.filter( org=self.request.org).order_by('-id') accounts = Account.objects.filter(org=self.request.org).order_by('-id') contacts = Contact.objects.filter(org=self.request.org).order_by('-id') profiles = Profile.objects.filter( is_active=True, org=self.request.org) if self.request.profile.role != "ADMIN" and not self.request.profile.is_admin: queryset = queryset.filter( Q(created_by=self.request.profile) | Q( assigned_to=self.request.profile) ).distinct() accounts = accounts.filter( Q(created_by=self.request.profile) | Q( assigned_to=self.request.profile) ).distinct() contacts = contacts.filter( Q(created_by=self.request.profile) | Q( assigned_to=self.request.profile) ).distinct() profiles = profiles.filter(role="ADMIN") if params: if params.get("name"): queryset = queryset.filter(name__icontains=params.get("name")) if params.get("status"): queryset = queryset.filter(status=params.get("status")) if params.get("priority"): queryset = queryset.filter(priority=params.get("priority")) if params.get("account"): queryset = queryset.filter(account=params.get("account")) context = {} results_cases = self.paginate_queryset( queryset, self.request, view=self) cases = CaseSerializer(results_cases, many=True).data if results_cases: offset = queryset.filter(id__gte=results_cases[-1].id).count() if offset == queryset.count(): offset = None else: offset = 0 context.update( { "cases_count": self.count, "offset": offset, } ) context["cases"] = cases context["status"] = STATUS_CHOICE context["priority"] = PRIORITY_CHOICE context["type_of_case"] = CASE_TYPE context["accounts_list"] = AccountSerializer(accounts, many=True).data context["contacts_list"] = ContactSerializer(contacts, many=True).data return context
def get_context_data(self, **kwargs): params = ( self.request.query_params if len(self.request.data) == 0 else self.request.data ) queryset = self.model.objects.filter(company=self.request.company) if self.request.user.role != "ADMIN" and not self.request.user.is_superuser: queryset = queryset.filter( Q(created_by=self.request.user) | Q(assigned_to=self.request.user) ).distinct() if params: request_post = params if request_post: if request_post.get("name"): queryset = queryset.filter(name__icontains=request_post.get("name")) if request_post.get("city"): queryset = queryset.filter( billing_city__contains=request_post.get("city") ) if request_post.get("industry"): queryset = queryset.filter( industry__icontains=request_post.get("industry") ) if request_post.get("tags"): queryset = queryset.filter(tags__in=json.loads(request_post.get("tags"))).distinct() context = {} search = False if ( params.get("name") or params.get("city") or params.get("industry") or params.get("tag") ): search = True context["search"] = search queryset_open = queryset.filter(status="open").order_by("id") results_accounts_open = self.paginate_queryset( queryset_open.distinct(), self.request, view=self) accounts_open = AccountSerializer( results_accounts_open, many=True ).data context["per_page"] = 10 context["active_accounts"] = { "accounts_count": self.count, "next": self.get_next_link(), "previous": self.get_previous_link(), "page_number":int(self.offset/10)+1, "open_accounts":accounts_open } queryset_close = queryset.filter(status="close").order_by("id") results_accounts_close = self.paginate_queryset( queryset_close.distinct(), self.request, view=self) accounts_close = AccountSerializer( results_accounts_close, many=True ).data context["closed_accounts"] = { "accounts_count": self.count, "next": self.get_next_link(), "previous": self.get_previous_link(), "page_number":int(self.offset/10)+1, "close_accounts":accounts_close } context["users"] = UserSerializer( User.objects.filter(is_active=True, company=self.request.company).order_by("email"), many=True ).data context["industries"] = INDCHOICES tag_ids = Account.objects.filter( company=self.request.company).values_list("tags", flat=True).distinct() context["tags"] = TagsSerailizer( Tags.objects.filter(id__in=tag_ids), many=True ).data if params.get("tag", None): context["request_tags"] = self.params.get("tag") else: context["request_tags"] = None TIMEZONE_CHOICES = [(tz, tz) for tz in pytz.common_timezones] context["timezones"] = TIMEZONE_CHOICES context["settings_timezone"] = settings.TIME_ZONE return context
def get_context_data(self, **kwargs): params = (self.request.query_params if len(self.request.data) == 0 else self.request.data) queryset = self.model.objects.filter(company=self.request.company) accounts = Account.objects.filter(company=self.request.company) if self.request.user.role != "ADMIN" and not self.request.user.is_superuser: queryset = queryset.filter( Q(created_by=self.request.user) | Q(assigned_to=self.request.user)).distinct() accounts = accounts.filter( Q(created_by=self.request.user) | Q(assigned_to=self.request.user)).distinct() if params: if params.get("invoice_title_or_number"): queryset = queryset.filter( Q(invoice_title__icontains=params.get( "invoice_title_or_number")) | Q(invoice_number__icontains=params.get( "invoice_title_or_number"))).distinct() if params.get("created_by"): queryset = queryset.filter(created_by=params.get("created_by")) if params.get("assigned_users"): queryset = queryset.filter( assigned_to__in=json.loads(params.get("assigned_users"))) if params.get("status"): queryset = queryset.filter(status=params.get("status")) if params.get("total_amount"): queryset = queryset.filter( total_amount__icontains=params.get("total_amount")) context = {} search = False if (params.get("invoice_title_or_number") or params.get("created_by") or params.get("assigned_users") or params.get("status") or params.get("total_amount")): search = True context["search"] = search results_invoice = self.paginate_queryset(queryset.distinct(), self.request, view=self) invoices = InvoiceSerailizer(results_invoice, many=True).data context["per_page"] = 10 context.update({ "invoices_count": self.count, "next": self.get_next_link(), "previous": self.get_previous_link(), "page_number": int(self.offset / 10) + 1, }) context["invoices"] = invoices context["users"] = UserSerializer( User.objects.filter( is_active=True, company=self.request.company).order_by("email"), many=True, ).data context["accounts_list"] = AccountSerializer(accounts, many=True).data if self.request.user == "ADMIN": context["teams_list"] = TeamsSerializer( Teams.objects.filter(company=self.request.company), many=True).data context["status"] = INVOICE_STATUS context["currency"] = CURRENCY_CODES context["countries"] = COUNTRIES return context
def get(self, request, pk, format=None): self.invoice = self.get_object(pk=pk) if self.invoice.company != request.company: return Response( { "error": True, "errors": "User company doesnot match with header...." }, status=status.HTTP_404_NOT_FOUND, ) context = {} context["invoice_obj"] = InvoiceSerailizer(self.invoice).data if self.request.user.role != "ADMIN" and not self.request.user.is_superuser: if not ((self.request.user == self.invoice.created_by) or (self.request.user in self.invoice.assigned_to.all())): return Response({ "error": True, "errors": "You don't have Permission to perform this action", }) comment_permission = (True if (self.request.user == self.invoice.created_by or self.request.user.is_superuser or self.request.user.role == "ADMIN") else False) if self.request.user.is_superuser or self.request.user.role == "ADMIN": users_mention = list( User.objects.filter( is_active=True, company=self.request.company, ).values("username")) elif self.request.user != self.invoice.created_by: if self.invoice.created_by: users_mention = [{ "username": self.invoice.created_by.username }] else: users_mention = [] else: users_mention = [] attachments = Attachments.objects.filter( invoice=self.invoice).order_by("-id") comments = Comment.objects.filter(invoice=self.invoice).order_by("-id") context.update({ "attachments": AttachmentsSerializer(attachments, many=True).data, "comments": CommentSerializer(comments, many=True).data, "invoice_history": InvoiceHistorySerializer(self.invoice.invoice_history.all(), many=True).data, "accounts": AccountSerializer(self.invoice.accounts.all(), many=True).data, "users": UserSerializer( User.objects.filter( is_active=True, company=self.request.company, ).order_by("email"), many=True, ).data, "comment_permission": comment_permission, "users_mention": users_mention, "status": INVOICE_STATUS, "currency": CURRENCY_CODES, "countries": COUNTRIES, }) return Response(context)
def get_context_data(self, **kwargs): params = (self.request.query_params if len(self.request.data) == 0 else self.request.data) queryset = self.model.objects.filter(company=self.request.company) accounts = Account.objects.filter(company=self.request.company) contacts = Contact.objects.filter(company=self.request.company) users = User.objects.filter(is_active=True, company=self.request.company) if self.request.user.role != "ADMIN" and not self.request.user.is_superuser: queryset = queryset.filter( Q(created_by=self.request.user) | Q(assigned_to=self.request.user)).distinct() accounts = accounts.filter( Q(created_by=self.request.user) | Q(assigned_to=self.request.user)).distinct() contacts = contacts.filter( Q(created_by=self.request.user) | Q(assigned_to=self.request.user)).distinct() users = users.filter(role="ADMIN") if params: if params.get("name"): queryset = queryset.filter(name__icontains=params.get("name")) if params.get("status"): queryset = queryset.filter(status=params.get("status")) if params.get("priority"): queryset = queryset.filter(priority=params.get("priority")) if params.get("account"): queryset = queryset.filter(account=params.get("account")) context = {} search = False if (params.get("name") or params.get("status") or params.get("priority") or params.get("account")): search = True context["search"] = search results_cases = self.paginate_queryset(queryset, self.request, view=self) cases = CaseSerializer(results_cases, many=True).data context["per_page"] = 10 context.update({ "cases_count": self.count, "next": self.get_next_link(), "previous": self.get_previous_link(), "page_number": int(self.offset / 10) + 1, }) if search: context["cases"] = cases return context context["cases"] = cases context["users"] = UserSerializer(users, many=True).data context["status"] = STATUS_CHOICE context["priority"] = PRIORITY_CHOICE context["type_of_case"] = CASE_TYPE context["accounts_list"] = AccountSerializer(accounts, many=True).data context["contacts_list"] = ContactSerializer(contacts, many=True).data if self.request.user == "ADMIN": context["teams_list"] = TeamsSerializer( Teams.objects.filter(company=self.request.company), many=True).data return context
def get(self, request, pk, format=None): context = {} context["account_obj"] = AccountSerializer(self.account).data if self.request.user.role != "ADMIN" and not self.request.user.is_superuser: if not ((self.request.user == self.account.created_by) or (self.request.user in self.account.assigned_to.all())): raise PermissionDenied comment_permission = (True if (self.request.user == self.account.created_by or self.request.user.is_superuser or self.request.user.role == "ADMIN") else False) if self.request.user.is_superuser or self.request.user.role == "ADMIN": users_mention = list( User.objects.filter( is_active=True, company=self.request.company, ).values("username")) elif self.request.user != self.account.created_by: if self.account.created_by: users_mention = [{ "username": self.account.created_by.username }] else: users_mention = [] else: users_mention = [] context.update({ "comments": CommentSerializer(self.account.accounts_comments.all(), many=True).data, "attachments": AttachmentsSerializer(self.account.account_attachment.all(), many=True).data, "opportunity_list": OpportunitySerializer( Opportunity.objects.filter(account=self.account), many=True).data, "contacts": ContactSerializer(self.account.contacts.all(), many=True).data, "users": UserSerializer( User.objects.filter( is_active=True, company=self.request.company, ).order_by("email"), many=True, ).data, "cases": CaseSerializer(Case.objects.filter(account=self.account), many=True).data, "stages": STAGES, "sources": SOURCES, "countries": COUNTRIES, "currencies": CURRENCY_CODES, "case_types": CASE_TYPE, "case_priority": PRIORITY_CHOICE, "case_status": STATUS_CHOICE, "comment_permission": comment_permission, "tasks": TaskSerializer(self.account.accounts_tasks.all(), many=True).data, "invoices": InvoiceSerailizer(self.account.accounts_invoices.all(), many=True).data, "emails": EmailSerailizer(self.account.sent_email.all(), many=True).data, "users_mention": users_mention, }) return Response(context)
def get_context_data(self, **kwargs): params = (self.request.query_params if len(self.request.data) == 0 else self.request.data) queryset = self.model.objects.filter( org=self.request.org).order_by('-id') if self.request.profile.role != "ADMIN" and not self.request.profile.is_admin: queryset = queryset.filter( Q(created_by=self.request.profile) | Q(assigned_to=self.request.profile)).distinct() if params: if params.get("name"): queryset = queryset.filter(name__icontains=params.get("name")) if params.get("city"): queryset = queryset.filter( billing_city__contains=params.get("city")) if params.get("industry"): queryset = queryset.filter( industry__icontains=params.get("industry")) if params.get("tags"): queryset = queryset.filter( tags__in=json.loads(params.get("tags"))).distinct() context = {} queryset_open = queryset.filter(status="open") results_accounts_open = self.paginate_queryset( queryset_open.distinct(), self.request, view=self) if results_accounts_open: offset = queryset_open.filter( id__gte=results_accounts_open[-1].id).count() if offset == queryset_open.count(): offset = None else: offset = 0 accounts_open = AccountSerializer(results_accounts_open, many=True).data context["per_page"] = 10 context["active_accounts"] = { "offset": offset, "open_accounts": accounts_open, } queryset_close = queryset.filter(status="close") results_accounts_close = self.paginate_queryset( queryset_close.distinct(), self.request, view=self) if results_accounts_close: offset = queryset_close.filter( id__gte=results_accounts_close[-1].id).count() if offset == queryset_close.count(): offset = None else: offset = 0 accounts_close = AccountSerializer(results_accounts_close, many=True).data context["closed_accounts"] = { "offset": offset, "close_accounts": accounts_close, } context["industries"] = INDCHOICES return context
def get_context_data(self, **kwargs): params = ( self.request.query_params if len(self.request.data) == 0 else self.request.data ) queryset = self.model.objects.filter(company=self.request.company) accounts = Account.objects.filter(company=self.request.company) contacts = Contact.objects.filter(company=self.request.company) if self.request.user.role != "ADMIN" and not self.request.user.is_superuser: queryset = queryset.filter( Q(created_by=self.request.user) | Q(assigned_to=self.request.user) ).distinct() accounts = accounts.filter( Q(created_by=self.request.user) | Q(assigned_to=self.request.user) ).distinct() contacts = contacts.filter( Q(created_by=self.request.user) | Q(assigned_to=self.request.user) ).distinct() if params: request_post = params if request_post.get("name"): queryset = queryset.filter( name__icontains=request_post.get("name") ) if request_post.get("account"): queryset = queryset.filter( account=request_post.get("account") ) if request_post.get("stage"): queryset = queryset.filter( stage__contains=request_post.get("stage") ) if request_post.get("lead_source"): queryset = queryset.filter( lead_source__contains=request_post.get("lead_source") ) if request_post.get("tags"): queryset = queryset.filter( tags__in=json.loads(request_post.get("tags")) ).distinct() context = {} search = False if ( params.get("name") or params.get("account") or params.get("stage") or params.get("lead_source") or params.get("tags") ): search = True context["search"] = search opportunities = OpportunitySerializer( queryset, many=True ).data context["opportunities"] = opportunities context["users"] = UserSerializer( User.objects.filter(is_active=True, company=self.request.company).order_by("email"), many=True ).data tag_ids = list(set(Opportunity.objects.filter( company=self.request.company).values_list("tags", flat=True))) context["tags"] = TagsSerializer( Tags.objects.filter(id__in=tag_ids), many=True ).data context["accounts_list"] = AccountSerializer( accounts, many=True ).data context["contacts_list"] = ContactSerializer( contacts, many=True ).data if self.request.user == "ADMIN": context["teams_list"] = TeamsSerializer( Teams.objects.filter(company=self.request.company), many=True ).data context["stage"] = STAGES context["lead_source"] = SOURCES context["currency"] = CURRENCY_CODES return context
def get(self, request, pk, format=None): self.account = self.get_object(pk=pk) if self.account.org != request.org: return Response( { "error": True, "errors": "User company doesnot match with header...." }, status=status.HTTP_404_NOT_FOUND, ) context = {} context["account_obj"] = AccountSerializer(self.account).data if self.request.profile.role != "ADMIN" and not self.request.profile.is_admin: if not ((self.request.profile == self.account.created_by) or (self.request.profile in self.account.assigned_to.all())): return Response( { "error": True, "errors": "You do not have Permission to perform this action", }, status=status.HTTP_403_FORBIDDEN, ) comment_permission = False if (self.request.profile == self.account.created_by or self.request.profile.is_admin or self.request.profile.role == "ADMIN"): comment_permission = True if self.request.profile.is_admin or self.request.profile.role == "ADMIN": users_mention = list( Profile.objects.filter( is_active=True, org=self.request.org).values("user__username")) elif self.request.profile != self.account.created_by: if self.account.created_by: users_mention = [{ "username": self.account.created_by.user.username }] else: users_mention = [] else: users_mention = [] context.update({ "attachments": AttachmentsSerializer(self.account.account_attachment.all(), many=True).data, "comments": CommentSerializer(self.account.accounts_comments.all(), many=True).data, "contacts": ContactSerializer(self.account.contacts.all(), many=True).data, "opportunity_list": OpportunitySerializer( Opportunity.objects.filter(account=self.account), many=True).data, "users": ProfileSerializer( Profile.objects.filter( is_active=True, org=self.request.org).order_by("user__email"), many=True, ).data, "cases": CaseSerializer(self.account.accounts_cases.all(), many=True).data, "stages": STAGES, "sources": SOURCES, "countries": COUNTRIES, "currencies": CURRENCY_CODES, "case_types": CASE_TYPE, "case_priority": PRIORITY_CHOICE, "case_status": STATUS_CHOICE, "comment_permission": comment_permission, "tasks": TaskSerializer(self.account.accounts_tasks.all(), many=True).data, "invoices": InvoiceSerailizer(self.account.accounts_invoices.all(), many=True).data, "emails": EmailSerializer(self.account.sent_email.all(), many=True).data, "users_mention": users_mention, }) return Response(context)