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)
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',
)
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 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",
)
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)
def post(self, request):
user_serializer = UserSerializer(data=request.data)
if user_serializer.is_valid():
user_object = user_serializer.save()
return Response(user_serializer.data, status=201)
return Response(user_serializer.errors, status=400)
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')
def post(self, request, format='json'):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user:
token = Token.objects.create(user=user)
json = serializer.data
json['token'] = token.key
return Response(json, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def signup(request):
serialized = UserSerializer(data=request.data)
if serialized.is_valid():
serialized.save()
created_user = User.objects.get(username=request.data['username'])
token = created_user.auth_token.key
return Response({"token": token}, status=status.HTTP_201_CREATED)
else:
return Response({'error': serialized.errors},
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
if not self.request.POST.get('registration_key', None) == getattr(
settings, "REGISTRATION_KEY"):
return Response("Update your application.",
status=status.HTTP_401_UNAUTHORIZED)
serializer = UserSerializer(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)
class RequestListSerializer(RequestSerializer):
request_by = UserSerializer()
processed_by = UserSerializer()
class Meta:
model = EmployeeRequest
fields = RequestSerializer.Meta.fields + (
'request_by',
'processed_by',
'created_at',
)
def put(self, request, pk, format=None):
if not self.check_owner(request, pk):
return Response(
"You cannot update the account details of other users.",
status=status.HTTP_403_FORBIDDEN)
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)
def create(self, request, **kwargs):
try:
password = make_password(request.data['password'])
serializer = UserSerializer(data=request.data,
context={'request': request})
except Http404:
return Response(status=status.HTTP_404_NOT_FOUND)
if serializer.is_valid():
serializer.save(password=password)
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
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 put(self, request, id=None):
try:
user_object = User.objects.get(id=id)
except User.DoesNotExist:
return Response({'errors': 'This user does not exist.'}, status=400)
user_serializer = UserSerializer(user_object, data=request.data)
if user_serializer.is_valid():
user_object = user_serializer.save()
return Response(user_serializer.data, status=200)
return Response(user_serializer.errors, status=400)
def post(self, request, format=None):
serializer = UserSerializer(request.user,
data=request.data,
context={'request': request})
if not serializer.is_valid():
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
serializer.save()
return Response(serializer.data)
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
User.objects.create_user(
username=serializer.validated_data['username'],
email=serializer.validated_data['email'],
password=serializer.validated_data['password'],
first_name=serializer.validated_data['first_name'],
last_name=serializer.validated_data['last_name'])
return Response({'message': 'Register successful!'},
status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class TableroSerializer(serializers.ModelSerializer):
"""
General purpose
"""
dueño = UserSerializer(read_only=True)
favoritos = UserSerializer(many=True, read_only=True)
miembros = UserSerializer(many=True, read_only=True)
class Meta:
model = Tablero
fields = ('nombre', 'descripcion', 'fecha_creacion', 'dueño',
'favoritos', 'miembros')
def test_username_unique(self):
"""test for username uniqueness"""
User.objects.create(username='******', password='******')
serializer = UserSerializer(
data={
'username': '******',
'first_name': 'first',
'last_name': 'last',
'password': '******'
})
self.assertFalse(serializer.is_valid())
def test_user_serializer_update(active_user_fixture):
serializer = UserSerializer(
active_user_fixture, {
"email": "*****@*****.**",
"password": "******",
"name": "another name"
})
assert serializer.is_valid()
assert serializer.errors == {}
serializer.save()
active_user_fixture.refresh_from_db()
assert active_user_fixture.name == "another name"
assert active_user_fixture.check_password("new_password")
def update(self, request, pk=None, **kwargs):
try:
password = make_password(request.data['password'])
instance = self.get_object()
self.check_object_permissions(self.request, instance)
serializer = UserSerializer(instance,
data=request.data,
context={'request': request})
except Http404:
return Response(status=status.HTTP_404_NOT_FOUND)
if serializer.is_valid():
serializer.save(password=password)
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_403_FORBIDDEN)
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 ProductSerializer(serializers.ModelSerializer):
owner = UserSerializer(read_only=True)
class Meta:
model = Product
fields = ('id', 'name', 'price', 'description', 'creation_date', 'category', 'on_auction', 'owner', 'image')
read_only_fields = ('owner', 'creation_date')
def get(self, request):
if request.user:
translation.activate(request.user.language)
request.session[
translation.LANGUAGE_SESSION_KEY] = request.user.language
return Response(UserSerializer(request.user).data)
return HttpResponseForbidden('user is not logged in')
def my_jwt_response_handler(token, user=None, request=None):
return {
'token': token,
'user': UserSerializer(user, context={
'request': request
}).data
}
class InfoSerializer(serializers.ModelSerializer):
user = UserSerializer(read_only=True)
class Meta:
model = Info
fields = '__all__'
read_only_fields = ('user', )
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")
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
},
}
def response_payload_handler(token, user=None, request=None):
account, member, countries, states, categories = None, None, None, None, None
try:
account = Account.objects.get(user=user)
except Account.DoesNotExist:
pass
try:
member = Member.objects.get(account=account)
except Member.DoesNotExist:
pass
countries = Country.objects.all()
categories = Category.objects.all()
partners = Business.objects.filter(
account=account).order_by('-last_modified_date')
cashiers = []
for role in AccountPartnerRole.objects.filter(account=account):
cashiers.append(Business.objects.get(id=role.business_id))
return {
'token': token,
'user': UserSerializer(user).data,
'account': AccountSerializer(account).data,
'member': MemberSerializer(member).data if member else member,
'partners': BusinessSerializer(partners, many=True).data,
'cashiers': BusinessSerializer(cashiers, many=True).data,
'countries': CountrySerializer(countries, many=True).data,
'categories': CategorySerializer(categories, many=True).data,
'stripe_key': settings.STRIPE_PUBLIC_KEY
}
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)
