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)
