def partial_update(self, request, pk=None):
"""
:param request:
:param pk:
:return:
"""
request.data["changed_by"] = self.request.user.username
instance = get_or_none(Contact, id=pk)
if not isinstance(instance, Contact):
return error_response(
data={"error": "Contact Book does not exist"},
msg='Contact does not exists',
status=status.HTTP_404_NOT_FOUND)
serializer = ContactSerializer(instance=instance,
data=request.data,
partial=True)
if serializer.is_valid():
serializer.save()
return success_response(status=status.HTTP_202_ACCEPTED,
msg='Contact Book is updated',
data=serializer.data)
return error_response(status=status.HTTP_400_BAD_REQUEST,
msg='Invalid data',
data=serializer.errors)
def get_contact(request):
try:
if request.method == 'POST':
myForm = ContactForm(request.POST)
if myForm.is_valid():
name = myForm.cleaned_data['name']
email = myForm.cleaned_data['email']
message = myForm.cleaned_data['message']
email_from = settings.EMAIL_HOST_USER
mobile = myForm.cleaned_data['mobile']
message = str(mobile) +' ' + message
recipient_list = ['*****@*****.**']
contact_serializer = ContactSerializer(
data={'mobile': mobile, 'email': email})
# if not email:
# raise ValueError('Enter a valid email address')
if contact_serializer.is_valid():
new_user = Contact.objects.create(name=name,
email=email,
mobile=mobile,
message=message
)
send_mail(name, message, email_from, recipient_list)
messages.success(request, 'You are Noted Down, Hang ON!')
# template = loader.get_template('contact/home.html')
else:
form = ContactForm()
return render(request, 'contact/contact.html', {'form': myForm});
except Exception as e:
print(e, traceback.format_exc())
return JSONResponse({'code': 500, 'response': 'Failed to signup'})
def post(self, request, format=None):
serializer = ContactSerializer(data=request.data)
if serializer.is_valid():
msg = serializer.save()
bot.send_notification(msg)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
owner = request.user.username
contacts = Contact.objects.all().filter(owner=owner)
contacts.delete
for contact in request.data:
contact['owner'] = owner
serializer = ContactSerializer(data=request.data, many=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=201)
return Response(serializer.errors, status=400)
def post(self, request):
user = User.objects.get(username=self.request.user)
serializer = ContactSerializer(data=request.data)
if not serializer.is_valid():
return Response({'serializer': serializer})
contact = serializer.save()
user.contact = contact
user.save()
return redirect(reverse_lazy(url_employee_contact))
def put(self, request: HttpRequest, contact_id: int) -> Response:
"""
:param request:
:param id:
:return:
"""
contact = self.get_object(contact_id)
serializer = ContactSerializer(contact, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request: HttpRequest) -> Response:
"""
:param request:
:return:
"""
serializer = ContactSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response({
"serializer.data": 200,
"status": status.HTTP_201_CREATED
})
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request: HttpRequest) -> Response:
"""
:param request:
:return:
"""
contact = Contact.objects.all()
serializer = ContactSerializer(contact, many=True)
return Response(serializer.data)
def create(self, request):
"""
:param request:
:return:
"""
request.data["created_by"] = self.request.user.username
request.data["changed_by"] = self.request.user.username
serializer = ContactSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return success_response(status=status.HTTP_201_CREATED,
msg='Contact is created',
data=serializer.data)
return error_response(status=status.HTTP_400_BAD_REQUEST,
msg='Invalid data',
data=serializer.errors)
def contact_lists_by_type(request):
if request.method == 'GET':
contacts = Contact.objects.all()
first_name = request.GET.get('f_name', None)
if first_name is not None:
contacts = contacts.filter(f_name__icontains=first_name)
contacts_serializer = ContactSerializer(contacts, many=True)
return JsonResponse(contacts_serializer.data, safe=False)
def get(self,
request: HttpRequest,
contact_id: int,
format=None) -> Response:
"""
:param id:
:return:
"""
contact = self.get_object(contact_id)
serializer = ContactSerializer(contact)
return Response(serializer.data)
class AppointmentSerializer(serializers.ModelSerializer):
id = serializers.ReadOnlyField()
contact = ContactSerializer(read_only=True)
notes = AppointmentNoteSerializer(many=True, required=False)
driving_times = AppointmentDrivingTimeSerializer(many=True, required=False)
def create(self, validated_data):
notes = validated_data.pop('notes', [])
appointment = super().create(validated_data)
notes_list = []
for note in notes:
ans = AppointmentNoteSerializer(data=note)
ans.is_valid(raise_exception=True)
notes_list.append(ans.save())
appointment.notes.set(notes_list)
return appointment
def update(self, instance, validated_data):
notes = validated_data.pop('notes', [])
super().update(instance, validated_data)
for note in notes:
instance_note, _ = instance.notes.get_or_create(type=note['type'])
instance_note.note = note['note']
instance_note.save()
return instance
def validate_notes(self, value):
types_list = []
for note in value:
if note['type'] in types_list:
raise serializers.ValidationError(
'every type is only allowed once')
types_list.append(note['type'])
return value
def validate_type(self, value):
if not value:
raise serializers.ValidationError(
'type must be an array of one or more string elements')
return value
def validate_organization_uuid(self, value):
if value:
request = self.context['request']
user_org_uuid = request.session.get('jwt_organization_uuid')
if user_org_uuid != str(value):
raise serializers.ValidationError(
'The Organization cannot be different than user\'s '
'organization')
return value
class Meta:
model = Appointment
exclude = ('owner', )
def contact_list(request):
"""
List all code contacts, or delete a contact.
"""
if request.user.is_authenticated:
if request.method == 'GET':
contacts = Contact.objects.all()
serializer = ContactSerializer(contacts, many=True)
return Response(serializer.data)
else:
return Response(status=status.HTTP_204_NO_CONTENT)
return Response({'msg': "login required"},
status=status.HTTP_403_FORBIDDEN)
def sendMessage(request):
"""
send contact message
"""
if request.method == 'POST':
data = request.data
serializer = ContactSerializer(data=data)
if serializer.is_valid():
# Email the profile with the
# contact information
subject = data['subject']
message = 'Works!'
from_email = settings.EMAIL_HOST_USER
to_list = ['*****@*****.**']
#print(from_email, to, subject)
#mail = EmailMultiAlternatives(subject, html_content, "from_email", [to])
#mail.attach_alternative(html_content, "text/html")
#mail.send()
send_mail(subject, message, from_email, to_list) #fail_silently=True
return Response({"success": "true"}, status=status.HTTP_201_CREATED)
def retrieve(request, pk=None):
"""
:param request:
:param pk:
:return:
"""
instance = get_or_none(Contact, id=pk)
if isinstance(instance, Contact):
serializer = ContactSerializer(instance=instance)
return success_response(data=serializer.data,
status=status.HTTP_200_OK,
msg='success')
return error_response(data={"error": "Contact Book does not exist"},
msg='Contact does not exists',
status=status.HTTP_404_NOT_FOUND)
def contactlist(request):
if request.method == 'GET':
contacts = Contact.objects.all()
contact_serializer = ContactSerializer(contacts, many=True)
return JsonResponse(contact_serializer.data, safe=False)
elif request.method == 'POST':
contact_data = JSONParser().parse(request)
contact_serializer = ContactSerializer(data=contact_data)
if contact_serializer.is_valid():
contact_serializer.save()
return JsonResponse(contact_serializer.data,
status=status.HTTP_201_CREATED)
return JsonResponse(contact_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def detail_contact(request, id):
"""
Retrieve, update or delete a code snippet.
"""
if request.user.is_authenticated:
try:
contact = Contact.objects.get(pk=id)
except Contact.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = ContactSerializer(contact)
return Response(serializer.data)
elif request.method == 'DELETE':
contact.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
else:
return Response(status=status.HTTP_204_NO_CONTENT)
return Response({'msg': "login required"},
status=status.HTTP_403_FORBIDDEN)
def contact_update(request, pk):
try:
contact = Contact.objects.get(pk=pk)
except Contact.DoesNotExist:
return JsonResponse({'message': 'The contact does not exist'},
status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
contact_serializer = ContactSerializer(contact)
return JsonResponse(contact_serializer.data)
elif request.method == 'PUT':
contact_details = JSONParser().parse(request)
contact_serializer = ContactSerializer(contact, data=contact_details)
if contact_serializer.is_valid():
contact_serializer.save()
return JsonResponse(contact_serializer.data)
return JsonResponse(contact_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
contact.delete()
return JsonResponse({'message': 'Contact was deleted successfully!'},
status=status.HTTP_204_NO_CONTENT)
def contact_list(request):
if request.method == 'GET':
contacts = Contact.objects.all()
contact_serializer = ContactSerializer(contacts, many=True)
return JsonResponse(contact_serializer.data, safe=False)
elif request.method == 'POST':
contact_serializer = ContactSerializer(data=request.data)
if contact_serializer.is_valid():
contact_serializer.save()
return JsonResponse(contact_serializer.data,
status=status.HTTP_201_CREATED)
return JsonResponse(contact_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
count = Contact.objects.all().delete()
return JsonResponse(
{
'message': '{} Contact were deleted successfully!'.format(
count[0])
},
status=status.HTTP_204_NO_CONTENT)
class CourseSerializers(serializers.ModelSerializer):
"""Courses serializer"""
contacts = ContactSerializer(many=True, )
branches = BranchSerializer(many=True)
category = serializers.PrimaryKeyRelatedField(
queryset=Category.objects.all())
class Meta:
model = Courses
fields = ("contacts", "branches", "name", "description", "category",
"logo")
def create(self, validated_data):
branches = validated_data.pop("branches")
contact = validated_data.pop("contacts")
course = Courses.objects.create(**validated_data)
for branches in branches:
Branch.objects.create(course=course, **branches)
for contact in contact:
Contact.objects.create(course=course, **contact)
return course
def get(self, request):
user = User.objects.get(username=request.user)
serializer = ContactSerializer(instance=user.contact)
return Response({'serializer': serializer})
def get(self, request, format=None):
contacts = Contact.objects.all()
serializer = ContactSerializer(contacts, many=True)
return Response(serializer.data)
def contact_detail(request, pk):
"""
Retrieve, update or delete a code snippet.
"""
try:
contact = Contact.objects.get(pk=pk)
except Contact.DoesNotExist:
return Response(status=404)
if request.method == 'GET':
serializer = ContactSerializer(contact)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = ContactSerializer(contact, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=200)
return Response(serializer.errors, status=400)
elif request.method == 'DELETE':
contact.delete()
return Response(status=204)
elif request.method == 'POST':
serializer = ContactSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=201)
return Response(serializer.errors, status=400)
def get(self, request):
owner = request.user.username
contacts = Contact.objects.filter(owner=owner)
serializer = ContactSerializer(contacts, many=True)
return Response(serializer.data)
class AccountSerializer(serializers.ModelSerializer):
def validate_legalname(self, value):
if not value:
raise serializers.ValidationError("Legalname empty or missing")
return value
def validate_vat(self, value):
if not value:
raise serializers.ValidationError("Vat empty or missing")
if Account.objects.filter(vat=value).count() > 0:
raise serializers.ValidationError("Vat already exist")
return value
def validate_address(self, value):
if not value:
raise serializers.ValidationError("Address empty or missing")
return value
def validate_city(self, value):
if not value:
raise serializers.ValidationError("City empty or missing")
return value
def validate_zipcode(self, value):
if not value:
raise serializers.ValidationError("Zipcode empty or missing")
return value
def validate_country(self, value):
if not value:
raise serializers.ValidationError("Country empty or missing")
return value
def validate_province(self, value):
if not value:
raise serializers.ValidationError("Province empty or missing")
return value
def validate_phone(self, value):
if not value:
raise serializers.ValidationError("Phone empty or missing")
return value
def validate_email(self, value):
if not value:
raise serializers.ValidationError("Email empty or missing")
return value
def validate_type(self, value):
if not value:
raise serializers.ValidationError("Customer Type empty or missing")
return value
account_type = serializers.ChoiceField(choices=fields.CUSTOMER_TYPE,
source="type",
read_only=True)
contacts = ContactSerializer(many=True,
source="contact_set",
read_only=True)
notes = NoteSerializer(many=True, source="note_set", read_only=True)
class Meta:
model = Account
fields = [
"id",
"name",
"legalname",
"vat",
"address",
"city",
"zipcode",
"country",
"province",
"geo",
"phone",
"email",
"pec",
"sdi",
"account_type",
"update_date",
"create_date",
"contacts",
"notes",
]
read_only_fields = ["id"]
def post(self, request):
user = User.objects.get(username=request.user)
serializer = ContactSerializer(data=request.data)
serializer.update(instance=user.contact, validated_data=request.data)
return redirect(reverse_lazy(url_employee_contact))
def get(self, request):
contact = ContactSerializer()
return Response({'serializer': contact})
def post(self, request, format=None):
serializer = ContactSerializer(data=request.data)
if serializer.is_valid():
serializer.save(created=request.user)
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
