def post(self, request, *args, **kwargs):
params = request.query_params if len(
request.data) == 0 else request.data
serializer = CaseCreateSerializer(data=params, request_obj=request)
if serializer.is_valid():
cases_obj = serializer.save(
created_by=request.profile,
org=request.org,
closed_on=params.get("closed_on"),
case_type=params.get("type_of_case"),
)
if params.get("contacts"):
contacts_list = json.loads(params.get("contacts"))
contacts = Contact.objects.filter(
id__in=contacts_list, org=request.org)
if contacts:
cases_obj.contacts.add(*contacts)
if params.get("teams"):
teams_list = json.loads(params.get("teams"))
teams = Teams.objects.filter(
id__in=teams_list, org=request.org)
if teams.exists():
cases_obj.teams.add(*teams)
if params.get("assigned_to"):
assinged_to_list = json.loads(
params.get("assigned_to"))
profiles = Profile.objects.filter(
id__in=assinged_to_list, org=request.org, is_active=True)
if profiles:
cases_obj.assigned_to.add(*profiles)
if self.request.FILES.get("case_attachment"):
attachment = Attachments()
attachment.created_by = self.request.profile
attachment.file_name = self.request.FILES.get(
"case_attachment").name
attachment.cases = cases_obj
attachment.attachment = self.request.FILES.get(
"case_attachment")
attachment.save()
recipients = list(
cases_obj.assigned_to.all().values_list("id", flat=True)
)
send_email_to_assigned_user.delay(
recipients,
cases_obj.id,
)
return Response(
{"error": False, "message": "Case Created Successfully"},
status=status.HTTP_200_OK,
)
return Response(
{"error": True, "errors": serializer.errors},
status=status.HTTP_400_BAD_REQUEST,
)
def form_valid(self, form):
# Save Account
account_object = form.save(commit=False)
account_object.save()
account_object.tags.clear()
if self.request.POST.get('tags', ''):
tags = self.request.POST.get("tags")
splitted_tags = tags.split(",")
for t in splitted_tags:
tag = Tags.objects.filter(name=t.lower())
if tag:
tag = tag[0]
else:
tag = Tags.objects.create(name=t.lower())
account_object.tags.add(tag)
if self.request.POST.getlist('contacts', []):
account_object.contacts.clear()
account_object.contacts.add(*self.request.POST.getlist('contacts'))
if self.request.POST.getlist('assigned_to', []):
account_object.assigned_to.clear()
account_object.assigned_to.add(
*self.request.POST.getlist('assigned_to'))
else:
account_object.assigned_to.clear()
if self.request.FILES.get('account_attachment'):
attachment = Attachments()
attachment.created_by = self.request.user
attachment.file_name = self.request.FILES.get(
'account_attachment').name
attachment.account = account_object
attachment.attachment = self.request.FILES.get(
'account_attachment')
attachment.save()
assigned_to_list = list(account_object.assigned_to.all().values_list(
'id', flat=True))
current_site = get_current_site(self.request)
recipients = assigned_to_list
send_email_to_assigned_user.delay(recipients,
account_object.id,
domain=current_site.domain,
protocol=self.request.scheme)
if self.request.POST.getlist('teams', []):
user_ids = Teams.objects.filter(
id__in=self.request.POST.getlist('teams')).values_list(
'users', flat=True)
assinged_to_users_ids = account_object.assigned_to.all(
).values_list('id', flat=True)
for user_id in user_ids:
if user_id not in assinged_to_users_ids:
account_object.assigned_to.add(user_id)
if self.request.is_ajax():
data = {
'success_url': reverse_lazy('accounts:list'),
'error': False
}
return JsonResponse(data)
return redirect("accounts:list")
def post(self, request, *args, **kwargs):
params = request.query_params if len(
request.data) == 0 else request.data
contact_serializer = CreateContactSerializer(
data=params, request_obj=request
)
address_serializer = BillingAddressSerializer(data=params)
data = {}
if not contact_serializer.is_valid():
data["contact_errors"] = contact_serializer.errors
if not address_serializer.is_valid():
data["address_errors"] = (address_serializer.errors,)
if data:
return Response(
{"error": True, "errors": data},
status=status.HTTP_400_BAD_REQUEST,
)
# if contact_serializer.is_valid() and address_serializer.is_valid():
address_obj = address_serializer.save()
contact_obj = contact_serializer.save(
date_of_birth=params.get("date_of_birth")
)
contact_obj.address = address_obj
contact_obj.created_by = self.request.profile
contact_obj.org = request.org
contact_obj.save()
if params.get("teams"):
teams_list = json.loads(params.get("teams"))
teams = Teams.objects.filter(
id__in=teams_list, org=request.org)
contact_obj.teams.add(*teams)
if params.get("assigned_to"):
assinged_to_list = json.loads(
params.get("assigned_to"))
profiles = Profile.objects.filter(
id__in=assinged_to_list, org=request.org)
contact_obj.assigned_to.add(*profiles)
recipients = list(
contact_obj.assigned_to.all().values_list("id", flat=True)
)
send_email_to_assigned_user.delay(
recipients,
contact_obj.id,
)
if request.FILES.get("contact_attachment"):
attachment = Attachments()
attachment.created_by = request.profile
attachment.file_name = request.FILES.get("contact_attachment").name
attachment.contact = contact_obj
attachment.attachment = request.FILES.get("contact_attachment")
attachment.save()
return Response(
{"error": False, "message": "Contact created Successfuly"},
status=status.HTTP_200_OK,
)
def form_valid(self, form):
# Save Account
account_object = form.save(commit=False)
account_object.save()
all_members_list = []
account_object.tags.clear()
if self.request.POST.get('tags', ''):
tags = self.request.POST.get("tags")
splitted_tags = tags.split(",")
for t in splitted_tags:
tag = Tags.objects.filter(name=t.lower())
if tag:
tag = tag[0]
else:
tag = Tags.objects.create(name=t.lower())
account_object.tags.add(tag)
if self.request.POST.getlist('contacts', []):
account_object.contacts.clear()
account_object.contacts.add(*self.request.POST.getlist('contacts'))
if self.request.FILES.get('account_attachment'):
attachment = Attachments()
attachment.created_by = self.request.user
attachment.file_name = self.request.FILES.get(
'account_attachment').name
attachment.account = account_object
attachment.attachment = self.request.FILES.get(
'account_attachment')
attachment.save()
return redirect("accounts:list")
def form_valid(self, form):
contact_obj = form.save(commit=False)
if self.request.POST.getlist('assigned_to', []):
contact_obj.assigned_to.add(*self.request.POST.getlist('assigned_to'))
assigned_to_list = self.request.POST.getlist('assigned_to')
current_site = get_current_site(self.request)
for assigned_to_user in assigned_to_list:
user = get_object_or_404(User, pk=assigned_to_user)
mail_subject = 'Assigned to contact.'
message = render_to_string('assigned_to/contact_assigned.html', {
'user': user,
'domain': current_site.domain,
'protocol': self.request.scheme,
'contact': contact_obj
})
email = EmailMessage(mail_subject, message, to=[user.email])
email.content_subtype = "html"
email.send()
if self.request.FILES.get('contact_attachment'):
attachment = Attachments()
attachment.created_by = self.request.user
attachment.file_name = self.request.FILES.get('contact_attachment').name
attachment.contact = contact_obj
attachment.attachment = self.request.FILES.get('contact_attachment')
attachment.save()
if self.request.is_ajax():
return JsonResponse({'error': False})
if self.request.POST.get("savenewform"):
return redirect("contacts:add_contact")
return redirect('contacts:list')
def form_valid(self, form):
# Save Account
account_object = form.save(commit=False)
account_object.save()
account_object.tags.clear()
if self.request.POST.get('tags', ''):
tags = self.request.POST.get("tags")
splitted_tags = tags.split(",")
for t in splitted_tags:
tag = Tags.objects.filter(name=t.lower())
if tag:
tag = tag[0]
else:
tag = Tags.objects.create(name=t.lower())
account_object.tags.add(tag)
if self.request.POST.getlist('contacts', []):
account_object.contacts.clear()
account_object.contacts.add(*self.request.POST.getlist('contacts'))
if self.request.FILES.get('account_attachment'):
attachment = Attachments()
attachment.created_by = self.request.user
attachment.file_name = self.request.FILES.get(
'account_attachment').name
attachment.account = account_object
attachment.attachment = self.request.FILES.get(
'account_attachment')
attachment.save()
if self.request.is_ajax():
data = {
'success_url': reverse_lazy('accounts:list'),
'error': False
}
return JsonResponse(data)
return redirect("accounts:list")
def form_valid(self, form):
contact_obj = form.save(commit=False)
if self.request.POST.getlist("assigned_to", []):
contact_obj.assigned_to.add(
*self.request.POST.getlist("assigned_to"))
# for assigned_to_user in assigned_to_list:
# user = get_object_or_404(User, pk=assigned_to_user)
# mail_subject = 'Assigned to contact.'
# message = render_to_string(
# 'assigned_to/contact_assigned.html', {
# 'user': user,
# 'domain': current_site.domain,
# 'protocol': self.request.scheme,
# 'contact': contact_obj
# })
# email = EmailMessage(mail_subject, message, to=[user.email])
# email.content_subtype = "html"
# email.send()
if self.request.POST.getlist("teams", []):
user_ids = Teams.objects.filter(
id__in=self.request.POST.getlist("teams")).values_list(
"users", flat=True)
assinged_to_users_ids = contact_obj.assigned_to.all().values_list(
"id", flat=True)
for user_id in user_ids:
if user_id not in assinged_to_users_ids:
contact_obj.assigned_to.add(user_id)
if self.request.POST.getlist("teams", []):
contact_obj.teams.add(*self.request.POST.getlist("teams"))
assigned_to_list = list(contact_obj.assigned_to.all().values_list(
"id", flat=True))
current_site = get_current_site(self.request)
recipients = assigned_to_list
send_email_to_assigned_user.delay(
recipients,
contact_obj.id,
domain=current_site.domain,
protocol=self.request.scheme,
)
if self.request.FILES.get("contact_attachment"):
attachment = Attachments()
attachment.created_by = self.request.user
attachment.file_name = self.request.FILES.get(
"contact_attachment").name
attachment.contact = contact_obj
attachment.attachment = self.request.FILES.get(
"contact_attachment")
attachment.save()
if self.request.is_ajax():
return JsonResponse({"error": False})
if self.request.POST.get("savenewform"):
return redirect("contacts:add_contact")
return redirect("contacts:list")
def post(self, request, pk, **kwargs):
params = (self.request.query_params
if len(self.request.data) == 0 else self.request.data)
context = {}
self.opportunity_obj = Opportunity.objects.get(pk=pk)
if self.opportunity_obj.company != request.company:
return Response({
"error":
True,
"errors":
"User company doesnot match with header...."
})
comment_serializer = CommentSerializer(data=params)
if self.request.user.role != "ADMIN" and not self.request.user.is_superuser:
if not (
(self.request.user == self.opportunity_obj.created_by) or
(self.request.user in self.opportunity_obj.assigned_to.all())):
return Response(
{
"error":
True,
"errors":
"You don't have Permission to perform this action",
},
status=status.HTTP_401_UNAUTHORIZED,
)
if comment_serializer.is_valid():
if params.get("comment"):
comment_serializer.save(
opportunity_id=self.opportunity_obj.id,
commented_by_id=self.request.user.id,
)
if self.request.FILES.get("opportunity_attachment"):
attachment = Attachments()
attachment.created_by = self.request.user
attachment.file_name = self.request.FILES.get(
"opportunity_attachment").name
attachment.opportunity = self.opportunity_obj
attachment.attachment = self.request.FILES.get(
"opportunity_attachment")
attachment.save()
comments = Comment.objects.filter(
opportunity=self.opportunity_obj).order_by("-id")
attachments = Attachments.objects.filter(
opportunity=self.opportunity_obj).order_by("-id")
context.update({
"opportunity_obj":
OpportunitySerializer(self.opportunity_obj).data,
"attachments":
AttachmentsSerializer(attachments, many=True).data,
"comments":
CommentSerializer(comments, many=True).data,
})
return Response(context)
def form_valid(self, form):
assigned_to_ids = self.get_object().assigned_to.all().values_list(
'id', flat=True)
case_obj = form.save(commit=False)
case_obj.contacts.clear()
case_obj.save()
all_members_list = []
if self.request.POST.getlist('assigned_to', []):
current_site = get_current_site(self.request)
assigned_form_users = form.cleaned_data.get(
'assigned_to').values_list('id', flat=True)
all_members_list = list(
set(list(assigned_form_users)) - set(list(assigned_to_ids)))
if len(all_members_list):
for assigned_to_user in all_members_list:
user = get_object_or_404(User, pk=assigned_to_user)
mail_subject = 'Assigned to case.'
message = render_to_string(
'assigned_to/cases_assigned.html', {
'user': user,
'domain': current_site.domain,
'protocol': self.request.scheme,
'case': case_obj
})
email = EmailMessage(mail_subject,
message,
to=[user.email])
email.content_subtype = "html"
email.send()
case_obj.assigned_to.clear()
case_obj.assigned_to.add(*self.request.POST.getlist('assigned_to'))
else:
case_obj.assigned_to.clear()
if self.request.POST.getlist('contacts', []):
case_obj.contacts.add(*self.request.POST.getlist('contacts'))
if self.request.POST.get('from_account'):
from_account = self.request.POST.get('from_account')
return redirect("accounts:view_account", pk=from_account)
if self.request.FILES.get('case_attachment'):
attachment = Attachments()
attachment.created_by = self.request.user
attachment.file_name = self.request.FILES.get(
'case_attachment').name
attachment.case = case_obj
attachment.attachment = self.request.FILES.get('case_attachment')
attachment.save()
if self.request.is_ajax():
return JsonResponse({'error': False})
return redirect("cases:list")
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 form_valid(self, form):
assigned_to_ids = self.get_object().assigned_to.all().values_list(
'id', flat=True)
contact_obj = form.save(commit=False)
all_members_list = []
if self.request.POST.getlist('assigned_to', []):
current_site = get_current_site(self.request)
assigned_form_users = form.cleaned_data.get(
'assigned_to').values_list('id', flat=True)
all_members_list = list(
set(list(assigned_form_users)) - set(list(assigned_to_ids)))
current_site = get_current_site(self.request)
recipients = all_members_list
send_email_to_assigned_user.delay(recipients,
contact_obj.id,
domain=current_site.domain,
protocol=self.request.scheme)
# if all_members_list:
# for assigned_to_user in all_members_list:
# user = get_object_or_404(User, pk=assigned_to_user)
# mail_subject = 'Assigned to contact.'
# message = render_to_string(
# 'assigned_to/contact_assigned.html', {
# 'user': user,
# 'domain': current_site.domain,
# 'protocol': self.request.scheme,
# 'contact': contact_obj
# })
# email = EmailMessage(
# mail_subject, message, to=[user.email])
# email.content_subtype = "html"
# email.send()
contact_obj.assigned_to.clear()
contact_obj.assigned_to.add(
*self.request.POST.getlist('assigned_to'))
else:
contact_obj.assigned_to.clear()
if self.request.FILES.get('contact_attachment'):
attachment = Attachments()
attachment.created_by = self.request.user
attachment.file_name = self.request.FILES.get(
'contact_attachment').name
attachment.contact = contact_obj
attachment.attachment = self.request.FILES.get(
'contact_attachment')
attachment.save()
if self.request.POST.get('from_account'):
from_account = self.request.POST.get('from_account')
return redirect("accounts:view_account", pk=from_account)
if self.request.is_ajax():
return JsonResponse({'error': False})
return redirect("contacts:list")
def form_valid(self, form):
opportunity_obj = form.save(commit=False)
opportunity_obj.created_by = self.request.user
if self.request.POST.get('stage') in ['CLOSED WON', 'CLOSED LOST']:
opportunity_obj.closed_by = self.request.user
opportunity_obj.save()
if self.request.POST.getlist('assigned_to', []):
opportunity_obj.assigned_to.add(
*self.request.POST.getlist('assigned_to'))
assigned_to_list = self.request.POST.getlist('assigned_to')
current_site = get_current_site(self.request)
for assigned_to_user in assigned_to_list:
user = get_object_or_404(User, pk=assigned_to_user)
mail_subject = 'Assigned to opportunity.'
message = render_to_string(
'assigned_to/opportunity_assigned.html', {
'user': user,
'domain': current_site.domain,
'protocol': self.request.scheme,
'opportunity': opportunity_obj
})
email = EmailMessage(mail_subject, message, to=[user.email])
email.content_subtype = "html"
email.send()
if self.request.POST.getlist('contacts', []):
opportunity_obj.contacts.add(
*self.request.POST.getlist('contacts'))
if self.request.POST.get('tags', ''):
tags = self.request.POST.get("tags")
splitted_tags = tags.split(",")
for t in splitted_tags:
tag = Tags.objects.filter(name=t.lower())
if tag:
tag = tag[0]
else:
tag = Tags.objects.create(name=t.lower())
opportunity_obj.tags.add(tag)
if self.request.FILES.get('oppurtunity_attachment'):
attachment = Attachments()
attachment.created_by = self.request.user
attachment.file_name = self.request.FILES.get(
'oppurtunity_attachment').name
attachment.opportunity = opportunity_obj
attachment.attachment = self.request.FILES.get(
'oppurtunity_attachment')
attachment.save()
if self.request.is_ajax():
return JsonResponse({'error': False})
if self.request.POST.get("savenewform"):
return redirect("opportunities:save")
if self.request.POST.get('from_account'):
from_account = self.request.POST.get('from_account')
return redirect("accounts:view_account", pk=from_account)
return redirect('opportunities:list')
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.request.user.role != "ADMIN" and not self.request.user.is_superuser:
if not ((self.request.user == self.lead_obj.created_by) or
(self.request.user 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.user.id,
)
if self.request.FILES.get("lead_attachment"):
attachment = Attachments()
attachment.created_by = self.request.user
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)
def put(self, request, pk, format=None):
params = request.query_params if len(
request.data) == 0 else request.data
context = {}
serializer = AccountCreateSerializer(data=params,
instance=self.account,
request_obj=request,
account=True)
if serializer.is_valid():
account_object = serializer.save()
previous_assigned_to_users = list(
account_object.assigned_to.all().values_list("id", flat=True))
account_object.tags.clear()
if params.get("tags", ""):
tags = params.get("tags")
splitted_tags = tags.split(",")
for t in splitted_tags:
tag = Tags.objects.filter(name=t.lower())
if tag:
tag = tag[0]
else:
tag = Tags.objects.create(name=t.lower())
account_object.tags.add(tag)
if params.getlist("contacts", []):
account_object.contacts.clear()
account_object.contacts.add(*params.getlist("contacts"))
if params.getlist("assigned_to", []):
account_object.assigned_to.clear()
account_object.assigned_to.add(*params.getlist("assigned_to"))
else:
account_object.assigned_to.clear()
if self.request.FILES.get("account_attachment"):
attachment = Attachments()
attachment.created_by = self.request.user
attachment.file_name = self.request.FILES.get(
"account_attachment").name
attachment.account = account_object
attachment.attachment = self.request.FILES.get(
"account_attachment")
attachment.save()
if params.getlist("teams", []):
account_object.teams.clear()
account_object.teams.add(*params.getlist("teams"))
else:
account_object.teams.clear()
if params.getlist("teams", []):
user_ids = Teams.objects.filter(
id__in=self.request.POST.getlist("teams")).values_list(
"users", flat=True)
assinged_to_users_ids = account_object.assigned_to.all(
).values_list("id", flat=True)
for user_id in user_ids:
if user_id not in assinged_to_users_ids:
account_object.assigned_to.add(user_id)
assigned_to_list = list(
account_object.assigned_to.all().values_list("id", flat=True))
current_site = get_current_site(self.request)
recipients = list(
set(assigned_to_list) - set(previous_assigned_to_users))
send_email_to_assigned_user.delay(
recipients,
account_object.id,
domain=current_site.domain,
protocol=self.request.scheme,
)
return Response({
"error": False,
"message": "Account Updated Successfully"
})
context["errors"] = serializer.errors
return Response(context, status=status.HTTP_400_BAD_REQUEST)
def update_case(request, pk):
case_object = Case.objects.filter(pk=pk).first()
accounts = Account.objects.filter(status="open")
contacts = Contact.objects.all()
if request.user.role != "ADMIN" and not request.user.is_superuser:
accounts = Account.objects.filter(created_by=request.user)
contacts = Contact.objects.filter(
Q(assigned_to__in=[request.user]) | Q(created_by=request.user))
users = []
if request.user.role == 'ADMIN' or request.user.is_superuser:
users = User.objects.filter(is_active=True).order_by('email')
elif request.user.google.all():
users = []
else:
users = User.objects.filter(role='ADMIN').order_by('email')
kwargs_data = {
"assigned_to": users,
"account": accounts,
"contacts": contacts
}
form = CaseForm(instance=case_object, **kwargs_data)
if request.POST:
form = CaseForm(request.POST,
request.FILES,
instance=case_object,
**kwargs_data)
if form.is_valid():
assigned_to_ids = case_object.assigned_to.all().values_list(
'id', flat=True)
case_obj = form.save(commit=False)
case_obj.contacts.clear()
case_obj.save()
all_members_list = []
if request.POST.getlist('assigned_to', []):
current_site = get_current_site(request)
assigned_form_users = form.cleaned_data.get(
'assigned_to').values_list('id', flat=True)
all_members_list = list(
set(list(assigned_form_users)) -
set(list(assigned_to_ids)))
recipients = all_members_list
send_email_to_assigned_user.delay(recipients,
case_obj.id,
domain=current_site.domain,
protocol=request.scheme)
# if all_members_list:
# for assigned_to_user in all_members_list:
# user = get_object_or_404(User, pk=assigned_to_user)
# mail_subject = 'Assigned to case.'
# message = render_to_string(
# 'assigned_to/cases_assigned.html', {
# 'user': user,
# 'domain': current_site.domain,
# 'protocol': request.scheme,
# 'case': case_obj
# })
# email = EmailMessage(
# mail_subject, message, to=[user.email])
# email.content_subtype = "html"
# email.send()
case_obj.assigned_to.clear()
case_obj.assigned_to.add(*request.POST.getlist('assigned_to'))
else:
case_obj.assigned_to.clear()
if request.POST.getlist('contacts', []):
case_obj.contacts.add(*request.POST.getlist('contacts'))
success_url = reverse("cases:list")
if request.POST.get('from_account'):
from_account = request.POST.get('from_account')
success_url = reverse("accounts:view_account",
kwargs={'pk': from_account})
if request.FILES.get('case_attachment'):
attachment = Attachments()
attachment.created_by = request.user
attachment.file_name = request.FILES.get(
'case_attachment').name
attachment.case = case_obj
attachment.attachment = request.FILES.get('case_attachment')
attachment.save()
return JsonResponse({'error': False, 'success_url': success_url})
return JsonResponse({'error': True, 'errors': form.errors})
context = {}
context["case_obj"] = case_object
user_assgn_list = [
assgined_to.id
for assgined_to in context["case_obj"].assigned_to.all()
]
if request.user == case_object.created_by:
user_assgn_list.append(request.user.id)
if request.user.role != "ADMIN" and not request.user.is_superuser:
if request.user.id not in user_assgn_list:
raise PermissionDenied
context["case_form"] = form
context["accounts"] = accounts
if request.GET.get('view_account'):
context['account'] = get_object_or_404(
Account, id=request.GET.get('view_account'))
context["contacts"] = contacts
context["users"] = kwargs_data['assigned_to']
context["case_types"] = CASE_TYPE
context["case_priority"] = PRIORITY_CHOICE
context["case_status"] = STATUS_CHOICE
context["assignedto_list"] = [
int(i) for i in request.POST.getlist('assigned_to', []) if i
]
context["contacts_list"] = [
int(i) for i in request.POST.getlist('contacts', []) if i
]
return render(request, "create_cases.html", context)
# message = render_to_string(
# 'assigned_to/cases_assigned.html', {
# 'user': user,
# 'domain': current_site.domain,
# 'protocol': request.scheme,
# 'case': case
# })
# email = EmailMessage(
# mail_subject, message, to=[user.email])
# email.content_subtype = "html"
# email.send()
if request.POST.getlist('contacts', []):
case.contacts.add(*request.POST.getlist('contacts'))
if request.FILES.get('case_attachment'):
attachment = Attachments()
attachment.created_by = request.user
attachment.file_name = request.FILES.get(
'case_attachment').name
attachment.case = case
attachment.attachment = request.FILES.get('case_attachment')
attachment.save()
success_url = reverse('cases:list')
if request.POST.get("savenewform"):
success_url = reverse("cases:add_case")
if request.POST.get('from_account'):
from_account = request.POST.get('from_account')
success_url = reverse("accounts:view_account",
kwargs={'pk': from_account})
return JsonResponse({'error': False, "success_url": success_url})
return JsonResponse({'error': True, 'errors': form.errors})
def create_lead(request):
template_name = "create_lead.html"
users = []
if request.user.role == 'ADMIN' or request.user.is_superuser:
users = User.objects.filter(is_active=True).order_by('email')
elif request.user.google.all():
users = []
else:
users = User.objects.filter(role='ADMIN').order_by('email')
form = LeadForm(assigned_to=users)
if request.POST:
form = LeadForm(request.POST, request.FILES, assigned_to=users)
if form.is_valid():
lead_obj = form.save(commit=False)
lead_obj.created_by = request.user
lead_obj.save()
l = Lead.objects.values_list('id',flat=True).latest('id')
print("Lead:",l)
if request.POST.get('tags', ''):
tags = request.POST.get("tags")
splitted_tags = tags.split(",")
for t in splitted_tags:
tag = Tags.objects.filter(name=t)
if tag:
tag = tag[0]
else:
tag = Tags.objects.create(name=t)
lead_obj.tags.add(tag)
if request.POST.getlist('assigned_to', []):
lead_obj.assigned_to.add(*request.POST.getlist('assigned_to'))
assigned_to_list = request.POST.getlist('assigned_to')
for i in assigned_to_list:
print("I:",i)
print(User.objects.values_list('username',flat=True).get(id=i))
# V_user = get_object_or_404(User,pk=i)
v_user=User.objects.values_list('username',flat=True).get(id=i)
uname = request.user.id
notifi=LeadNotification.objects.create(leadid=l,userid=i)
# current_site = get_current_site(request)
# recipients = assigned_to_list
# send_email_to_assigned_user.delay(recipients, lead_obj.id, domain=current_site.domain,
# protocol=request.scheme)
# for assigned_to_user in assigned_to_list:
# user = get_object_or_404(User, pk=assigned_to_user)
# mail_subject = 'Assigned to lead.'
# message = render_to_string(
# 'assigned_to/leads_assigned.html', {
# 'user': user,
# 'domain': current_site.domain,
# 'protocol': request.scheme,
# 'lead': lead_obj
# })
# email = EmailMessage(
# mail_subject, message, to=[user.email])
# email.content_subtype = "html"
# email.send()
if request.POST.getlist('teams', []):
user_ids = Teams.objects.filter(id__in=request.POST.getlist('teams')).values_list('users', flat=True)
assinged_to_users_ids = lead_obj.assigned_to.all().values_list('id', flat=True)
for user_id in user_ids:
if user_id not in assinged_to_users_ids:
lead_obj.assigned_to.add(user_id)
if request.POST.getlist('teams', []):
lead_obj.teams.add(*request.POST.getlist('teams'))
current_site = get_current_site(request)
recipients = list(lead_obj.assigned_to.all().values_list('id', flat=True))
send_email_to_assigned_user.delay(recipients, lead_obj.id, domain=current_site.domain,
protocol=request.scheme)
if request.FILES.get('lead_attachment'):
attachment = Attachments()
attachment.created_by = request.user
attachment.file_name = request.FILES.get(
'lead_attachment').name
attachment.lead = lead_obj
attachment.attachment = request.FILES.get('lead_attachment')
attachment.save()
if request.POST.get('status') == "qualified":
account_object = Account.objects.create(
created_by=request.user, name=lead_obj.account_name,
email=lead_obj.email, phone=lead_obj.phone,
description=request.POST.get('description'),
website=request.POST.get('website'),
)
account_object.billing_address_line = lead_obj.address_line
account_object.billing_street = lead_obj.street
account_object.billing_city = lead_obj.city
account_object.billing_state = lead_obj.state
account_object.billing_postcode = lead_obj.postcode
account_object.billing_country = lead_obj.country
for tag in lead_obj.tags.all():
account_object.tags.add(tag)
if request.POST.getlist('assigned_to', []):
# account_object.assigned_to.add(*request.POST.getlist('assigned_to'))
assigned_to_list = request.POST.getlist('assigned_to')
current_site = get_current_site(request)
recipients = assigned_to_list
send_email_to_assigned_user.delay(recipients, lead_obj.id, domain=current_site.domain,
protocol=request.scheme)
# for assigned_to_user in assigned_to_list:
# user = get_object_or_404(User, pk=assigned_to_user)
# mail_subject = 'Assigned to account.'
# message = render_to_string(
# 'assigned_to/account_assigned.html', {
# 'user': user,
# 'domain': current_site.domain,
# 'protocol': request.scheme,
# 'account': account_object
# })
# email = EmailMessage(
# mail_subject, message, to=[user.email])
# email.content_subtype = "html"
# email.send()
account_object.save()
# update_leads_cache.delay()
success_url = reverse('leads:list')
if request.POST.get("savenewform"):
success_url = reverse("leads:add_lead")
return JsonResponse({'error': False, 'success_url': success_url})
return JsonResponse({'error': True, 'errors': form.errors})
context = {}
context["lead_form"] = form
context["accounts"] = Account.objects.filter(status="open")
context["users"] = users
context["countries"] = COUNTRIES
context["status"] = LEAD_STATUS
context["source"] = LEAD_SOURCE
context["teams"] = Teams.objects.all()
context["assignedto_list"] = [
int(i) for i in request.POST.getlist('assigned_to', []) if i]
return render(request, template_name, context)
def post(self, request, *args, **kwargs):
params = request.query_params if len(
request.data) == 0 else request.data
serializer = OpportunityCreateSerializer(data=params,
request_obj=request)
if serializer.is_valid():
opportunity_obj = serializer.save(created_by=request.profile,
closed_on=params.get("due_date"),
org=request.org)
if params.get("contacts"):
contacts_list = json.loads(params.get("contacts"))
contacts = Contact.objects.filter(id__in=contacts_list,
org=request.org)
opportunity_obj.contacts.add(*contacts)
if params.get("tags"):
tags = json.loads(params.get("tags"))
for tag in tags:
obj_tag = Tags.objects.filter(slug=tag.lower())
if obj_tag.exists():
obj_tag = obj_tag[0]
else:
obj_tag = Tags.objects.create(name=tag)
opportunity_obj.tags.add(obj_tag)
if params.get("stage"):
stage = params.get("stage")
if stage in ["CLOSED WON", "CLOSED LOST"]:
opportunity_obj.closed_by = self.request.profile
if params.get("teams"):
teams_list = json.loads(params.get("teams"))
teams = Teams.objects.filter(id__in=teams_list,
org=request.org)
opportunity_obj.teams.add(*teams)
if params.get("assigned_to"):
assinged_to_list = json.loads(params.get("assigned_to"))
profiles = Profile.objects.filter(id__in=assinged_to_list,
org=request.org,
is_active=True)
opportunity_obj.assigned_to.add(*profiles)
if self.request.FILES.get("opportunity_attachment"):
attachment = Attachments()
attachment.created_by = self.request.profile
attachment.file_name = self.request.FILES.get(
"opportunity_attachment").name
attachment.opportunity = opportunity_obj
attachment.attachment = self.request.FILES.get(
"opportunity_attachment")
attachment.save()
recipients = list(opportunity_obj.assigned_to.all().values_list(
"id", flat=True))
send_email_to_assigned_user.delay(
recipients,
opportunity_obj.id,
)
return Response(
{
"error": False,
"message": "Opportunity Created Successfully"
},
status=status.HTTP_200_OK,
)
return Response(
{
"error": True,
"errors": serializer.errors
},
status=status.HTTP_400_BAD_REQUEST,
)
def update_opportunity(request, pk):
opportunity_object = Opportunity.objects.filter(pk=pk).first()
accounts = Account.objects.filter(status="open")
contacts = Contact.objects.all()
if request.user.role != "ADMIN" and not request.user.is_superuser:
accounts = Account.objects.filter(
created_by=request.user)
contacts = Contact.objects.filter(
Q(assigned_to__in=[request.user]) | Q(created_by=request.user))
users = []
if request.user.role == 'ADMIN' or request.user.is_superuser:
users = User.objects.filter(is_active=True).order_by('email')
elif request.user.google.all():
users = []
else:
users = User.objects.filter(role='ADMIN').order_by('email')
kwargs_data = {
"assigned_to": users,
"account": accounts, "contacts": contacts}
form = OpportunityForm(instance=opportunity_object, **kwargs_data)
if request.POST:
form = form = OpportunityForm(
request.POST, request.FILES,
instance=opportunity_object, **kwargs_data)
if form.is_valid():
assigned_to_ids = opportunity_object.assigned_to.all().values_list(
'id', flat=True)
opportunity_obj = form.save(commit=False)
if request.POST.get('stage') in ['CLOSED WON', 'CLOSED LOST']:
opportunity_obj.closed_by = request.user
previous_assigned_to_users = list(opportunity_obj.assigned_to.all().values_list('id', flat=True))
opportunity_obj.save()
opportunity_obj.contacts.clear()
all_members_list = []
if request.POST.getlist('assigned_to', []):
current_site = get_current_site(request)
assigned_form_users = form.cleaned_data.get(
'assigned_to').values_list('id', flat=True)
all_members_list = list(
set(list(assigned_form_users)) -
set(list(assigned_to_ids)))
# current_site = get_current_site(request)
# recipients = all_members_list
# send_email_to_assigned_user.delay(recipients, opportunity_obj.id, domain=current_site.domain,
# protocol=request.scheme)
# if all_members_list:
# for assigned_to_user in all_members_list:
# user = get_object_or_404(User, pk=assigned_to_user)
# mail_subject = 'Assigned to opportunity.'
# message = render_to_string(
# 'assigned_to/opportunity_assigned.html', {
# 'user': user,
# 'domain': current_site.domain,
# 'protocol': request.scheme,
# 'opportunity': opportunity_obj
# })
# email = EmailMessage(
# mail_subject, message, to=[user.email])
# email.content_subtype = "html"
# email.send()
opportunity_obj.assigned_to.clear()
opportunity_obj.assigned_to.add(
*request.POST.getlist('assigned_to'))
else:
opportunity_obj.assigned_to.clear()
if request.POST.getlist('teams', []):
user_ids = Teams.objects.filter(id__in=request.POST.getlist('teams')).values_list('users', flat=True)
assinged_to_users_ids = opportunity_obj.assigned_to.all().values_list('id', flat=True)
for user_id in user_ids:
if user_id not in assinged_to_users_ids:
opportunity_obj.assigned_to.add(user_id)
if request.POST.getlist('teams', []):
opportunity_obj.teams.clear()
opportunity_obj.teams.add(*request.POST.getlist('teams'))
else:
opportunity_obj.teams.clear()
current_site = get_current_site(request)
assigned_to_list = list(opportunity_obj.assigned_to.all().values_list('id', flat=True))
recipients = list(set(assigned_to_list) - set(previous_assigned_to_users))
send_email_to_assigned_user.delay(recipients, opportunity_obj.id, domain=current_site.domain,
protocol=request.scheme)
if request.POST.getlist('contacts', []):
opportunity_obj.contacts.add(
*request.POST.getlist('contacts'))
opportunity_obj.tags.clear()
if request.POST.get('tags', ''):
tags = request.POST.get("tags")
splitted_tags = tags.split(",")
for t in splitted_tags:
tag = Tags.objects.filter(name=t.lower())
if tag:
tag = tag[0]
else:
tag = Tags.objects.create(name=t.lower())
opportunity_obj.tags.add(tag)
if request.FILES.get('oppurtunity_attachment'):
attachment = Attachments()
attachment.created_by = request.user
attachment.file_name = request.FILES.get(
'oppurtunity_attachment').name
attachment.opportunity = opportunity_obj
attachment.attachment = request.FILES.get(
'oppurtunity_attachment')
attachment.save()
success_url = reverse('opportunities:list')
if request.POST.get('from_account'):
from_account = request.POST.get('from_account')
success_url = reverse("accounts:view_account", kwargs={
'pk': from_account})
return JsonResponse({'error': False, 'success_url': success_url})
return JsonResponse({'error': True, 'errors': form.errors})
context = {}
context['TITLE'] = settings.TITLE
context["opportunity_obj"] = opportunity_object
user_assgn_list = [
assigned_to.id for assigned_to in
context["opportunity_obj"].assigned_to.all()]
if request.user == context['opportunity_obj'].created_by:
user_assgn_list.append(request.user.id)
if request.user.role != "ADMIN" and not request.user.is_superuser:
if request.user.id not in user_assgn_list:
raise PermissionDenied
context["opportunity_form"] = form
context["accounts"] = accounts
if request.GET.get('view_account'):
context['account'] = get_object_or_404(
Account, id=request.GET.get('view_account'))
context["contacts"] = contacts
context["users"] = kwargs_data['assigned_to']
context["currencies"] = CURRENCY_CODES
context["stages"] = STAGES
context["sources"] = SOURCES
context["teams"] = Teams.objects.all()
context["assignedto_list"] = [
int(i) for i in request.POST.getlist('assigned_to', []) if i]
context["contacts_list"] = [
int(i) for i in request.POST.getlist('contacts', []) if i]
return render(request, "create_opportunity.html", context)
def post(self, request, *args, **kwargs):
params = request.query_params if len(
request.data) == 0 else request.data
serializer = AccountCreateSerializer(data=params,
request_obj=request,
account=True)
# Save Account
if serializer.is_valid():
account_object = serializer.save(created_by=request.profile,
org=request.org)
if params.get("contacts"):
contacts_list = json.loads(params.get("contacts"))
contacts = Contact.objects.filter(id__in=contacts_list,
org=request.org)
if contacts:
account_object.contacts.add(*contacts)
if params.get("tags"):
tags = json.loads(params.get("tags"))
for tag in tags:
tag_obj = Tags.objects.filter(slug=tag.lower())
if tag_obj.exists():
tag_obj = tag_obj[0]
else:
tag_obj = Tags.objects.create(name=tag)
account_object.tags.add(tag_obj)
if params.get("teams"):
teams_list = json.loads(params.get("teams"))
teams = Teams.objects.filter(id__in=teams_list,
org=request.org)
if teams:
account_object.teams.add(*teams)
if params.get("assigned_to"):
assigned_to_list = json.loads(params.get("assigned_to"))
profiles = Profile.objects.filter(id__in=assigned_to_list,
org=request.org,
is_active=True)
if profiles:
account_object.assigned_to.add(*profiles)
if self.request.FILES.get("account_attachment"):
attachment = Attachments()
attachment.created_by = request.profile
attachment.file_name = request.FILES.get(
"account_attachment").name
attachment.account = account_object
attachment.attachment = request.FILES.get("account_attachment")
attachment.save()
recipients = list(account_object.assigned_to.all().values_list(
"id", flat=True))
send_email_to_assigned_user.delay(
recipients,
account_object.id,
)
return Response(
{
"error": False,
"message": "Account Created Successfully"
},
status=status.HTTP_200_OK,
)
return Response(
{
"error": True,
"errors": serializer.errors
},
status=status.HTTP_400_BAD_REQUEST,
)
def put(self, request, pk, format=None):
params = request.query_params if len(
request.data) == 0 else request.data
opportunity_object = self.get_object(pk=pk)
data = {}
if opportunity_object.company != request.company:
return Response({
"error":True,
"errors":"User company doesnot match with header...."},
status=status.HTTP_404_NOT_FOUND
)
if self.request.user.role != "ADMIN" and not self.request.user.is_superuser:
if not (
(self.request.user == opportunity_object.created_by)
or (self.request.user in opportunity_object.assigned_to.all())
):
return Response(
{"error": True,
"errors": "You do not have Permission to perform this action"},
status=status.HTTP_401_UNAUTHORIZED,
)
serializer = OpportunityCreateSerializer(
opportunity_object,
data=params,
request_obj=request,
opportunity=True,
)
if serializer.is_valid():
opportunity_object = serializer.save(
closed_on = params.get("due_date")
)
previous_assigned_to_users = list(
opportunity_object.assigned_to.all().values_list("id", flat=True)
)
opportunity_object.contacts.clear()
if params.get("contacts"):
contacts = json.loads(params.get("contacts"))
for contact in contacts:
obj_contact = Contact.objects.filter(id=contact, company=request.company)
if obj_contact:
opportunity_object.contacts.add(contact)
else:
data["contacts"] = "Please enter valid Contact"
return Response({"error":True, "errors":data})
opportunity_object.tags.clear()
if params.get("tags"):
tags = json.loads(params.get("tags"))
# for t in tags:
# tag,_ = Tags.objects.get_or_create(name=t.lower())
# opportunity_object.tags.add(tag)
for tag in tags:
obj_tag = Tags.objects.filter(slug=tag.lower())
if obj_tag:
obj_tag = obj_tag[0]
else:
obj_tag = Tags.objects.create(name=tag)
opportunity_object.tags.add(obj_tag)
if params.get("stage"):
stage = params.get("stage")
if stage in ["CLOSED WON","CLOSED LOST"]:
opportunity_object.closed_by_id = self.request.user.id
if self.request.user.role == "ADMIN":
opportunity_object.teams.clear()
if params.get("teams"):
teams = json.loads(params.get("teams"))
for team in teams:
obj_team = Teams.objects.filter(id=team,company=request.company)
if obj_team:
opportunity_object.teams.add(team)
else:
data["team"] = "Please enter valid Team"
return Response({"error": True, "errors":data})
opportunity_object.assigned_to.clear()
if params.get("assigned_to"):
assinged_to_users_ids = json.loads(params.get("assigned_to"))
for user_id in assinged_to_users_ids:
user = User.objects.filter(id=user_id, company=request.company)
if user:
opportunity_object.assigned_to.add(user_id)
else:
data["assigned_to"] = "Please enter valid User"
return Response({"error": True, "errors":data})
if self.request.FILES.get("opportunity_attachment"):
attachment = Attachments()
attachment.created_by = self.request.user
attachment.file_name = self.request.FILES.get(
"opportunity_attachment").name
attachment.opportunity = opportunity_object
attachment.attachment = self.request.FILES.get(
"opportunity_attachment")
attachment.save()
assigned_to_list = list(
opportunity_object.assigned_to.all().values_list("id", flat=True)
)
current_site = get_current_site(self.request)
recipients = list(set(assigned_to_list) - set(previous_assigned_to_users))
send_email_to_assigned_user.delay(
recipients,
opportunity_object.id,
domain=current_site.domain,
protocol=self.request.scheme,
)
return Response(
{"error": False, "message": "Opportunity Updated Successfully"},
status=status.HTTP_200_OK,
)
return Response({"error": True, "errors": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs):
params = request.query_params if len(request.data) == 0 else request.data
data = {}
serializer = OpportunityCreateSerializer(
data=params, request_obj=request
)
if serializer.is_valid():
opportunity_obj = serializer.save(
created_by=request.user,
company=request.company,
closed_on = params.get("due_date")
)
if params.get("contacts"):
contacts = json.loads(params.get("contacts"))
for contact in contacts:
obj_contact = Contact.objects.filter(id=contact, company=request.company)
if obj_contact:
opportunity_obj.contacts.add(contact)
else:
opportunity_obj.delete()
data["contacts"] = "Please enter valid contact"
return Response({"error": True, "errors":data})
if params.get("tags"):
tags = json.loads(params.get("tags"))
# for t in tags:
# tag,_ = Tags.objects.get_or_create(slug=t.lower())
# opportunity_obj.tags.add(tag)
for tag in tags:
obj_tag = Tags.objects.filter(slug=tag.lower())
if obj_tag:
obj_tag = obj_tag[0]
else:
obj_tag = Tags.objects.create(name=tag)
opportunity_obj.tags.add(obj_tag)
if params.get("stage"):
stage = params.get("stage")
if stage in ["CLOSED WON","CLOSED LOST"]:
opportunity_obj.closed_by = self.request.user
if self.request.user.role == "ADMIN":
if params.get("teams"):
teams = json.loads(params.get("teams"))
for team in teams:
obj_team = Teams.objects.filter(id=team,company=request.company)
if obj_team:
opportunity_obj.teams.add(team)
else:
opportunity_obj.delete()
data["team"] = "Please enter valid Team"
return Response({"error": True, "errors":data})
if params.get("assigned_to"):
assinged_to_users_ids = json.loads(params.get("assigned_to"))
for user_id in assinged_to_users_ids:
user = User.objects.filter(id=user_id, company=request.company)
if user:
opportunity_obj.assigned_to.add(user_id)
else:
opportunity_obj.delete()
data["assigned_to"] = "Please enter valid user"
return Response({"error": True, "errors":data})
if self.request.FILES.get("opportunity_attachment"):
attachment = Attachments()
attachment.created_by = self.request.user
attachment.file_name = self.request.FILES.get("opportunity_attachment").name
attachment.opportunity = opportunity_obj
attachment.attachment = self.request.FILES.get("opportunity_attachment")
attachment.save()
assigned_to_list = list(
opportunity_obj.assigned_to.all().values_list("id", flat=True)
)
current_site = get_current_site(request)
recipients = assigned_to_list
send_email_to_assigned_user.delay(
recipients,
opportunity_obj.id,
domain=current_site.domain,
protocol=self.request.scheme,
)
return Response({"error": False,
"message": "Opportunity Created Successfully"})
return Response({"error": True,
"errors": serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
def create_lead(request):
template_name = "create_lead.html"
users = []
if request.user.role == 'ADMIN' or request.user.is_superuser:
users = User.objects.filter(is_active=True).order_by('email')
elif request.user.google.all():
users = []
else:
users = User.objects.filter(role='ADMIN').order_by('email')
form = LeadForm(assigned_to=users)
if request.POST:
print(request.POST)
cat_id = Category.objects.get(pk=request.POST.get('category'))
subc_id = SubCategory.objects.get(pk=request.POST.get('sub_category'))
item_id = ItemList.objects.get(pk=request.POST.get('item_list'))
form = LeadForm(request.POST, request.FILES, assigned_to=users,sub_category=subc_id,item_list=item_id)
if form.is_valid():
lead_obj = form.save(commit=False)
lead_obj.created_by = request.user
lead_obj.save()
if request.POST.get('tags', ''):
tags = request.POST.get("tags")
splitted_tags = tags.split(",")
for t in splitted_tags:
tag = Tags.objects.filter(name=t)
if tag:
tag = tag[0]
else:
tag = Tags.objects.create(name=t)
lead_obj.tags.add(tag)
if request.POST.getlist('assigned_to', []):
lead_obj.assigned_to.add(*request.POST.getlist('assigned_to'))
assigned_to_list = request.POST.getlist('assigned_to')
if request.POST.getlist('teams', []):
user_ids = Teams.objects.filter(id__in=request.POST.getlist('teams')).values_list('users', flat=True)
assinged_to_users_ids = lead_obj.assigned_to.all().values_list('id', flat=True)
for user_id in user_ids:
if user_id not in assinged_to_users_ids:
lead_obj.assigned_to.add(user_id)
if request.POST.getlist('teams', []):
lead_obj.teams.add(*request.POST.getlist('teams'))
if request.POST.getlist('products',[]):
lead_obj.products.add(*request.POST.getlist('products'))
current_site = get_current_site(request)
recipients = list(lead_obj.assigned_to.all().values_list('id', flat=True))
send_email_to_assigned_user.delay(recipients, lead_obj.id, domain=current_site.domain,
protocol=request.scheme)
if request.FILES.get('lead_attachment'):
attachment = Attachments()
attachment.created_by = request.user
attachment.file_name = request.FILES.get(
'lead_attachment').name
attachment.lead = lead_obj
attachment.attachment = request.FILES.get('lead_attachment')
attachment.save()
if request.POST.get('status') == "converted":
account_object = Account.objects.create(
created_by=request.user, name=lead_obj.account_name,
email=lead_obj.email, phone=lead_obj.phone,
description=request.POST.get('description'),
website=request.POST.get('website'),
)
account_object.billing_address_line = lead_obj.address_line
account_object.billing_street = lead_obj.street
account_object.billing_city = lead_obj.city
account_object.billing_state = lead_obj.state
account_object.billing_postcode = lead_obj.postcode
account_object.billing_country = lead_obj.country
for tag in lead_obj.tags.all():
account_object.tags.add(tag)
if request.POST.getlist('assigned_to', []):
# account_object.assigned_to.add(*request.POST.getlist('assigned_to'))
assigned_to_list = request.POST.getlist('assigned_to')
current_site = get_current_site(request)
recipients = assigned_to_list
send_email_to_assigned_user.delay(recipients, lead_obj.id, domain=current_site.domain,
protocol=request.scheme)
account_object.save()
# update_leads_cache.delay()
success_url = reverse('leads:list')
if request.POST.get("savenewform"):
success_url = reverse("leads:add_lead")
return JsonResponse({'error': False, 'success_url': success_url})
return JsonResponse({'error': True, 'errors': form.errors})
context = {}
context["lead_form"] = form
context["accounts"] = Account.objects.filter(status="open")
context["users"] = users
context["countries"] = COUNTRIES
context["status"] = LEAD_STATUS
context["source"] = LEAD_SOURCE
context["teams"] = Teams.objects.all()
context['products'] = Product.objects.all()
context["assignedto_list"] = [
int(i) for i in request.POST.getlist('assigned_to', []) if i]
return render(request, template_name, context)
def form_valid(self, form):
assigned_to_ids = self.get_object().assigned_to.all().values_list(
'id', flat=True)
lead_obj = form.save(commit=False)
lead_obj.save()
lead_obj.tags.clear()
all_members_list = []
if self.request.POST.get('tags', ''):
tags = self.request.POST.get("tags")
splitted_tags = tags.split(",")
for t in splitted_tags:
tag = Tags.objects.filter(name=t)
if tag:
tag = tag[0]
else:
tag = Tags.objects.create(name=t)
lead_obj.tags.add(tag)
if self.request.POST.getlist('assigned_to', []):
if self.request.POST.get('status') != "converted":
current_site = get_current_site(self.request)
assigned_form_users = form.cleaned_data.get(
'assigned_to').values_list('id', flat=True)
all_members_list = list(
set(list(assigned_form_users)) -
set(list(assigned_to_ids)))
if len(all_members_list):
for assigned_to_user in all_members_list:
user = get_object_or_404(User, pk=assigned_to_user)
mail_subject = 'Assigned to lead.'
message = render_to_string(
'assigned_to/leads_assigned.html', {
'user': user,
'domain': current_site.domain,
'protocol': self.request.scheme,
'lead': lead_obj
})
email = EmailMessage(mail_subject,
message,
to=[user.email])
email.content_subtype = "html"
email.send()
lead_obj.assigned_to.clear()
lead_obj.assigned_to.add(*self.request.POST.getlist('assigned_to'))
else:
lead_obj.assigned_to.clear()
if self.request.FILES.get('lead_attachment'):
attachment = Attachments()
attachment.created_by = self.request.user
attachment.file_name = self.request.FILES.get(
'lead_attachment').name
attachment.lead = lead_obj
attachment.attachment = self.request.FILES.get('lead_attachment')
attachment.save()
if self.request.POST.get('status') == "converted":
account_object = Account.objects.create(
created_by=self.request.user,
name=lead_obj.account_name,
email=lead_obj.email,
phone=lead_obj.phone,
description=self.request.POST.get('description'),
website=self.request.POST.get('website'))
account_object.billing_address_line = lead_obj.address_line
account_object.billing_street = lead_obj.street
account_object.billing_city = lead_obj.city
account_object.billing_state = lead_obj.state
account_object.billing_postcode = lead_obj.postcode
account_object.billing_country = lead_obj.country
for tag in lead_obj.tags.all():
account_object.tags.add(tag)
if self.request.POST.getlist('assigned_to', []):
account_object.assigned_to.add(
*self.request.POST.getlist('assigned_to'))
assigned_to_list = self.request.POST.getlist('assigned_to')
current_site = get_current_site(self.request)
for assigned_to_user in assigned_to_list:
user = get_object_or_404(User, pk=assigned_to_user)
mail_subject = 'Assigned to account.'
message = render_to_string(
'assigned_to/account_assigned.html', {
'user': user,
'domain': current_site.domain,
'protocol': self.request.scheme,
'account': account_object
})
email = EmailMessage(mail_subject,
message,
to=[user.email])
email.content_subtype = "html"
email.send()
account_object.save()
status = self.request.GET.get('status', None)
if status:
return redirect('accounts:list')
return redirect('leads:list')
def put(self, request, pk, format=None):
params = request.query_params if len(
request.data) == 0 else request.data
opportunity_object = self.get_object(pk=pk)
if opportunity_object.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 == opportunity_object.created_by) or
(self.request.profile
in opportunity_object.assigned_to.all())):
return Response(
{
"error":
True,
"errors":
"You do not have Permission to perform this action",
},
status=status.HTTP_403_FORBIDDEN,
)
serializer = OpportunityCreateSerializer(
opportunity_object,
data=params,
request_obj=request,
opportunity=True,
)
if serializer.is_valid():
opportunity_object = serializer.save(
closed_on=params.get("due_date"))
previous_assigned_to_users = list(
opportunity_object.assigned_to.all().values_list("id",
flat=True))
opportunity_object.contacts.clear()
if params.get("contacts"):
contacts_list = json.loads(params.get("contacts"))
contacts = Contact.objects.filter(id__in=contacts_list,
org=request.org)
opportunity_object.contacts.add(*contacts)
opportunity_object.tags.clear()
if params.get("tags"):
tags = json.loads(params.get("tags"))
for tag in tags:
obj_tag = Tags.objects.filter(slug=tag.lower())
if obj_tag.exists():
obj_tag = obj_tag[0]
else:
obj_tag = Tags.objects.create(name=tag)
opportunity_object.tags.add(obj_tag)
if params.get("stage"):
stage = params.get("stage")
if stage in ["CLOSED WON", "CLOSED LOST"]:
opportunity_object.closed_by = self.request.profile
opportunity_object.teams.clear()
if params.get("teams"):
teams_list = json.loads(params.get("teams"))
teams = Teams.objects.filter(id__in=teams_list,
org=request.org)
opportunity_object.teams.add(*teams)
opportunity_object.assigned_to.clear()
if params.get("assigned_to"):
assinged_to_list = json.loads(params.get("assigned_to"))
profiles = Profile.objects.filter(id__in=assinged_to_list,
org=request.org,
is_active=True)
opportunity_object.assigned_to.add(*profiles)
if self.request.FILES.get("opportunity_attachment"):
attachment = Attachments()
attachment.created_by = self.request.profile
attachment.file_name = self.request.FILES.get(
"opportunity_attachment").name
attachment.opportunity = opportunity_object
attachment.attachment = self.request.FILES.get(
"opportunity_attachment")
attachment.save()
assigned_to_list = list(
opportunity_object.assigned_to.all().values_list("id",
flat=True))
recipients = list(
set(assigned_to_list) - set(previous_assigned_to_users))
send_email_to_assigned_user.delay(
recipients,
opportunity_object.id,
)
return Response(
{
"error": False,
"message": "Opportunity Updated Successfully"
},
status=status.HTTP_200_OK,
)
return Response(
{
"error": True,
"errors": serializer.errors
},
status=status.HTTP_400_BAD_REQUEST,
)
def form_valid(self, form):
# Save Account
account_object = form.save(commit=False)
account_object.created_by = self.request.user
account_object.company = self.request.company
account_object.save()
if self.request.POST.get("tags", ""):
tags = self.request.POST.get("tags")
splitted_tags = tags.split(",")
for t in splitted_tags:
tag = Tags.objects.filter(name=t)
if tag:
tag = tag[0]
else:
tag = Tags.objects.create(name=t)
account_object.tags.add(tag)
if self.request.POST.getlist("contacts", []):
account_object.contacts.add(*self.request.POST.getlist("contacts"))
if self.request.POST.getlist("assigned_to", []):
account_object.assigned_to.add(*self.request.POST.getlist("assigned_to"))
if self.request.FILES.get("account_attachment"):
attachment = Attachments()
attachment.created_by = self.request.user
attachment.file_name = self.request.FILES.get("account_attachment").name
attachment.account = account_object
attachment.attachment = self.request.FILES.get("account_attachment")
attachment.save()
if self.request.POST.getlist("teams", []):
user_ids = Teams.objects.filter(
id__in=self.request.POST.getlist("teams")
).values_list("users", flat=True)
assinged_to_users_ids = account_object.assigned_to.all().values_list(
"id", flat=True
)
for user_id in user_ids:
if user_id not in assinged_to_users_ids:
account_object.assigned_to.add(user_id)
if self.request.POST.getlist("teams", []):
account_object.teams.add(*self.request.POST.getlist("teams"))
assigned_to_list = list(
account_object.assigned_to.all().values_list("id", flat=True)
)
current_site = get_current_site(self.request)
recipients = assigned_to_list
send_email_to_assigned_user.delay(
recipients,
account_object.id,
domain=current_site.domain,
protocol=self.request.scheme,
)
if self.request.POST.get("savenewform"):
return redirect("accounts:new_account")
if self.request.is_ajax():
data = {"success_url": reverse_lazy("accounts:list"), "error": False}
return JsonResponse(data)
return redirect("accounts:list")
def put(self, request, pk, format=None):
params = request.query_params if len(
request.data) == 0 else request.data
cases_object = self.get_object(pk=pk)
if cases_object.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.profile.is_admin:
if not (
(self.request.profile == cases_object.created_by)
or (self.request.profile in cases_object.assigned_to.all())
):
return Response(
{
"error": True,
"errors": "You do not have Permission to perform this action",
},
status=status.HTTP_403_FORBIDDEN,
)
serializer = CaseCreateSerializer(
cases_object,
data=params,
request_obj=request,
)
if serializer.is_valid():
cases_object = serializer.save(
closed_on=params.get("closed_on"), case_type=params.get("type_of_case")
)
previous_assigned_to_users = list(
cases_object.assigned_to.all().values_list("id", flat=True)
)
cases_object.contacts.clear()
if params.get("contacts"):
contacts_list = json.loads(params.get("contacts"))
contacts = Contact.objects.filter(
id__in=contacts_list, org=request.org)
if contacts:
cases_object.contacts.add(*contacts)
cases_object.teams.clear()
if params.get("teams"):
teams_list = json.loads(params.get("teams"))
teams = Teams.objects.filter(
id__in=teams_list, org=request.org)
if teams.exists():
cases_object.teams.add(*teams)
cases_object.assigned_to.clear()
if params.get("assigned_to"):
assinged_to_list = json.loads(
params.get("assigned_to"))
profiles = Profile.objects.filter(
id__in=assinged_to_list, org=request.org, is_active=True)
if profiles:
cases_object.assigned_to.add(*profiles)
if self.request.FILES.get("case_attachment"):
attachment = Attachments()
attachment.created_by = self.request.profile
attachment.file_name = self.request.FILES.get(
"case_attachment").name
attachment.case = cases_object
attachment.attachment = self.request.FILES.get(
"case_attachment")
attachment.save()
assigned_to_list = list(
cases_object.assigned_to.all().values_list("id", flat=True)
)
recipients = list(set(assigned_to_list) -
set(previous_assigned_to_users))
send_email_to_assigned_user.delay(
recipients,
cases_object.id,
)
return Response(
{"error": False, "message": "Case Updated Successfully"},
status=status.HTTP_200_OK,
)
return Response(
{"error": True, "errors": serializer.errors},
status=status.HTTP_400_BAD_REQUEST,
)
def create_lead(request):
template_name = "create_lead.html"
users = User.objects.filter(is_active=True).order_by('email')
form = LeadForm(assigned_to=users)
if request.POST:
form = LeadForm(request.POST, request.FILES, assigned_to=users)
if form.is_valid():
lead_obj = form.save(commit=False)
lead_obj.created_by = request.user
lead_obj.save()
if request.POST.get('tags', ''):
tags = request.POST.get("tags")
splitted_tags = tags.split(",")
for t in splitted_tags:
tag = Tags.objects.filter(name=t)
if tag:
tag = tag[0]
else:
tag = Tags.objects.create(name=t)
lead_obj.tags.add(tag)
if request.POST.getlist('assigned_to', []):
lead_obj.assigned_to.add(*request.POST.getlist('assigned_to'))
assigned_to_list = request.POST.getlist('assigned_to')
current_site = get_current_site(request)
for assigned_to_user in assigned_to_list:
user = get_object_or_404(User, pk=assigned_to_user)
mail_subject = 'Assigned to lead.'
message = render_to_string(
'assigned_to/leads_assigned.html', {
'user': user,
'domain': current_site.domain,
'protocol': request.scheme,
'lead': lead_obj
})
email = EmailMessage(mail_subject,
message,
to=[user.email])
email.content_subtype = "html"
email.send()
if request.FILES.get('lead_attachment'):
attachment = Attachments()
attachment.created_by = request.user
attachment.file_name = request.FILES.get(
'lead_attachment').name
attachment.lead = lead_obj
attachment.attachment = request.FILES.get('lead_attachment')
attachment.save()
if request.POST.get('status') == "converted":
account_object = Account.objects.create(
created_by=request.user,
name=lead_obj.account_name,
email=lead_obj.email,
phone=lead_obj.phone,
description=request.POST.get('description'),
website=request.POST.get('website'),
)
account_object.billing_address_line = lead_obj.address_line
account_object.billing_street = lead_obj.street
account_object.billing_city = lead_obj.city
account_object.billing_state = lead_obj.state
account_object.billing_postcode = lead_obj.postcode
account_object.billing_country = lead_obj.country
for tag in lead_obj.tags.all():
account_object.tags.add(tag)
if request.POST.getlist('assigned_to', []):
# account_object.assigned_to.add(*request.POST.getlist('assigned_to'))
assigned_to_list = request.POST.getlist('assigned_to')
current_site = get_current_site(request)
for assigned_to_user in assigned_to_list:
user = get_object_or_404(User, pk=assigned_to_user)
mail_subject = 'Assigned to account.'
message = render_to_string(
'assigned_to/account_assigned.html', {
'user': user,
'domain': current_site.domain,
'protocol': request.scheme,
'account': account_object
})
email = EmailMessage(mail_subject,
message,
to=[user.email])
email.content_subtype = "html"
email.send()
account_object.save()
success_url = reverse('leads:list')
if request.POST.get("savenewform"):
success_url = reverse("leads:add_lead")
return JsonResponse({'error': False, 'success_url': success_url})
else:
return JsonResponse({'error': True, 'errors': form.errors})
else:
context = {}
context["lead_form"] = form
context["accounts"] = Account.objects.filter(status="open")
context["users"] = users
context["countries"] = COUNTRIES
context["status"] = LEAD_STATUS
context["source"] = LEAD_SOURCE
context["assignedto_list"] = [
int(i) for i in request.POST.getlist('assigned_to', []) if i
]
return render(request, template_name, context)
def update_lead(request, pk):
lead_record = Lead.objects.filter(pk=pk).first()
template_name = "create_lead.html"
users = []
if request.user.role == 'ADMIN' or request.user.is_superuser:
users = User.objects.filter(is_active=True).order_by('email')
else:
users = User.objects.filter(role='ADMIN').order_by('email')
status = request.GET.get('status', None)
initial = {}
if status and status == "Qualified":
error = "This field is required."
lead_record.status = "Qualified"
initial.update({
"status": status, "lead": lead_record.id})
error = ""
form = LeadForm(instance=lead_record, initial=initial, assigned_to=users)
if request.POST:
form = LeadForm(request.POST, request.FILES,
instance=lead_record,
initial=initial, assigned_to=users)
if request.POST.get('status') == "Qualified":
form.fields['account_name'].required = True
form.fields['email'].required = True
else:
form.fields['account_name'].required = False
form.fields['email'].required = False
if form.is_valid():
assigned_to_ids = lead_record.assigned_to.all().values_list(
'id', flat=True)
lead_obj = form.save(commit=False)
lead_obj.save()
previous_assigned_to_users = list(lead_obj.assigned_to.all().values_list('id', flat=True))
lead_obj.tags.clear()
all_members_list = []
if request.POST.get('tags', ''):
tags = request.POST.get("tags")
splitted_tags = tags.split(",")
for t in splitted_tags:
tag = Tags.objects.filter(name=t)
if tag:
tag = tag[0]
else:
tag = Tags.objects.create(name=t)
lead_obj.tags.add(tag)
if request.POST.getlist('assigned_to', []):
if request.POST.get('status') != "Qualified":
current_site = get_current_site(request)
assigned_form_users = form.cleaned_data.get(
'assigned_to').values_list('id', flat=True)
all_members_list = list(
set(list(assigned_form_users)) -
set(list(assigned_to_ids)))
# current_site = get_current_site(request)
# recipients = all_members_list
# send_email_to_assigned_user.delay(recipients, lead_obj.id, domain=current_site.domain,
# protocol=request.scheme)
# if all_members_list:
# for assigned_to_user in all_members_list:
# user = get_object_or_404(User, pk=assigned_to_user)
# mail_subject = 'Assigned to lead.'
# message = render_to_string(
# 'assigned_to/leads_assigned.html', {
# 'user': user,
# 'domain': current_site.domain,
# 'protocol': request.scheme,
# 'lead': lead_obj
# })
# email = EmailMessage(
# mail_subject, message, to=[user.email])
# email.content_subtype = "html"
# email.send()
lead_obj.assigned_to.clear()
lead_obj.assigned_to.add(*request.POST.getlist('assigned_to'))
else:
lead_obj.assigned_to.clear()
if request.POST.getlist('teams', []):
user_ids = Teams.objects.filter(id__in=request.POST.getlist('teams')).values_list('users', flat=True)
assinged_to_users_ids = lead_obj.assigned_to.all().values_list('id', flat=True)
for user_id in user_ids:
if user_id not in assinged_to_users_ids:
lead_obj.assigned_to.add(user_id)
if request.POST.getlist('teams', []):
lead_obj.teams.clear()
lead_obj.teams.add(*request.POST.getlist('teams'))
else:
lead_obj.teams.clear()
current_site = get_current_site(request)
assigned_to_list = list(lead_obj.assigned_to.all().values_list('id', flat=True))
recipients = list(set(assigned_to_list) - set(previous_assigned_to_users))
send_email_to_assigned_user.delay(recipients, lead_obj.id, domain=current_site.domain,
protocol=request.scheme)
# update_leads_cache.delay()
if request.FILES.get('lead_attachment'):
attachment = Attachments()
attachment.created_by = request.user
attachment.file_name = request.FILES.get(
'lead_attachment').name
attachment.lead = lead_obj
attachment.attachment = request.FILES.get('lead_attachment')
attachment.save()
if request.POST.get('status') == "Qualified":
account_object = Account.objects.create(
created_by=request.user, name=lead_obj.account_name,
email=lead_obj.email, phone=lead_obj.phone,
description=request.POST.get('description'),
website=request.POST.get('website'),
lead=lead_obj
)
account_object.billing_address_line = lead_obj.address_line
account_object.billing_street = lead_obj.street
account_object.billing_city = lead_obj.city
account_object.billing_state = lead_obj.state
account_object.billing_postcode = lead_obj.postcode
account_object.billing_country = lead_obj.country
for tag in lead_obj.tags.all():
account_object.tags.add(tag)
if request.POST.getlist('assigned_to', []):
# account_object.assigned_to.add(*request.POST.getlist('assigned_to'))
assigned_to_list = request.POST.getlist('assigned_to')
current_site = get_current_site(request)
recipients = assigned_to_list
send_email_to_assigned_user.delay(recipients, lead_obj.id, domain=current_site.domain,
protocol=request.scheme)
# current_site = get_current_site(request)
# for assigned_to_user in assigned_to_list:
# user = get_object_or_404(User, pk=assigned_to_user)
# mail_subject = 'Assigned to account.'
# message = render_to_string(
# 'assigned_to/account_assigned.html', {
# 'user': user,
# 'domain': current_site.domain,
# 'protocol': request.scheme,
# 'account': account_object
# })
# email = EmailMessage(
# mail_subject, message, to=[user.email])
# email.content_subtype = "html"
# email.send()
for comment in lead_obj.leads_comments.all():
comment.account = account_object
comment.save()
account_object.save()
status = request.GET.get('status', None)
success_url = reverse('leads:list')
if status:
success_url = reverse('accounts:list')
return JsonResponse({'error': False, 'success_url': success_url})
return JsonResponse({'error': True, 'errors': form.errors})
context = {}
context["lead_obj"] = lead_record
user_assgn_list = [
assigned_to.id for assigned_to in lead_record.get_assigned_users_not_in_teams]
if request.user == lead_record.created_by:
user_assgn_list.append(request.user.id)
if request.user.role != "ADMIN" and not request.user.is_superuser:
if request.user.id not in user_assgn_list:
raise PermissionDenied
team_ids = [user.id for user in lead_record.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["lead_form"] = form
context["accounts"] = Account.objects.filter(status="open")
context["users"] = users
context["users_excluding_team"] = users_excluding_team
context["countries"] = COUNTRIES
context["status"] = LEAD_STATUS
context["source"] = LEAD_SOURCE
context["error"] = error
context["teams"] = Teams.objects.all()
context["assignedto_list"] = [
int(i) for i in request.POST.getlist('assigned_to', []) if i]
return render(request, template_name, context)
def create_opportunity(request):
accounts = Account.objects.filter(status="open", company=request.company)
contacts = Contact.objects.filter(company=request.company)
if request.user.role != "ADMIN" and not request.user.is_superuser:
accounts = Account.objects.filter(created_by=request.user,
company=request.company)
contacts = Contact.objects.filter(
Q(assigned_to__in=[request.user])
| Q(created_by=request.user)).filter(company=request.company)
users = []
if request.user.role == "ADMIN" or request.user.is_superuser:
users = User.objects.filter(is_active=True,
company=request.company).order_by("email")
elif request.user.google.all():
users = []
else:
users = User.objects.filter(role="ADMIN",
company=request.company).order_by("email")
kwargs_data = {
"assigned_to": users,
"account": accounts,
"contacts": contacts,
"request_obj": request,
}
if request.POST:
form = OpportunityForm(request.POST, request.FILES, **kwargs_data)
if form.is_valid():
opportunity_obj = form.save(commit=False)
opportunity_obj.created_by = request.user
opportunity_obj.company = request.company
if request.POST.get("stage") in ["CLOSED WON", "CLOSED LOST"]:
opportunity_obj.closed_by = request.user
opportunity_obj.save()
if request.POST.getlist("assigned_to", []):
opportunity_obj.assigned_to.add(
*request.POST.getlist("assigned_to"))
# assigned_to_list = request.POST.getlist('assigned_to')
# current_site = get_current_site(request)
# recipients = assigned_to_list
# send_email_to_assigned_user.delay(recipients, opportunity_obj.id, domain=current_site.domain,
# protocol=request.scheme)
# for assigned_to_user in assigned_to_list:
# user = get_object_or_404(User, pk=assigned_to_user)
# mail_subject = 'Assigned to opportunity.'
# message = render_to_string(
# 'assigned_to/opportunity_assigned.html', {
# 'user': user,
# 'domain': current_site.domain,
# 'protocol': request.scheme,
# 'opportunity': opportunity_obj
# })
# email = EmailMessage(
# mail_subject, message, to=[user.email])
# email.content_subtype = "html"
# email.send()
if request.POST.getlist("teams", []):
user_ids = Teams.objects.filter(
id__in=request.POST.getlist("teams")).values_list(
"users", flat=True)
assinged_to_users_ids = opportunity_obj.assigned_to.all(
).values_list("id", flat=True)
for user_id in user_ids:
if user_id not in assinged_to_users_ids:
opportunity_obj.assigned_to.add(user_id)
if request.POST.getlist("teams", []):
opportunity_obj.teams.add(*request.POST.getlist("teams"))
current_site = get_current_site(request)
recipients = list(opportunity_obj.assigned_to.all().values_list(
"id", flat=True))
send_email_to_assigned_user.delay(
recipients,
opportunity_obj.id,
domain=current_site.domain,
protocol=request.scheme,
)
if request.POST.getlist("contacts", []):
opportunity_obj.contacts.add(*request.POST.getlist("contacts"))
if request.POST.get("tags", ""):
tags = request.POST.get("tags")
splitted_tags = tags.split(",")
for t in splitted_tags:
tag = Tags.objects.filter(name=t.lower())
if tag:
tag = tag[0]
else:
tag = Tags.objects.create(name=t.lower())
opportunity_obj.tags.add(tag)
if request.FILES.get("oppurtunity_attachment"):
attachment = Attachments()
attachment.created_by = request.user
attachment.file_name = request.FILES.get(
"oppurtunity_attachment").name
attachment.opportunity = opportunity_obj
attachment.attachment = request.FILES.get(
"oppurtunity_attachment")
attachment.save()
success_url = reverse("opportunities:list")
if request.POST.get("savenewform"):
success_url = reverse("opportunities:save")
if request.POST.get("from_account"):
from_account = request.POST.get("from_account")
success_url = reverse("accounts:view_account",
kwargs={"pk": from_account})
# print(success_url)
return JsonResponse({"error": False, "success_url": success_url})
return JsonResponse({"error": True, "errors": form.errors})
context = {}
context["opportunity_form"] = OpportunityForm(**kwargs_data)
context["accounts"] = accounts
if request.GET.get("view_account"):
context["account"] = get_object_or_404(
Account, id=request.GET.get("view_account"))
context["contacts"] = contacts.filter(company=request.company)
context["users"] = kwargs_data["assigned_to"]
context["currencies"] = CURRENCY_CODES
context["stages"] = STAGES
context["sources"] = SOURCES
context["teams"] = Teams.objects.filter(company=request.company)
context["assignedto_list"] = [
int(i) for i in request.POST.getlist("assigned_to", []) if i
]
context["contacts_list"] = [
int(i) for i in request.POST.getlist("contacts", []) if i
]
return render(request, "create_opportunity.html", context)
