class TaskSerializer(serializers.ModelSerializer):
created_by = ProfileSerializer()
assigned_to = ProfileSerializer(read_only=True, many=True)
contacts = ContactSerializer(read_only=True, many=True)
teams = TeamsSerializer(read_only=True, many=True)
task_attachment = AttachmentsSerializer(read_only=True, many=True)
task_comments = CommentSerializer(read_only=True, many=True)
class Meta:
model = Task
fields = (
"id",
"title",
"status",
"priority",
"due_date",
"account",
"created_by",
"created_on",
"contacts",
"teams",
"assigned_to",
"task_attachment",
"task_comments",
)
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)
request_post = params
if request_post:
if request_post.get("team_name"):
queryset = queryset.filter(
name__icontains=request_post.get("team_name"))
if request_post.get("created_by"):
queryset = queryset.filter(
created_by=request_post.get("created_by"))
if request_post.get("assigned_users"):
queryset = queryset.filter(users__id__in=json.loads(
request_post.get("assigned_users")))
context = {}
search = False
if (params.get("team_name") or params.get("created_by")
or params.get("assigned_users")):
search = True
context["search"] = search
context["teams"] = TeamsSerializer(queryset.distinct(), many=True).data
users = User.objects.filter(
is_active=True, company=self.request.company).order_by("id")
context["users"] = UserSerializer(users, many=True).data
return context
class ContactSerializer(serializers.ModelSerializer):
created_by = UserSerializer()
company = CompanySerializer()
teams = TeamsSerializer(read_only=True, many=True)
assigned_to = UserSerializer(read_only=True, many=True)
address = BillingAddressSerializer(read_only=True)
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 = Contact
fields = (
'id',
"first_name",
"last_name",
"email",
"phone",
"address",
"description",
"assigned_to",
"created_by",
"created_on",
"is_active",
"teams",
"company",
"created_on_arrow",
"get_team_users",
"get_team_and_assigned_users",
"get_assigned_users_not_in_teams",
)
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_context_data(self, **kwargs):
params = self.request.query_params if len(
self.request.data) == 0 else request.data
context = {}
context["contact_obj"] = ContactSerializer(self.contact).data
user_assgn_list = [
assigned_to.id for assigned_to in self.contact.assigned_to.all()
]
if self.request.user.role == "ADMIN" or self.request.user.is_superuser:
self.users = User.objects.filter(
is_active=True, company=self.request.company).order_by("email")
else:
self.users = User.objects.filter(
role="ADMIN", company=self.request.company).order_by("email")
if self.request.user == self.contact.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:
raise PermissionDenied
context["address_obj"] = BillingAddressSerializer(
self.contact.address).data
context["users"] = UserSerializer(self.users, many=True).data
context["countries"] = COUNTRIES
context["teams"] = TeamsSerializer(
Teams.objects.filter(company=self.request.company), many=True).data
context["assignedto_list"] = [
int(i) for i in params.getlist("assigned_to", []) if i
]
return context
class EventSerializer(serializers.ModelSerializer):
created_by = ProfileSerializer()
assigned_to = ProfileSerializer(read_only=True, many=True)
contacts = ContactSerializer(read_only=True, many=True)
teams = TeamsSerializer(read_only=True, many=True)
event_attachment = AttachmentsSerializer(read_only=True, many=True)
event_comments = CommentSerializer(read_only=True, many=True)
org = OrganizationSerializer()
class Meta:
model = Event
fields = (
"id",
"name",
"event_type",
"status",
"is_active",
"disabled",
"start_date",
"start_time",
"end_date",
"end_time",
"description",
"date_of_meeting",
"created_by",
"created_on",
"contacts",
"teams",
"assigned_to",
"event_attachment",
"event_comments",
"org"
)
def get_context_data(self, **kwargs):
params = self.request.query_params if len(
self.request.data) == 0 else self.request.data
context = {}
if self.request.user.role == "ADMIN" or self.request.user.is_superuser:
self.users = User.objects.filter(
is_active=True, company=self.request.company).order_by("email")
else:
self.users = User.objects.filter(
role="ADMIN", company=self.request.company).order_by("email")
context["users"] = UserSerializer(self.users, many=True).data
context["countries"] = COUNTRIES
context["assignedto_list"] = [
int(i) for i in params.getlist("assigned_to", []) if i
]
context["teams"] = TeamsSerializer(
Teams.objects.filter(company=self.request.company), many=True).data
context["contact_obj_list"] = ContactSerializer(
self.get_queryset(params), many=True).data
context["per_page"] = params.get("per_page")
context["assignedto_list"] = [
int(i) for i in params.getlist("assigned_to", []) if i
]
search = False
if (params.get("first_name") or params.get("city")
or params.get("phone") or params.get("email")
or params.get("assigned_to")):
search = True
context["search"] = search
return context
def get(self, request, pk, **kwargs):
if self.request.user.role != "ADMIN" and not self.request.user.is_superuser:
return Response(
{
"error": True,
"errors":
"You don't have permission to perform this action.",
},
status=status.HTTP_403_FORBIDDEN,
)
self.team_obj = self.get_object(pk)
if self.team_obj.company != request.company:
return Response({
"error":
True,
"errors":
"User company doesnot match with header...."
})
context = {}
context["team"] = TeamsSerializer(self.team_obj).data
context["users"] = UserSerializer(
User.objects.filter(
is_active=True,
company=self.request.company).order_by("email"),
many=True,
).data
return Response(context)
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",
)
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(self, request, *args, **kwargs):
data = {}
teams = Teams.objects.filter(org=request.org).order_by('-id')
teams_data = TeamsSerializer(teams, many=True).data
profiles = Profile.objects.filter(
is_active=True, org=request.org).order_by('user__email')
profiles_data = ProfileSerializer(profiles, many=True).data
data["teams"] = teams_data
data["profiles"] = profiles_data
return Response(data)
def get(self, request, *args, **kwargs):
data = {}
teams = Teams.objects.filter(company=request.company)
teams_data = TeamsSerializer(teams, many=True).data
users = User.objects.filter(company=request.company)
users_data = UserSerializer(users, many=True).data
users = User.objects.all().values_list("id", flat=True)
data["teams"] = teams_data
data["users_data"] = users_data
data["users"] = list(users)
return Response(data)
def get(self, request, pk, **kwargs):
if self.request.profile.role != "ADMIN" and not self.request.profile.is_admin:
return Response(
{
"error": True,
"errors": "You don't have permission to perform this action.",
},
status=status.HTTP_403_FORBIDDEN,
)
self.team_obj = self.get_object(pk)
context = {}
context["team"] = TeamsSerializer(self.team_obj).data
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).order_by("-created_on")
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)).distinct()
request_post = params
if request_post:
if request_post.get("name"):
queryset = queryset.filter(
first_name__icontains=request_post.get("name"))
if request_post.get("city"):
queryset = queryset.filter(
address__city__icontains=request_post.get("city"))
if request_post.get("phone"):
queryset = queryset.filter(
phone__icontains=request_post.get("phone"))
if request_post.get("email"):
queryset = queryset.filter(
email__icontains=request_post.get("email"))
if request_post.getlist("assigned_to"):
queryset = queryset.filter(assigned_to__id__in=json.loads(
request_post.get("assigned_to"))).distinct()
context = {}
search = False
if (params.get("first_name") or params.get("city")
or params.get("phone") or params.get("email")
or params.get("assigned_to")):
search = True
context["search"] = search
context["contact_obj_list"] = ContactSerializer(queryset,
many=True).data
context["users"] = UserSerializer(
User.objects.filter(
is_active=True,
company=self.request.company).order_by("email"),
many=True,
).data
context["countries"] = COUNTRIES
context["teams"] = TeamsSerializer(
Teams.objects.filter(company=self.request.company), many=True).data
context["per_page"] = params.get("per_page")
context["assignedto_list"] = UserSerializer(
User.objects.filter(company=self.request.company), many=True).data
return context
def get(self, request, format=None):
users = []
if request.user.role == "ADMIN" or request.user.is_superuser:
users = User.objects.filter(
is_active=True, company=request.company).order_by("email")
else:
users = User.objects.filter(
role="ADMIN", company=request.company).order_by("email")
context = {}
context["users"] = UserSerializer(users, many=True).data
teams = Teams.objects.filter(company=request.company)
context["teams"] = TeamsSerializer(teams, many=True).data
context['status'] = (("active", "active"), ("inactive", "inactive"))
return Response(context)
def get(self, request, *args, **kwargs):
if self.request.user.role != "ADMIN" and not self.request.user.is_superuser:
return Response({
"error": True,
"Message": "Permission Denied"
},
status=status.HTTP_403_FORBIDDEN)
data = {}
teams = Teams.objects.filter(company=request.company)
teams_data = TeamsSerializer(teams, many=True).data
users = User.objects.filter(company=request.company, is_active=True)
users_data = UserSerializer(users, many=True).data
data["teams"] = teams_data
data["users_data"] = users_data
return Response(data)
class ContactSerializer(serializers.ModelSerializer):
created_by = ProfileSerializer()
teams = TeamsSerializer(read_only=True, many=True)
assigned_to = ProfileSerializer(read_only=True, many=True)
address = BillingAddressSerializer(read_only=True)
get_team_users = ProfileSerializer(read_only=True, many=True)
get_team_and_assigned_users = ProfileSerializer(read_only=True, many=True)
get_assigned_users_not_in_teams = ProfileSerializer(read_only=True, many=True)
contact_attachment = AttachmentsSerializer(read_only=True, many=True)
date_of_birth = serializers.DateField()
org = OrganizationSerializer()
class Meta:
model = Contact
fields = (
"id",
"salutation",
"first_name",
"last_name",
"date_of_birth",
"organization",
"title",
"primary_email",
"secondary_email",
"mobile_number",
"secondary_number",
"department",
"language",
"do_not_call",
"address",
"description",
"linked_in_url",
"facebook_url",
"twitter_username",
"contact_attachment",
"assigned_to",
"created_by",
"created_on",
"is_active",
"teams",
"created_on_arrow",
"get_team_users",
"get_team_and_assigned_users",
"get_assigned_users_not_in_teams",
"org"
)
def get_context_data(self, **kwargs):
params = self.request.query_params if len(
self.request.data) == 0 else request.data
context = {}
if self.request.user.role == "ADMIN" or self.request.user.is_superuser:
self.users = User.objects.filter(
is_active=True, company=self.request.company).order_by("email")
else:
self.users = User.objects.filter(
role="ADMIN", company=self.request.company).order_by("email")
context["users"] = UserSerializer(self.users, many=True).data
context["countries"] = COUNTRIES
context["assignedto_list"] = [
int(i) for i in params.getlist("assigned_to", []) if i
]
context["teams"] = TeamsSerializer(
Teams.objects.filter(company=self.request.company), many=True).data
return context
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")
class LeadSerializer(serializers.ModelSerializer):
assigned_to = UserSerializer(read_only=True, many=True)
created_by = UserSerializer()
tags = TagsSerializer(read_only=True, many=True)
lead_attachment = AttachmentsSerializer(read_only=True, many=True)
teams = TeamsSerializer(read_only=True, many=True)
company = CompanySerializer()
lead_comments = LeadCommentSerializer(read_only=True, many=True)
class Meta:
model = Lead
# fields = ‘__all__’
fields = (
"id",
"title",
"first_name",
"last_name",
"phone",
"email",
"status",
"source",
"address_line",
"street",
"city",
"state",
"postcode",
"country",
"website",
"description",
"lead_attachment",
"lead_comments",
"assigned_to",
"account_name",
"opportunity_amount",
"created_by",
"created_on",
"is_active",
"enquery_type",
"tags",
"created_from_site",
"teams",
"company",
)
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()
request_post = params
if request_post:
if request_post.get("team_name"):
queryset = queryset.filter(
name__icontains=request_post.get("team_name"))
if request_post.get("created_by"):
queryset = queryset.filter(
created_by=request_post.get("created_by"))
if request_post.get("assigned_users"):
queryset = queryset.filter(users__id__in=json.loads(
request_post.get("assigned_users")))
context = {}
search = False
if (params.get("team_name") or params.get("created_by")
or params.get("assigned_users")):
search = True
context["search"] = search
results_teams = self.paginate_queryset(queryset.distinct(),
self.request,
view=self)
teams = TeamsSerializer(results_teams, many=True).data
context["per_page"] = 10
context.update({
"teams_count": self.count,
"next": self.get_next_link(),
"previous": self.get_previous_link(),
"page_number": int(self.offset / 10) + 1,
})
context["teams"] = teams
users = User.objects.filter(is_active=True, ).order_by("id")
context["users"] = UserSerializer(users, many=True).data
return context
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.filter(org=self.request.org).order_by('-id')
if params:
if params.get("team_name"):
queryset = queryset.filter(
name__icontains=params.get("team_name")
)
if params.get("created_by"):
queryset = queryset.filter(created_by=params.get("created_by"))
if params.get("assigned_users"):
queryset = queryset.filter(
users__id__in=json.loads(params.get("assigned_users"))
)
context = {}
results_teams = self.paginate_queryset(
queryset.distinct(), self.request, view=self
)
teams = TeamsSerializer(results_teams, many=True).data
if results_teams:
offset = queryset.filter(id__gte=results_teams[-1].id).count()
if offset == queryset.count():
offset = None
else:
offset = 0
context.update(
{
"teams_count": self.count,
"offset": offset
}
)
context["teams"] = teams
return context
class LeadSerializer(serializers.ModelSerializer):
assigned_to = ProfileSerializer(read_only=True, many=True)
created_by = ProfileSerializer()
country = serializers.SerializerMethodField()
tags = TagsSerializer(read_only=True, many=True)
lead_attachment = AttachmentsSerializer(read_only=True, many=True)
teams = TeamsSerializer(read_only=True, many=True)
lead_comments = LeadCommentSerializer(read_only=True, many=True)
def get_country(self, obj):
return obj.get_country_display()
class Meta:
model = Lead
# fields = ‘__all__’
fields = ("id", "title", "first_name", "last_name", "phone", "email",
"status", "source", "address_line", "street", "city",
"state", "postcode", "country", "website", "description",
"lead_attachment", "lead_comments", "assigned_to",
"account_name", "opportunity_amount", "created_by",
"created_on", "is_active", "enquiry_type", "tags",
"created_from_site", "teams", "skype_ID", "industry",
"company")
class InvoiceSerailizer(serializers.ModelSerializer):
from_address = BillingAddressSerializer()
to_address = BillingAddressSerializer()
created_by = UserSerializer()
org = OrganizationSerializer()
teams = TeamsSerializer(read_only=True, many=True)
assigned_to = UserSerializer(read_only=True, many=True)
class Meta:
model = Invoice
fields = (
"id",
"invoice_title",
"invoice_number",
"status",
"due_date",
"name",
"email",
"phone",
"from_address",
"to_address",
"created_on",
"created_by",
"currency",
"quantity",
"rate",
"tax",
"total_amount",
"amount_due",
"amount_paid",
"is_email_sent",
"details",
"teams",
"assigned_to",
"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.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):
context = {}
user_assgn_list = [
assigned_to.id for assigned_to in self.task_obj.assigned_to.all()
]
if self.request.user == self.task_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 don't have Permission to perform this action",
},
status=status.HTTP_403_FORBIDDEN,
)
comments = Comment.objects.filter(task=self.task_obj).order_by("-id")
attachments = Attachments.objects.filter(
task=self.task_obj).order_by("-id")
assigned_data = self.task_obj.assigned_to.values("id", "email")
if self.request.user.is_superuser or self.request.user.role == "ADMIN":
users_mention = list(
User.objects.filter(is_active=True, ).values("username"))
elif self.request.user != self.task_obj.created_by:
users_mention = [{"username": self.task_obj.created_by.username}]
else:
users_mention = list(
self.task_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, ).order_by("email")
else:
users = User.objects.filter(role="ADMIN", ).order_by("email")
if self.request.user == self.task_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 don't have Permission to perform this action",
},
status=status.HTTP_403_FORBIDDEN,
)
team_ids = [user.id for user in self.task_obj.get_team_users]
all_user_ids = users.values_list("id", flat=True)
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({
"task_obj":
TaskSerializer(self.task_obj).data,
"attachments":
AttachmentsSerializer(attachments, many=True).data,
"comments":
CommentSerializer(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["teams"] = TeamsSerializer(Teams.objects.all(), 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)
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
