def patch(self, request, pk, format=None):
note = self.get_object(pk)
serializer = NoteSerializer(note, data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_validation_failure(self):
"""
Tests thata serializer.is_valid() if missing fields
returns:
"""
# missing title
data = self.note_data.copy()
del data["title"]
serializer = NoteSerializer(data=data)
self.assertFalse(serializer.is_valid())
with self.assertRaises(AssertionError):
serializer.save()
self.assertEqual(Note.objects.count(), 0)
data = self.note_data.copy()
del data["content"]
serializer = NoteSerializer(data=data)
self.assertFalse(serializer.is_valid())
with self.assertRaises(AssertionError):
serializer.save()
self.assertEqual(Note.objects.count(), 0)
def update(self, request, pk):
note = self.get_obj_and_check_permission(Note, request, pk)
serializer = NoteSerializer(note, request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
def post(self, request, note_id):
try:
note = Note.objects.get(id=note_id)
except ObjectDoesNotExist:
response = {
"message": "Object doesn't exist"
}
return Response(response)
data = {}
file = request.data['audio']
file_name = note.init_file_name(file)
if file_name == "":
response = {
"message": "file name error"
}
return Response(response)
uploader = CloudinaryUploader(file=file,public_id=file_name,folder="notes/audios", resource_type="video")
r = uploader.upload()
data['audio'] = r['secure_url']
serializer = NoteSerializer(note, data=data, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
else:
response = {
"message": "Upload file failed"
}
return Response(response)
def put(self, request, pk, format=None):
note = self.get_object(pk)
self.check_object_permissions(request, note)
serializer = NoteSerializer(note, data=request.data)
if serializer.is_valid():
serializer.save(owner=request.user.profile)
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
serializer = NoteSerializer(data=request.data)
#another method of saving
# serializer.is_valid(raise_exception=True)
# serializer.save(owner=request.user.profile)
# return Response(serializer.data,status=status.HTTP_201_CREATED)
if serializer.is_valid():
serializer.save(owner=request.user.profile)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_try_post_invalid_note(self):
try:
with transaction.atomic():
# Arrange - note with missing phrase
note_json = {
"context": "Hola amiga!",
"definition": "Hi",
"language": "es",
"owner": self.user
}
# Act
serializer = NoteSerializer(data=note_json)
self.assertFalse(serializer.is_valid())
finally:
pass
def note_detail(request, pk):
try:
snippet = Note.objects.get(pk=pk)
except Note.DoesNotExist:
return HttpResponse(status=404)
if request.method == 'GET':
serializer = NoteSerializer(snippet)
return JsonResponse(serializer.data)
def notes(self, request, pk=None):
if request.method == 'POST':
serializer = NoteSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save(new_hire=self.get_object(), admin=request.user)
return Response(serializer.data, status=status.HTTP_201_CREATED)
notes = Note.objects.filter(new_hire=self.get_object()).order_by('-created')
return Response(NoteSerializer(notes, many=True).data)
class UserSerializer(serializers.ModelSerializer):
mobile = serializers.CharField(
required=True,
validators=[UniqueValidator(queryset=User.objects.all())],
max_length=10,
)
full_name = serializers.CharField(max_length=40)
password = serializers.CharField(min_length=6, write_only=True)
edit_access_to = NoteSerializer(many=True, no_access=True)
view_access_to = NoteSerializer(many=True, no_access=True)
def __init__(self, *args, **kwargs):
show_access_only = kwargs.pop("show_access_only", False)
super(UserSerializer, self).__init__(*args, **kwargs)
if not show_access_only:
self.fields.pop("edit_access_to")
self.fields.pop("view_access_to")
else:
self.fields.pop("id")
self.fields.pop(User.USERNAME_FIELD)
self.fields.pop("full_name")
def create(self, validated_data):
user = User.objects.create_user(
validated_data["mobile"],
validated_data["password"],
full_name=validated_data["full_name"],
)
return user
class Meta:
model = User
fields = [
"id",
User.USERNAME_FIELD,
"full_name",
"password",
"edit_access_to",
"view_access_to",
]
def test_validation_success(self):
"""
Tests that serializer.is_valid() is True if required fields and
serializer.save() --> Saves note
returns:
"""
serializer = NoteSerializer(data=self.note_data)
self.assertTrue(serializer.is_valid())
serializer_note = serializer.save()
for field in self.note_data:
self.assertEqual(eval(f"serializer_note.{field}"), self.note_data.get(field))
self.assertTrue(hasattr(serializer_note, "date_created"))
# Assert For model level
model_note = Note.objects.first()
for field in self.note_data:
self.assertEqual(eval(f"model_note.{field}"), self.note_data.get(field))
self.assertEqual(serializer_note, model_note)
def get(self, request, category_id, unit_id):
try:
category = Category.objects.get(id=category_id)
unit = category.list_unit.get(id=unit_id)
except ObjectDoesNotExist:
response = {
"message": "Object doesn't exist"
}
return Response(response)
notes = unit.note_set.all()
serializer=NoteSerializer(notes, many=True)
return Response(serializer.data)
def note_element(request, pk):
try:
note = Note.objects.get(pk=pk)
except Note.DoesNotExist:
return HttpResponse(status=404)
if request.method == 'GET':
serializer = NoteSerializer(note)
return Response(serializer.data)
elif request.method == 'DELETE':
note.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def notes_list(request):
if request.method == 'GET':
notes = Note.objects.all()
serializer = NoteSerializer(notes, many=True)
return JsonResponse(serializer.data, safe=False)
elif request.method == 'POST':
data = JSONParser().parse(request)
serializer = NoteSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def note_collection(request):
if request.method == 'GET':
notes = Note.objects.all()
serializer = NoteSerializer(notes, many=True)
return Response(serializer.data)
elif request.method == 'POST':
data = {
'title': request.data.get('title'),
'body': request.data.get('body')
}
serializer = NoteSerializer(data=data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD)
def redis_conn_trash(self, note_query_set):
new_list = []
for note in note_query_set:
note_id = 'note' + str(note.id)
redis_data = redis_obj.get(note_id)
if redis_data is not None:
data = redis_data.decode('utf-8')
redis_dict = ast.literal_eval(data)
else:
note_object = Note.objects.filter(id=note.id)
note_serializer = NoteSerializer(note_object, many=True)
data = [{k: v
for k, v in data.items()}
for data in note_serializer.data]
redis_obj.set(note_id, str(data))
redis_dict = note_serializer.data
new_list.append(redis_dict)
return new_list
def note_detail(request, pk):
try:
note = Note.objects.get(pk=pk)
except Note.DoesNotExist:
return HttpResponse(status=404)
if request.method == 'GET':
serializer = NoteSerializer(note)
return JsonResponse(serializer.data)
elif request.method == 'PUT':
data = JSONParser().parse(request)
serializer = NoteSerializer(note, data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
return JsonResponse(serializer.errors, status=400)
elif request.method == 'DELETE':
note.delete()
return HttpResponse(status=204)
def test_try_put_invalid_note(self):
# Arrange - note with missing phrase
note_json = {
"phrase": "Hola",
"context": "Hola amiga!",
"definition": "Hi",
"language": "es",
"owner": self.user
}
serializer = NoteSerializer(data=note_json)
self.assertTrue(serializer.is_valid())
# Act
note_json["phrase"] = None
# Assert
serializer = NoteSerializer(data=note_json)
self.assertFalse(serializer.is_valid())
def list(self, request):
notes = Note.objects.filter(user=request.user)
serializer = NoteSerializer(notes, many=True)
return Response(serializer.data)
def notes_detail(request, notes_id):
if request.method == 'GET':
notes = Note.objects.filter(id=notes_id).first()
serializer = NoteSerializer(notes)
return JsonResponse(serializer.data, safe=False)
def get(self, request, format=None):
notes = Note.objects.all()
serializer = NoteSerializer(notes, many=True)
return Response(serializer.data)
def post(self, request, format=None):
serializer = NoteSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, pk, format=None):
print(pk)
note = self.get_object(pk)
serializer = NoteSerializer(note)
return Response(serializer.data)
def create(self, request):
serializer = NoteSerializer(data=request.data)
if serializer.is_valid():
serializer.save(user=request.user)
return Response(serializer.data, status.HTTP_201_CREATED)
return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
def get(self, request, note_id):
note = self.check_existance(note_id)
serialized = NoteSerializer(note)
return Response(serialized.data)
def partial_update(self, request, pk=None):
note = get_object_or_404(Note, pk=pk)
serializer = NoteSerializer(note, data=request.data, partial=True)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data)
def handle(self, *args, **options):
exported_data = []
username = get_env_variable('ELASTIC_USERNAME')
password = get_env_variable('ELASTIC_PASSWORD')
index_name = get_env_variable('INDEX_NAME')
es = Elasticsearch([{
'host': 'localhost',
'post': 9200
}],
timeout=30,
http_auth=(username, password))
last_updated = datetime.now() - timedelta(365 * 10)
with open('/home/ubuntu/vms2/pushToEs_last_updated', 'r') as f:
rows = csv.reader(f)
for row in rows:
last_updated = datetime.strptime(row[0],
"%Y-%m-%d %H:%M:%S.%f")
tasks = Task.objects.filter(updated_at__gt=last_updated).exclude(
task_type__task_type='Retention Survey').order_by(
'updated_at')[:1000]
# tasks = Task.objects.filter(updated_at__gt=last_updated).order_by('updated_at')[:2500]
for task in tasks:
task_doc = dict(TaskListTaskSerializer(task).data)
task_doc['timestamp'] = datetime.now()
task_doc['form_data'] = dict(
FormDataSerializer(task.form_data).data)
task_doc['task_status_category'] = dict(
TaskStatusCategorySerializer(task.status.category).data)
if task.beneficiary and hasattr(task.beneficiary, 'profile'):
task_doc['beneficiary'][
'date_joined'] = task.beneficiary.date_joined
task_doc['beneficiary']['profile'] = dict(
UserSerializer(task.beneficiary.profile).data)
task_doc['beneficiary']['notes'] = json.loads(
json.dumps(
NoteSerializer(
task.beneficiary.beneficiary_notes.all(),
many=True).data))
if task.beneficiary and hasattr(task.beneficiary,
'persistent_data'):
task_doc['beneficiary']['persistent_data'] = dict(
PersistentFormDataSerializer(
task.beneficiary.persistent_data).data)
if 'Address' in task_doc['beneficiary']['persistent_data'][
'data'].keys():
try:
location = Location.objects.get(
pk=task_doc['beneficiary']['persistent_data']
['data']['Address'])
task_doc['beneficiary']['location'] = dict(
LocationSerializer(location).data)
task_doc['beneficiary']['location'][
'geocordinates'] = {}
task_doc['beneficiary']['location']['geocordinates'][
'lat'] = location.lat
task_doc['beneficiary']['location']['geocordinates'][
'lon'] = location.lng
except:
pass
calls = Call.objects.filter(task=task)
task_doc['calls'] = []
for call in calls:
call_dict = dict(CallSerializer(call).data)
if call_dict['end']:
call_duration = (call.end_time - call.start_time).seconds
call_dict['duration'] = call_duration
call_dict['caller'] = dict(
UserSerializer(call.caller.profile).data)
task_doc['calls'].append(call_dict)
if task.beneficiary:
task_doc['beneficiary']['tags'] = []
tags = task.beneficiary.tags.all()
for tag in tags:
task_doc['beneficiary']['tags'].append(
dict(LightTagSerializer(tag).data))
if hasattr(task.beneficiary.profile, 'stage'):
task_doc['beneficiary']['stage'] = dict(
StageSerializer(task.beneficiary.profile.stage).data)
if task.assignee and hasattr(task.assignee, 'profile'):
task_doc['assignee']['profile'] = dict(
UserSerializer(task.assignee.profile).data)
if task.assignee and hasattr(task.assignee, 'profile') and hasattr(
task.assignee.profile, 'guild'):
task_doc['assignee']['guild'] = dict(
GuildSerializer(task.assignee.profile.guild).data)
# print task_doc
try:
res = es.index(index=index_name,
doc_type='task',
id=task.id,
body=task_doc)
except Exception as e:
if e.error == 'mapper_parsing_exception':
print task_doc
task_doc['beneficiary']['persistent_data']['data'][
'Children'][0]['Date of Birth'] = datetime.strptime(
task_doc['beneficiary']['persistent_data']['data']
['Children'][0]['Date of Birth'], '%d/%m/%Y')
res = es.index(index='ia',
doc_type='task',
id=task.id,
timestamp=task_doc['timestamp'],
body=task_doc)
# print task_doc
continue
last_updated = task.updated_at
# print task_doc
break
last_updated = task.updated_at
with open('/home/ubuntu/vms2/pushToEs_last_updated', 'w') as f:
f.write(last_updated.strftime("%Y-%m-%d %H:%M:%S.%f"))
def retrieve(self, request, pk):
note = self.get_obj_and_check_permission(Note, request, pk)
serializer = NoteSerializer(note)
return Response(serializer.data)
def see_notes(self, request, pk=None):
user = self.get_object()
book = request.data.get('book')
own_notes = Note.objects.all().filter(Q(user=user), Q(book=book))
serialized = NoteSerializer(own_notes, many=True)
return Response(serialized.data)
def retrieve(self, request, pk=None):
note = get_object_or_404(Note, pk=pk)
serializer = NoteSerializer(note)
return Response(serializer.data)