class InternRoleFullSerializer(InternRoleSerializer):
role = RoleSerializer(read_only=True)
intern = SimpleInternSerializer(read_only=True)
semesters = SemesterSerializer(many=True)
created_by = UserSerializer(read_only=True)
last_editor = UserSerializer(read_only=True)
removed_by = UserSerializer(read_only=True)
date_added = serializers.DateField(read_only=True)
date_edited = serializers.DateField(read_only=True)
date_removed = serializers.DateField(read_only=True)
access_given = serializers.BooleanField()
date_access_given = serializers.DateTimeField(read_only=True)
date_access_revoked = serializers.DateTimeField(read_only=True)
class Meta:
model = InternRole
fields = (
"id",
"intern",
"role",
"semesters",
"access_given",
"date_access_given",
"date_access_revoked",
"date_added",
"date_removed",
"date_edited",
"comments",
"created_by",
"last_editor",
"removed_by",
"recieved_interncard",
)
class InternRoleFullSerializer(InternRoleSerializer):
role = RoleSerializer(read_only=True)
intern = SimpleInternSerializer(read_only=True)
semesters = SemesterSerializer(many=True)
created_by = UserSerializer(read_only=True)
last_editor = UserSerializer(read_only=True)
removed_by = UserSerializer(read_only=True)
date_added = serializers.DateField(read_only=True)
date_edited = serializers.DateField(read_only=True)
date_removed = serializers.DateField(read_only=True)
access_given = serializers.BooleanField()
date_access_given = serializers.DateTimeField(read_only=True)
date_access_revoked = serializers.DateTimeField(read_only=True)
class Meta:
model = InternRole
fields = (
'id',
'intern',
'role',
'semesters',
'access_given',
'date_access_given',
'date_access_revoked',
'date_added',
'date_removed',
'date_edited',
'comments',
'created_by',
'last_editor',
'removed_by',
'recieved_interncard',
)
class TaskSerializer(serializers.ModelSerializer):
access_list = UserSerializer(read_only=True, many=True)
owner = UserSerializer(read_only=True)
class Meta:
model = Task
fields = ('id', 'name', 'description', 'end_time', 'owner',
'access_list')
class RequestListSerializer(RequestSerializer):
request_by = UserSerializer()
processed_by = UserSerializer()
class Meta:
model = EmployeeRequest
fields = RequestSerializer.Meta.fields + (
'request_by',
'processed_by',
'created_at',
)
class CardSerializer(serializers.ModelSerializer):
"""
General purpose Card serializer
"""
dueño = UserSerializer(read_only=True)
miembros = UserSerializer(many=True, read_only=True)
class Meta:
model = Tarjeta
fields = ('nombre', 'miembros', 'lista', 'descripcion', 'dueño')
def test_password_validation(self):
"""test for password validation"""
# true
serializer = UserSerializer(
data={
'username': '******',
'first_name': 'first',
'last_name': 'last',
'password': '******'
})
self.assertTrue(serializer.is_valid())
# less than 8 chars
serializer = UserSerializer(
data={
'username': '******',
'first_name': 'first',
'last_name': 'last',
'password': '******'
})
self.assertFalse(serializer.is_valid())
# user attr similar
serializer = UserSerializer(
data={
'username': '******',
'first_name': 'first',
'last_name': 'last',
'password': '******'
})
self.assertFalse(serializer.is_valid())
# common password
serializer = UserSerializer(
data={
'username': '******',
'first_name': 'first',
'last_name': 'last',
'password': '******'
})
self.assertFalse(serializer.is_valid())
# numbers only
serializer = UserSerializer(
data={
'username': '******',
'first_name': 'first',
'last_name': 'last',
'password': '******'
})
self.assertFalse(serializer.is_valid())
class ProfileSerializer(serializers.ModelSerializer):
user = UserSerializer()
phones = PhoneSerializer(many=True)
guardians = UserSerializer(many=True, required=False)
class Meta:
model = Profile
fields = ('id', 'user', 'phones', 'guardians', 'active', 'cpf', 'rg',
'birth_date', 'genre', 'cep', 'logradouro', 'complemento',
'bairro', 'localidade', 'uf')
def create(self, validated_data):
user_data = validated_data.pop('user')
phones_data = validated_data.pop('phones')
guardians_data = validated_data.pop(
'guardians') if 'guardians' in validated_data else []
user = User.objects.create(**user_data)
profile = Profile.objects.create(user=user, **validated_data)
for guardian_data in guardians_data:
guardian = User.objects.get_or_create(**guardian_data)[0]
guardian.save()
profile.guardians.add(guardian)
for phone_data in phones_data:
phone = Phone.objects.create(**phone_data)
profile.phones.add(phone)
return profile
def update(self, instance, validated_data):
user_data = validated_data.pop('user')
phones_data = validated_data.pop('phones')
guardians_data = validated_data.pop(
'guardians') if 'guardians' in validated_data else []
for field, value in user_data.items():
setattr(instance.user, field, value)
for field, value in validated_data.items():
setattr(instance, field, value)
for guardian_data in guardians_data:
guardian = User.objects.get_or_create(**guardian_data)[0]
guardian.save()
instance.guardians.add(guardian)
# for phone_data in phones_data:
# phone = Phone.objects.get_or_create(**phone_data)[0]
# phone.save()
# instance.phones.add(phone)
instance.user.save()
instance.save()
return instance
class ClassSerializer(serializers.ModelSerializer):
user = UserSerializer(many=False, read_only=True)
user_id = serializers.IntegerField(write_only=True)
class Meta:
model = Class
fields = '__all__'
class InfoSerializer(serializers.ModelSerializer):
user = UserSerializer(read_only=True)
class Meta:
model = Info
fields = '__all__'
read_only_fields = ('user', )
def social_login(request):
json_body = json.loads(request.body)
try:
auth_token = json_body["token"]
provider = json_body["provider"]
except KeyError:
return HttpResponseBadRequest("Missing args")
try:
email = verify_user(auth_token=auth_token, provider=provider)
except SocialAuthInvalidTokenException as e:
logger.warning("Invalid social auth token provided", exc_info=e)
return HttpResponseForbidden()
try:
user = User.objects.get(email=email)
created = False
except User.DoesNotExist:
user = User.objects.create_user(email)
created = True
# If there is already a player in the session, set it on the user
do_user_player_coherence(request, user)
login(request, user)
resp = UserSerializer(user).data
resp["_created"] = created
return JsonResponse(resp)
def put(self, request, pk):
user = self.get_object(pk)
serializer = UserSerializer(user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class UserTeamSerializer(serializers.ModelSerializer):
user = UserSerializer(read_only=True)
class Meta:
model = UserTeam
fields = ('id', 'user', 'team')
class ArquivoSerializer(serializers.ModelSerializer):
#leituras = LeituraSimplificadoSerializer(source='arquivo', many=True)
acelerometro = AcelerometroSimplificadoSerializer()
usuario = UserSerializer()
class Meta:
model = Arquivo
fields = ('__all__')
class LoanSerializer(serializers.ModelSerializer):
created = serializers.DateTimeField(format=DATETIME_FORMAT, read_only=True)
modified = serializers.DateTimeField(format=DATETIME_FORMAT,
read_only=True)
client = UserSerializer()
value = serializers.SerializerMethodField()
amount_due = serializers.SerializerMethodField()
interest_rate = serializers.SerializerMethodField()
balance_due = serializers.SerializerMethodField()
class Meta:
model = Loan
fields = '__all__'
def get_value(self, obj):
return f'R$ {obj.value:.2f}'
def get_amount_due(self, obj):
return f'R$ {obj.amount_due:.2f}'
def get_interest_rate(self, obj):
return f'{100.0 * float(obj.interest_rate):.2f}%'
def get_balance_due(self, obj):
return f'R$ {obj.make_balance_due():.2f}'
def login_user(request):
try:
data = json.loads(request.body)
except json.JSONDecodeError:
return HttpResponseBadRequest()
if 'username' not in data:
return HttpResponseBadRequest(
json.dumps({"username": "******"}))
if 'password' not in data:
return HttpResponseBadRequest(
json.dumps({"password": "******"}))
user = authenticate(request,
username=data['username'],
password=data['password'])
if not user:
return HttpResponseBadRequest(
json.dumps({"password": "******"}))
login(request, user)
data = UserSerializer(
user,
context={
'request': request
},
).data
return HttpResponse(JSONRenderer().render(data),
content_type="application/json")
def post(self, request):
serialized = UserSerializer(data=request.data)
if serialized.is_valid():
serialized.save()
return Response(serialized.data)
else:
return Response(serialized._errors, status=400)
def to_representation(self, value):
if isinstance(value, User):
return UserSerializer(value).data
elif isinstance(value, Post):
return PostSerializer(value, context={'request': None}).data
else:
return 'unknown'
class EventSerializer(serializers.HyperlinkedModelSerializer):
cause = EventRelatedField(read_only=True)
author = UserSerializer()
class Meta:
model = Event
fields = ('object_id', 'cause', 'author', 'created_at', 'causeType', 'id')
def current_user(request):
"""
Determine the current user by their token, and return their data
"""
serializer = UserSerializer(request.user)
return Response(serializer.data)
def my_jwt_response_handler(token, user=None, request=None):
return {
"token": token,
"user": UserSerializer(user, context={
"request": request
}).data,
}
def get(self, request):
if request.method == 'GET':
#get current user
serializer = UserSerializer(request.user)
#get stories
stories = request.GET.get('stories')
#get architecture
architecture = request.GET.get('architecture')
#predict image
prediction = predict_image(serializer.data)
#build response
response_andrei = {
'email':
'*****@*****.**',
'img':
"image_generated" + list(serializer.data.values())[0] + ".png",
}
response_andrei.update(serializer.data)
response = []
response.append(response_andrei)
#return response
return JsonResponse(response, safe=False)
class ProjectSerializer(serializers.ModelSerializer):
users = UserSerializer(many=True, read_only=True)
workspace = WorkspaceSerializer(read_only=True)
class Meta:
model = Project
fields = ('id', 'name', 'description', 'users', 'workspace', 'created_at')
def post(self, request, format='json'):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user:
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class Meta:
model = Friendship
fields = ("id", "requester_user", "addresser_user", "status",
"request_date", "approval_date", "friendship_end_date",
"active")
requester_user = UserSerializer(source="manager_user", read_only=True)
extra_kwargs = {
"requester_user": {
"read_only": True
},
"request_date": {
"read_only": True
},
"approval_date": {
"read_only": True
},
"friendship_end_date": {
"read_only": True
},
"active": {
"read_only": True
},
"status": {
"read_only": True
},
}
class InternSerializer(serializers.ModelSerializer):
user = UserSerializer()
roles = serializers.SerializerMethodField()
log = InternLogEntrySerializer(many=True, read_only=True)
comments = serializers.CharField(max_length=300,
allow_blank=True,
required=False)
class Meta:
model = Intern
fields = (
"id",
"user",
"active",
"comments",
"roles",
"registered",
"left",
"log",
)
def update(self, instance, validated_data):
instance.comments = validated_data.get("comments", instance.comments)
instance.save()
return instance
def get_roles(self, obj):
roles = InternRole.objects.filter(intern=obj,
date_removed__isnull=True)
serializer = InternRoleSerializer(instance=roles, many=True)
return serializer.data
