def get_context_data(self, **kwargs):
context = {}
open_leads = self.get_queryset().exclude(status="closed")
close_leads = self.get_queryset().filter(status="closed")
context["status"] = LEAD_STATUS
context["open_leads"] = LeadSerializer(open_leads, many=True).data
context["close_leads"] = LeadSerializer(close_leads, many=True).data
context["source"] = LEAD_SOURCE
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
tag_ids = list(
set(
self.get_queryset().values_list(
"tags",
flat=True,
)
)
)
context["tags"] = TagsSerailizer(
Tags.objects.filter(id__in=tag_ids), many=True).data
context["countries"] = COUNTRIES
return context
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 ClientQuotationSerializer(serializers.ModelSerializer):
lead = LeadSerializer('lead')
home_type_from = HomeTypeSerializer('home_type_from')
home_type_to = HomeTypeSerializer('home_type_to')
truck_size_type = TruckSizeTypeSerializer('truck_size_type')
class Meta:
model = ClientQuotation
fields = '__all__'
def post(self, request, pk, **kwargs):
params = (
self.request.query_params
if len(self.request.data) == 0
else self.request.data
)
context = {}
self.lead_obj = Lead.objects.get(pk=pk)
if self.lead_obj.org != request.org:
return Response(
{"error": True, "errors": "User company doesnot match with header...."},
status=status.HTTP_403_FORBIDDEN
)
if self.request.profile.role != "ADMIN" and not self.request.user.is_superuser:
if not (
(self.request.profile == self.lead_obj.created_by)
or (self.request.profile in self.lead_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(
lead_id=self.lead_obj.id,
commented_by_id=self.request.profile.id,
)
if self.request.FILES.get("lead_attachment"):
attachment = Attachments()
attachment.created_by = self.request.profile
attachment.file_name = self.request.FILES.get(
"lead_attachment").name
attachment.lead = self.lead_obj
attachment.attachment = self.request.FILES.get(
"lead_attachment")
attachment.save()
comments = Comment.objects.filter(
lead__id=self.lead_obj.id).order_by("-id")
attachments = Attachments.objects.filter(lead__id=self.lead_obj.id).order_by(
"-id"
)
context.update(
{
"lead_obj": LeadSerializer(self.lead_obj).data,
"attachments": AttachmentsSerializer(attachments, many=True).data,
"comments": LeadCommentSerializer(comments, many=True).data,
}
)
return Response(context)
class QuotationSerializer(serializers.ModelSerializer):
lead = LeadSerializer('lead')
home_type_from = HomeTypeSerializer('home_type_from')
home_type_to = HomeTypeSerializer('home_type_to')
truck_size_type = TruckSizeTypeSerializer('truck_size_type')
assigned_truck = TruckSerializer('assigned_truck')
assigned_driver = DriverSerializer('assigned_driver')
inventory = InventoryStuffSerializer(source='inventorystuff_set',
many=True)
class Meta:
model = Quotation
fields = '__all__'
class AccountSerializer(serializers.ModelSerializer):
created_by = UserSerializer()
lead = LeadSerializer()
company = CompanySerializer()
tags = TagsSerailizer(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)
class Meta:
model = Account
# fields = ‘__all__’
fields = ('id', "name", "email", "phone", "industry",
"billing_address_line", "billing_street", "billing_city",
"billing_state", "billing_postcode", "billing_country",
"website", "description", "created_by", "created_on",
"is_active", "tags", "status", "lead", "contact_name",
"contacts", "assigned_to", "teams", "company")
class AccountSerializer(serializers.ModelSerializer):
created_by = ProfileSerializer()
lead = LeadSerializer()
org = OrganizationSerializer()
tags = TagsSerailizer(read_only=True, many=True)
assigned_to = ProfileSerializer(read_only=True, many=True)
contacts = ContactSerializer(read_only=True, many=True)
teams = TeamsSerializer(read_only=True, many=True)
account_attachment = AttachmentsSerializer(read_only=True, many=True)
class Meta:
model = Account
# fields = ‘__all__’
fields = ("id", "name", "email", "phone", "industry",
"billing_address_line", "billing_street", "billing_city",
"billing_state", "billing_postcode", "billing_country",
"website", "description", "account_attachment", "created_by",
"created_on", "is_active", "tags", "status", "lead",
"contact_name", "contacts", "assigned_to", "teams", "org")
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)
.exclude(status="converted")
.select_related("created_by")
.prefetch_related(
"tags",
"assigned_to",
)
)
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)
)
request_post = params
if request_post:
if request_post.get("name"):
queryset = queryset.filter(
Q(first_name__icontains=request_post.get("name"))
& Q(last_name__icontains=request_post.get("name"))
)
if request_post.get("title"):
queryset = queryset.filter(title__icontains=request_post.get("title"))
if request_post.get("source"):
queryset = queryset.filter(source=request_post.get("source"))
if request_post.getlist("assigned_to"):
queryset = queryset.filter(
assigned_to__id__in=json.loads(request_post.get("assigned_to"))
)
if request_post.get("status"):
queryset = queryset.filter(status=request_post.get("status"))
if request_post.get("tags"):
queryset = queryset.filter(
tags__in=json.loads(request_post.get("tags"))
)
if request_post.get("city"):
queryset = queryset.filter(city__icontains=request_post.get("city"))
if request_post.get("email"):
queryset = queryset.filter(email__icontains=request_post.get("email"))
context = {}
search = False
if (
params.get("title")
or params.get("source")
or params.get("assigned_to")
or params.get("status")
or params.get("tags")
):
search = True
context["search"] = search
open_leads = queryset.exclude(status="closed").distinct()
close_leads = queryset.filter(status="closed").distinct()
if search:
context["open_leads"] = LeadSerializer(open_leads, many=True).data
return context
context["open_leads"] = LeadSerializer(open_leads, many=True).data
context["close_leads"] = LeadSerializer(close_leads, many=True).data
context["status"] = LEAD_STATUS
context["source"] = LEAD_SOURCE
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
tag_ids = list(
set(
queryset.values_list(
"tags",
flat=True,
)
)
)
context["tags"] = TagsSerializer(
Tags.objects.filter(id__in=tag_ids), many=True
).data
context["countries"] = COUNTRIES
return context
def get_context_data(self, **kwargs):
params = (
self.request.query_params
if len(self.request.data) == 0
else self.request.data
)
context = {}
user_assgn_list = [
assigned_to.id for assigned_to in self.lead_obj.assigned_to.all()
]
if self.request.user == self.lead_obj.created_by:
user_assgn_list.append(self.request.user.id)
if self.request.user.role != "ADMIN" and not self.request.user.is_superuser:
if self.request.user.id not in user_assgn_list:
return Response(
{
"error": True,
"errors": "You do not have Permission to perform this action",
}
)
comments = Comment.objects.filter(lead=self.lead_obj).order_by("-id")
attachments = Attachments.objects.filter(lead=self.lead_obj).order_by("-id")
assigned_data = []
for each in self.lead_obj.assigned_to.all():
assigned_dict = {}
assigned_dict["id"] = each.id
assigned_dict["name"] = each.email
assigned_data.append(assigned_dict)
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.lead_obj.created_by:
users_mention = [{"username": self.lead_obj.created_by.username}]
else:
users_mention = list(self.lead_obj.assigned_to.all().values("username"))
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")
else:
users = User.objects.filter(
role="ADMIN", company=self.request.company
).order_by("email")
user_assgn_list = [
assigned_to.id
for assigned_to in self.lead_obj.get_assigned_users_not_in_teams
]
if self.request.user == self.lead_obj.created_by:
user_assgn_list.append(self.request.user.id)
if self.request.user.role != "ADMIN" and not self.request.user.is_superuser:
if self.request.user.id not in user_assgn_list:
return Response(
{
"error": True,
"errors": "You do not have Permission to perform this action",
}
)
team_ids = [user.id for user in self.lead_obj.get_team_users]
all_user_ids = [user.id for user in users]
users_excluding_team_id = set(all_user_ids) - set(team_ids)
users_excluding_team = User.objects.filter(id__in=users_excluding_team_id)
context.update(
{
"lead_obj": LeadSerializer(self.lead_obj).data,
"attachments": AttachmentsSerializer(attachments, many=True).data,
"comments": LeadCommentSerializer(comments, many=True).data,
"users_mention": users_mention,
"assigned_data": assigned_data,
}
)
context["users"] = UserSerializer(users, many=True).data
context["users_excluding_team"] = UserSerializer(
users_excluding_team, many=True
).data
context["source"] = LEAD_SOURCE
context["status"] = LEAD_STATUS
context["teams"] = TeamsSerializer(
Teams.objects.filter(company=self.request.company), many=True
).data
context["countries"] = COUNTRIES
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.all().exclude(
status="converted").select_related("created_by").prefetch_related(
"tags",
"assigned_to",
))
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))
request_post = params
if request_post:
if request_post.get("name"):
queryset = queryset.filter(
Q(first_name__icontains=request_post.get("name"))
& Q(last_name__icontains=request_post.get("name")))
if request_post.get("title"):
queryset = queryset.filter(
title__icontains=request_post.get("title"))
if request_post.get("source"):
queryset = queryset.filter(source=request_post.get("source"))
if request_post.getlist("assigned_to"):
queryset = queryset.filter(assigned_to__id__in=json.loads(
request_post.get("assigned_to")))
if request_post.get("status"):
queryset = queryset.filter(status=request_post.get("status"))
if request_post.get("tags"):
queryset = queryset.filter(
tags__in=json.loads(request_post.get("tags")))
if request_post.get("city"):
queryset = queryset.filter(
city__icontains=request_post.get("city"))
if request_post.get("email"):
queryset = queryset.filter(
email__icontains=request_post.get("email"))
context = {}
search = False
if (params.get("title") or params.get("source")
or params.get("assigned_to") or params.get("status")
or params.get("tags")):
search = True
context["search"] = search
queryset_open = queryset.exclude(status="closed").order_by("id")
results_leads_open = self.paginate_queryset(queryset_open.distinct(),
self.request,
view=self)
open_leads = LeadSerializer(results_leads_open, many=True).data
context["per_page"] = 10
context["open_leads"] = {
"leads_count": self.count,
"next": self.get_next_link(),
"previous": self.get_previous_link(),
"page_number": int(self.offset / 10) + 1,
"open_leads": open_leads,
}
queryset_close = queryset.filter(status="closed").order_by("id")
results_leads_close = self.paginate_queryset(queryset_close.distinct(),
self.request,
view=self)
close_leads = LeadSerializer(results_leads_close, many=True).data
context["close_leads"] = {
"leads_count": self.count,
"next": self.get_next_link(),
"previous": self.get_previous_link(),
"page_number": int(self.offset / 10) + 1,
"close_leads": close_leads,
}
context["status"] = LEAD_STATUS
context["source"] = LEAD_SOURCE
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
tag_ids = list(set(queryset.values_list(
"tags",
flat=True,
)))
context["tags"] = TagsSerializer(Tags.objects.filter(id__in=tag_ids),
many=True).data
context["countries"] = COUNTRIES
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)
.exclude(status="converted")
.select_related("created_by")
.prefetch_related(
"tags",
"assigned_to",
)
).order_by('-id')
if self.request.profile.role != "ADMIN" and not self.request.user.is_superuser:
queryset = queryset.filter(
Q(assigned_to__in=[self.request.profile]) | Q(
created_by=self.request.profile)
)
if params:
if params.get("name"):
queryset = queryset.filter(
Q(first_name__icontains=params.get("name"))
& Q(last_name__icontains=params.get("name"))
)
if params.get("title"):
queryset = queryset.filter(
title__icontains=params.get("title"))
if params.get("source"):
queryset = queryset.filter(source=params.get("source"))
if params.getlist("assigned_to"):
queryset = queryset.filter(
assigned_to__id__in=json.loads(
params.get("assigned_to"))
)
if params.get("status"):
queryset = queryset.filter(status=params.get("status"))
if params.get("tags"):
queryset = queryset.filter(
tags__in=json.loads(params.get("tags"))
)
if params.get("city"):
queryset = queryset.filter(
city__icontains=params.get("city"))
if params.get("email"):
queryset = queryset.filter(
email__icontains=params.get("email"))
context = {}
queryset_open = queryset.exclude(status="closed")
results_leads_open = self.paginate_queryset(
queryset_open.distinct(), self.request, view=self
)
open_leads = LeadSerializer(results_leads_open, many=True).data
if results_leads_open:
offset = queryset_open.filter(
id__gte=results_leads_open[-1].id).count()
if offset == queryset_open.count():
offset = None
else:
offset = 0
context["per_page"] = 10
context["open_leads"] = {
"leads_count": self.count,
"open_leads": open_leads,
"offset": offset
}
queryset_close = queryset.filter(status="closed")
results_leads_close = self.paginate_queryset(
queryset_close.distinct(), self.request, view=self
)
close_leads = LeadSerializer(results_leads_close, many=True).data
if results_leads_close:
offset = queryset_close.filter(
id__gte=results_leads_close[-1].id).count()
if offset == queryset_close.count():
offset = None
else:
offset = 0
context["close_leads"] = {
"leads_count": self.count,
"close_leads": close_leads,
"offset": offset
}
contacts = Contact.objects.filter(org=self.request.org).values(
"id",
"first_name"
)
context["contacts"] = contacts
context["status"] = LEAD_STATUS
context["source"] = LEAD_SOURCE
context["companies"] = CompanySerializer(
Company.objects.filter(org=self.request.org), many=True).data
context["tags"] = TagsSerializer(Tags.objects.all(),many=True).data
users = Profile.objects.filter(is_active=True, org=self.request.org).values(
"id",
"user__email")
context["users"]=users
context["countries"] = COUNTRIES
context["industries"] = INDCHOICES
return context
