def post(self, request):
serializer = UserSerializer(data=request.data) #en rest framework los datos que se envían están en data, y no en POST
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=HTTP_201_CREATED)
else:
return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
def create(self, req):
serializer = UserSerializer(data=req.data, context={'request': req})
if serializer.is_valid():
new_user = serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, format=None):
my_profile = request.user.get_profile()
# User should be able to edit first_name, last_name, email here
# TODO: Make sure this is safe as we are making two calls to serialize the request
user_serializer = UserSerializer(
request.user,
data=request.DATA,
partial=True
)
if not user_serializer.is_valid():
return errors.New400BadRequest(user_serializer.errors)
user_serializer.save()
serializer = ProfileSerializer(
my_profile,
data=request.DATA,
partial=True
)
print serializer.errors
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
return errors.New400BadRequest(serializer.errors)
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
new_user = serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, userid):
user = self.get_user(userid)
serializer = UserSerializer(user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
request_data = request.data
client_data = request_data["client"]
try:
client = Client.objects.get(user__email=client_data["user"]["email"])
user_serializer = UserSerializer(client.user, data=client_data["user"])
except Client.DoesNotExist:
client = None
user_serializer = UserSerializer(data=client_data["user"])
# Update information for user.
if user_serializer.is_valid():
user_serializer.save()
else:
return Response(user_serializer.errors)
del client_data["user"]
client_data["user_id"] = user_serializer.instance.id
# Update information for client.
if client:
serializer = ClientSerializer(client, data=client_data)
else:
serializer = ClientSerializer(data=client_data)
if serializer.is_valid():
serializer.save()
# Add this client to the provision table.
users_db_utils.add_to_client_provision(
serializer.instance.id)
return Response(serializer.data,
status=status.HTTP_201_CREATED)
return Response(serializer.errors)
def create(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
new_user = serializer.save()
send_mail(u"Bienvenido!", u"Bienvenido a Frikr!", "*****@*****.**", [new_user.email], fail_silently=True)
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk):
user = get_object_or_404(User, pk=pk)
self.check_object_permissions(request, user) # llama a has_object_permission
serializer = UserSerializer(user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=HTTP_202_ACCEPTED)
else:
return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
def update(self, request, pk):
user = get_object_or_404(User, pk=pk)
# Paso al serializados que instancia y con que la tiene que actualizar.
serializer = UserSerializer(instance=user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class UpdateUserTest(APITestCase):
def setUp(self):
self.user = User.objects.create(username="******", first_name="Jake")
self.data = UserSerializer(self.user).data
self.data.update({'first_name': 'Changed'})
def test_can_update_user(self):
response = self.client.put(reverse('user-detail', args=[self.user.id]), self.data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def put(self, request, pk):
user = get_object_or_404(User, pk=pk)
self.check_object_permissions(request, user)
serializer = UserSerializer(User, request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.data, status=status.HTTP_400_BAD_REQUEST)
def create(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
new_user = serializer.save()
# Devolvemos los datos después de crear el recurso, es como un acuse de recibo.
# no todas las apis devuelven los datos.
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def update(self, request, pk):
user = get_object_or_404(User, pk=pk)
self.check_object_permissions(request, user) # compruebo si el usuario autenticado puede hacer PUT en este user
serializer = UserSerializer(instance=user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def update(self, req, pk):
user = get_object_or_404(User, pk=pk)
self.check_object_permissions(req, user) # permisos a mano
serializer = UserSerializer(instance=user, data=req.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_404_NOT_FOUND)
def update(self, request, pk):
self.check_permissions(request)
user = get_object_or_404(User, pk=pk)
self.check_object_permissions(request, user)
serializer = UserSerializer(instance=user, data=request.data) #Serializa este usuario con data datos
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk):
user = get_object_or_404(User, pk=pk)
if request.user.is_superuser or request.user.username == user.username:
serializer = UserSerializer(instance=user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
else:
return Response(status=status.HTTP_401_UNAUTHORIZED)
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
new_user = serializer.save()
blog = Blog()
blog.title = request.data.get("blog")
blog.owner = new_user
blog.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def list_matches(self, request):
serialized = UserSerializer(data=request.data)
if serialized.is_valid():
User.objects.create_user(
serialized.init_data['email'],
serialized.init_data['date_of_birth'],
serialized.init_data['password']
)
return Response(serialized.data, status=status.HTTP_201_CREATED)
else:
return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
serializer = UserSerializer(data=request.data) # se inicializa el serializer con los datos que me llegan por http mediante POST
if serializer.is_valid():
new_user = serializer.save() # Guarda el objeto en BB.DD. y me lo devuelve
new_blog = Blog()
new_blog.name = 'El blog de {0} {1}'.format(request.data.get('first_name'), request.data.get('last_name'))
new_blog.author = new_user
new_blog.save()
# serializer almacena los datos en 'serializer.data'
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
# serializer almacena los errores en 'serializer.errors'
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk):
user = get_object_or_404(User, pk=pk) # devuelve el objeto o, si este no existe, un error 404
# compruebo si el usuario autenticado puede hacer PUT en este user
# Hay que hacerlo a mano porque estamos heredando de una GenericAPIView
# Al hacer la recuperación del objeto 'user' manualmente, la comprobacion tambien debe ser manual
self.check_object_permissions(request, user)
serializer = UserSerializer(instance=user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, request):
serializer = UserSerializer(data=request.data) #TODOS LOS MÉTODOS REST VIENEN POR EL PARAMETRO 'DATA' DE LA REQUEST
if serializer.is_valid():
new_user = serializer.save()
# TODO - crear el usuario y su blog en una sóla llamada
blog_for_newUser = Blog()
blog_for_newUser.owner = new_user
blog_for_newUser.name = new_user.first_name + ' ' + new_user.last_name + '\'s Personal Blog'
blog_for_newUser.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create_auth(request):
serialized = UserSerializer(data=request.data)
if request.data['secret_code'] == settings.SECRET_CODE:
if serialized.is_valid():
User.objects.create_user(
serialized.data['username'],
serialized.data['email'],
serialized.data['password']
)
return Response(serialized.data, status=status.HTTP_201_CREATED)
else:
return Response(serialized._errors , status=status.HTTP_400_BAD_REQUEST)
else:
return Response({'Incorrect inscription code' : [", please contact our team to get yours"]} , status=status.HTTP_400_BAD_REQUEST)
def test_user_creation(self):
data = {"username": "******", "email": "*****@*****.**",
"password": "******", "first_name": "tester",
"last_name": "testington"}
serializer = UserSerializer(data=data)
self.assertTrue(serializer.is_valid(), msg=serializer.errors)
user = serializer.create(serializer.validated_data)
self.assertEqual(data['username'], user.username)
self.assertEqual(data['email'], user.email)
self.assertEqual(data['first_name'], user.first_name)
self.assertEqual(data['last_name'], user.last_name)
def put(self, request, pk):
"""
Endpoint de modificación de usuario. Por convención, se utiliza la url de listado con una petición PUT para la modificación de un objeto de ese listado. En el serializer.save() comprueba automáticamente si tiene instancia del User; si la tiene, coge esa instancia y llama al update() del serializer; si no la tiene, llama al método create() del serializer, como en el caso del POST del UserListAPI
"""
user = get_object_or_404(User, pk=pk)
# compruebo manualmente si el usuario autenticado puede hacer PUT en este user
self.check_object_permissions(request, user)
# Actualiza los datos de la instancia recuperada con los datos que me pasan por la API
serializer = UserSerializer(instance=user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def invite(self, request, pk=None):
user_invite_serializer = UserSerializer(
data=request.data)
# Process user and check if it was already in our system
user, created = user_invite_serializer.process_new_user(
request,
force_invite=True)
if created:
rstatus = status.HTTP_201_CREATED
elif user:
rstatus = status.HTTP_200_OK
else:
rstatus = status.HTTP_400_BAD_REQUEST
return Response(UserSerializer(instance=user).data, status=rstatus)
def create(self, request):
"""
Endpoint de creación de usuario. Guardamos automáticamente también el blog con su nombre de usuario
:param request:
:return:
"""
# Creamos serializador a partir de los datos de la petición. En rest framwork, para evitar request.POST,
# request.GET, etc., se utiliza simplemente data
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
new_user = serializer.save()
# Guardamos blog para el nuevo usuario
user_blog = Blog()
user_blog.owner = new_user
user_blog.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
"""
Endpoint de creación de usuario. Por convención, se utiliza la url de listado con una petición POST para la creación de un objeto de ese listado. En el serializer.save() comprueba automáticamente si tiene instasncia del User; si no la tiene, llama al método create del serializer.
"""
# Creamos serializador a partir de los datos de la petición. En rest framwork, para evitar request.POST,
# request.GET, etc., se utiliza simplemente data
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
# Guardamos el usuario a través del serializer y devolvemos los datos del objeto creado
new_user = serializer.save()
# Guardamos blog para el nuevo usuario
user_blog = Blog()
user_blog.owner = new_user
user_blog.save()
# Respondemos código 201 (creado) y los datos del objeto creado
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
# Devolvemos diccionario con errores y el código 400 (petición errónea) si algo fue mal
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def user_detail(request, pk):
"""
Retrieve, update or delete a user instance.
"""
try:
user = User.objects.get(pk=pk)
except User.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = UserSerializer(user)
return Response(serializer.data)
elif request.method == 'PUT':
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)
elif request.method == 'DELETE':
user.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def put(self, request, username, format=None):
data = UserAccountSerializer(data=request.data).data
user = User.objects.get(username=username)
user_serializer = UserSerializer(user,
data=data['user'])
if user_serializer.is_valid():
user_serializer.save()
account = self.get_object(username)
account.school = data.get('school')
account.class_in_school = data.get('class_in_school')
# client should put facebook_id to enable this
# account.facebook_id = data.get('facebook_id')
account.save()
update_session_auth_hash(request, user)
return Response(UserAccountSerializer(account).data)
return Response(user_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def put(self, request, username, format=None):
serializer = UserAccountSerializer(data=request.data)
if serializer.is_valid() is False:
return Response(
{"message": "Cannnot update profile with provided information"}, status=status.HTTP_400_BAD_REQUEST
)
data = serializer.validated_data
password = data["user"].get("password")
confirm_password = data["user"].get("confirm_password")
if password != confirm_password:
return Response(
{"message": "Password and confirm password don't match"}, status=status.HTTP_400_BAD_REQUEST
)
user = User.objects.get(username=username)
user_serializer = UserSerializer(user, data=data["user"])
if user_serializer.is_valid():
user_serializer.save()
account = self.get_object(username)
account.school = data.get("school")
account.class_in_school = data.get("class_in_school")
# client should put facebook_id to enable this
# account.facebook_id = data.get('facebook_id')
account.save()
update_session_auth_hash(request, user)
return Response(UserAccountSerializer(account).data)
return Response(user_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class ReviewSerializer(serializers.ModelSerializer):
user = UserSerializer(required=False)
region = RegionSerializer(many=True,
source="region_reivews",
required=False)
subject = SubjectSerializer(many=True,
source='subject_reivews',
required=False)
activity = ActivitySerializer(many=True, required=False)
comments = CommentSerializer(many=True, required=False)
images = ImageSerializer(many=True, required=False)
class Meta:
model = Review
fields = [
'id', 'title', 'body', 'created_at', 'updated_at', 'user',
'region', 'subject', 'activity', 'comments', 'like_count', 'images'
]
def create(self, validated_data):
try:
subject_data = validated_data.pop('subject')
activity_data = validated_data.pop('activity')
regions_data = validated_data.pop('region')
review = Review.objects.create(**validated_data)
for data in regions_data:
region, created = Region.objects.get(city=data['city'],
town=data['town'])
review.region.add(region)
for data in activity_data:
activity = Activity.objects.get(id=data['id'])
review.activity.add(activity)
for data in subject_data:
subject, created = Subject.objects.get(id=data['id'])
review.subject.add(subject)
except:
review.delete()
finally:
return review
def get_delete_update_user(request, pk):
user = get_object_or_404(User, pk=pk)
# get details of a single user
if request.method == 'GET':
serializer = UserSerializer(user)
return Response(serializer.data)
# delete a single user
elif request.method == 'DELETE':
user.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
# update details of a single user
elif request.method == 'PUT':
serializer = UserSerializer(user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_204_NO_CONTENT)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class OrderEventSerializer(serializers.ModelSerializer):
owner = UserSerializer(read_only=True)
rate_cards = PrimaryKeyRelatedField(allow_empty=True,
many=True,
queryset=RateCard.objects.all(),
required=False)
participants = PrimaryKeyRelatedField(allow_empty=True,
many=True,
queryset=User.objects.all(),
required=False)
status = SerializerMethodField()
class Meta:
model = OrderEvent
fields = ('id', 'name', 'owner', 'rate_cards', 'participants',
'status')
depth = 1
def get_status(self, status) -> str:
return status.get_status_display()
class LeaseAreaAttachmentSerializer(FileSerializerMixin,
EnumSupportSerializerMixin,
FieldPermissionsSerializerMixin,
serializers.ModelSerializer):
id = serializers.IntegerField(required=False)
uploader = UserSerializer()
file = serializers.SerializerMethodField('get_file_url')
filename = serializers.SerializerMethodField('get_file_filename')
class Meta:
model = LeaseAreaAttachment
fields = ('id', 'type', 'file', 'filename', 'uploader', 'uploaded_at',
'lease_area')
download_url_name = 'leaseareaattachment-download'
def override_permission_check_field_name(self, field_name):
if field_name == 'filename':
return 'file'
return field_name
def isLogin(request):
if request.user.is_authenticated():
likes = list()
for like in Like.objects.filter(user=request.user):
likes.append(like.blog.id)
return http.JsonResponse({
'user':
UserSerializer(request.user, context={
'request': request
}).data,
'user_extend':
UserExtendSerializer(request.user.userextend,
context={
'request': request
}).data,
'like':
likes,
})
else:
return http.HttpResponse(status=status.HTTP_401_UNAUTHORIZED)
def post(self, *args, **kwargs):
serializer = UserAuthTokenSerializer(data=self.request.data)
if serializer.is_valid():
if self.request.META.get('HTTP_AUTHORIZATION').split(' ')[1] != serializer.validated_data.get('token'):
return Response({
'error': 'Invalid authorization token!',
})
try:
token = Token.objects.get(key=serializer.validated_data.get('token'))
user = User.objects.get(phone=token.user)
except Token.DoesNotExist:
return Response({
'error': 'User with this token does not exist!',
}, status=status.HTTP_404_NOT_FOUND)
return Response({
'user': UserSerializer(user).data,
}, status=status.HTTP_200_OK)
return Response({
'error': 'Token is required!',
}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, pk=None):
if pk:
error = {"errors": "Must Not Include id while making PUT request"}
return Response(error, status=status.HTTP_400_BAD_REQUEST)
print("Inside Post")
try:
user = User.objects.all().get(id=request.data["id"])
except ObjectDoesNotExist:
user_dict = request.data.dict()
print(type(user_dict))
user_dict["password"] = bcrypt.hashpw(
user_dict["password"].encode("utf-8"), bcrypt.gensalt((15)))
print(user_dict)
new_user = User(**user_dict)
new_user.save()
print(new_user.password)
serializer = UserSerializer(new_user)
return Response(serializer.data)
error = {"errors": "User Id already exists "}
return Response(error, status=status.HTTP_400_BAD_REQUEST)
class PostListSerializer(ModelSerializer):
url = HyperlinkedIdentityField(
view_name='blog_api:detail',
lookup_field='slug'
)
user = UserSerializer(read_only=True)
class Meta:
model = Post
fields = [
'user',
'id',
'url',
'slug',
'title',
'description',
'image',
'category',
'timestamp',
]
class RoomSerializer(serializers.ModelSerializer):
user = UserSerializer()
class Meta:
model = Room
exclude = ("modified", )
read_only_fields = ("user", "id", "created", "updated")
def validate(self, data):
if self.instance:
check_in = data.get("check_in", self.instance.check_in)
check_out = data.get("check_out", self.instance.check_out)
else:
check_in = data.get("check_in")
check_out = data.get("check_out")
if check_in == check_out:
raise serializers.ValidationError(
"Not enough time between changes")
return data
def create(self, request, *args, **kwargs):
client = User.objects.get(email=request.data.get('client'))
service_provider = Business.objects.get(
pk=request.data.get('service_provider'))
service_type = Service.objects.get(pk=request.data.get('service_type'))
appointment_data = {
'client': UserSerializer(client).data,
'service_provider': BusinessSerializer(service_provider).data,
'time': request.data.get('time'),
'date': request.data.get('date'),
'service_type': ServiceSerializer(service_type).data,
'comment': request.data.get('comment'),
}
serializer = AppointmentSerializer(data=appointment_data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data,
status=status.HTTP_201_CREATED,
headers=headers)
def to_representation(self, instance):
data = super().to_representation(instance)
request = self.context.get("request")
data['user'] = UserSerializer(User.objects.get(pk=data['user']),
context={
'request': request
}).data
if (data['tweet']):
data['tweet'] = TweetSerializer(
Tweet.objects.get(pk=data['tweet']),
context={
'request': request
}).data
if (data['retweet']):
data['retweet'] = RetweetSerializer(
Retweet.objects.get(pk=data['retweet']),
context={
'request': request
}).data
return data
def register_user(request):
print("Creating a new user")
print(request.data)
data = {'username':request.data["userName"], 'password':request.data["password"], 'email':request.data["email"]}
serializer = UserSerializer(data=data)
if serializer.is_valid():
print("Valid")
user = serializer.save()
# have to create profile data and link it to user
data = {'user':user, 'first_name':None, 'last_name':None, 'email':request.data["email"], 'birth_date':None, 'country':None}
serializer = ProfileSerializer(data=data)
if serializer.is_valid():
print("Profile data is valid")
serializer.save()
else:
print("Profile data is not valid")
print(serializer.errors)
#profile = Profile(user=user, first_name=None, last_name=None, email=request.data["email"], birth_date=None, country=None)
return Response({'user': serializer.data})
print("data not valid")
print(serializer.errors)
class ObtainTokenSerializer(serializers.Serializer):
email = serializers.EmailField(required=True, write_only=True)
password = serializers.CharField(max_length=256,
required=True,
write_only=True)
token = serializers.CharField(max_length=256, read_only=True)
user = UserSerializer(read_only=True)
def validate(self, attrs):
credentials = {
"email": attrs.get("email", None),
"password": attrs.get("password", None),
}
user = authenticate(**credentials)
payload = jwt_payload_handler(user)
token = jwt_encode_handler(payload)
return jwt_response_payload_handler(user=UserSerializer(user).data,
token=token)
def post(self, request):
login_serializer = UserLoginSerializer(
data=request.data.get('login_data'))
login_serializer.is_valid(raise_exception=True)
user = login_serializer.validated_data.get('user')
if user:
login(request, user)
user_serializer = UserSerializer(
user,
context={
'data': {
'fields':
['first_name', 'last_name', 'email', 'token']
}
})
return Response({'success': True, 'user': user_serializer.data})
return Response({
'success': False,
'error': "Unable to login with given credentials"
})
def update_collaborators(request, repo_id):
repo = get_object_or_404(Repository, pk=repo_id)
signed_in_user = request.user.id
if repo.user.id != signed_in_user:
raise GeneralException("Not authorized")
user_id_list = request.data
if len(user_id_list) > 0:
repo.collaborators.clear()
repo.collaborators.add(*user_id_list)
else:
repo.assignees.clear()
repo.save()
repo.refresh_from_db()
serializer = UserSerializer(repo.collaborators, many=True)
return Response(serializer.data)
def to_representation(self, instance):
from events.serializers import EventItemSerializer, TransportationInfoSerializer
response = super().to_representation(instance)
data = {
'uuid':
instance.uuid,
'event_item':
EventItemSerializer(instance.event_item).data,
'item_master':
ItemMasterSerializer(instance.item_master).data,
'user':
UserSerializer(instance.user).data,
'event_attendee':
EventAttendeeSerializer(instance.event_attendee).data,
'transportation_info':
TransportationInfoSerializer(instance.transportation_info).data
}
response.update(data)
return response
def retrieve(self, request, pk):
"""
Endpoint detalle de usuario
:param request:
:param pk:
:return:
"""
# Si existe el usuario cuya PK=pk existe lo devuelve, y si no se captura una excepción y se manda
# un código 404
# La función get_object_or_404 recibe el modelo como primer parámetro y a continuación los campos
# de búsqueda
user = get_object_or_404(User, pk=pk)
# compruebo manualmente si el usuario autenticado puede hacer GET en este user
self.check_object_permissions(request, user)
# Convertimos objeto user en diccionario, que es guardado en 'data'
serializer = UserSerializer(user)
return Response(serializer.data)
def post(self, request, format=None):
data = request.data
username = data.get('username', None)
password = data.get('password', None)
account = authenticate(username=username, password=password)
if account is not None:
login(request, account)
serialized = UserSerializer(account)
return Response(serialized.data)
else:
return Response(
{
'status': 'Unathorized',
'message': 'Lazy error message.'
},
status=status.HTTP_401_UNAUTHORIZED)
class CommentSerializer(serializers.ModelSerializer):
author = UserSerializer(required=False)
class Meta:
model = Comment
fields = [
'id', 'content_type_id', 'object_id', 'content', 'parent',
'created_at', 'author'
]
def validate(self, data):
parent = data.get('parent') # type: Optional[Comment]
if parent:
if data['content_type_id'] != parent.content_type_id or data[
'object_id'] != parent.object_id:
raise serializers.ValidationError(
_("`content_type_id` and `object_id` should equal to parent's ones"
))
return data
class LogEntrySerializer(serializers.ModelSerializer):
class Meta:
model = LogEntry
fields = (
'actor',
'object_repr',
'action',
'timestamp',
'changes',
)
actor = UserSerializer()
action = serializers.SerializerMethodField()
changes = serializers.SerializerMethodField()
def get_action(self, obj):
return obj.get_action_display()
def get_changes(self, obj):
return obj.changes_dict
def get(self, request, *args, **kwargs):
if IsLoggedIn(request):
query_name = IsLoggedIn(request).username
print(query_name)
try:
logger = Ngo.objects.get(username=query_name)
except:
logger = user.objects.get(username=query_name)
if logger.IsNgo:
serializer = NgoSerializer(logger)
return Response(serializer.data,
status=status.HTTP_206_PARTIAL_CONTENT)
else:
serializer = UserSerializer(logger)
return Response(serializer.data,
status=status.HTTP_206_PARTIAL_CONTENT)
else:
return Response({'message': "unauthenticated user"},
status=status.HTTP_401_UNAUTHORIZED)
class CommentCreateUpdateSerializer(serializers.Serializer):
comment = CommentSerializer()
auth_user = UserSerializer()
def validate(self, data):
for field in ('comment', 'auth_user'):
if field not in data:
raise serializers.ValidationError(
_(f'`{field}` field is required'))
return data
def create(self, validated_data):
author_data = validated_data.pop('auth_user')
username = author_data.pop('username')
user, _ = User.objects.get_or_create(username=username,
defaults=author_data)
comment = Comment.objects.create(author=user,
**validated_data['comment'])
comment_created.send(sender=comment.__class__,
comment=comment,
user=user)
return {
'comment': comment,
'auth_user': user,
}
def update(self, instance, validated_data):
instance.content = validated_data['comment']['content']
instance.save(update_fields=['content'])
author_data = validated_data.pop('auth_user')
username = author_data.pop('username')
user, _ = User.objects.get_or_create(username=username,
defaults=author_data)
comment_updated.send(sender=instance.__class__,
comment=instance,
user=user)
return {
'comment': instance,
'auth_user': user,
}
def get_participants(self, request):
username = request.data['email']
subject_slug = request.data['subject_slug']
user = User.objects.get(email = username)
participants = None
response = ""
if not subject_slug == "":
subject = Subject.objects.get(slug = subject_slug)
participants = User.objects.filter(Q(is_staff = True) | Q(subject_student__slug = subject_slug) | Q(professors__slug = subject_slug) | Q(coordinators__subject_category__slug = subject_slug)).exclude(email = username).distinct()
serializer = UserSerializer(participants, many = True, context = {"request_user": username})
json_r = json.dumps(serializer.data)
json_r = json.loads(json_r)
info = {}
info["data"] = {}
info["data"]["participants"] = json_r
info["message"] = ""
info["type"] = ""
info["title"] = ""
info["success"] = True
info["number"] = 1
info['extra'] = 0
response = json.dumps(info)
self.log_context['subject_id'] = subject.id
self.log_context['subject_slug'] = subject_slug
self.log_context['subject_name'] = subject.name
super(ParticipantsViewset, self).createLog(user, self.log_component, self.log_action, self.log_resource, self.log_context)
return HttpResponse(response)
class ObjectiveSerializer(serializers.ModelSerializer):
""" The default serializer for a learning Objective.
"""
contributor = UserSerializer(required=False)
num_questions = serializers.SerializerMethodField()
class Meta:
model = Objective
fields = (
"id",
"title",
"specialty",
"topic",
"stage",
"notes",
"contributor",
"created_at",
"modified_at",
"num_questions",
)
read_only_fields = (
"id",
"contributor",
"created_at",
"modified_at",
"num_questions",
)
def create(self, validated_data):
""" Create a new objective, retrieving the user from the request.
"""
contributor = self.context["request"].user
objective = Objective.objects.create(contributor=contributor,
**validated_data)
return objective
def get_num_questions(self, object):
""" Get the number of questions allocated under this objective.
"""
return object.objective_question.count()
class BlogSnippetSerializer(serializers.ModelSerializer):
publisher_profile = UserSerializer(read_only=True)
upvote = serializers.SerializerMethodField()
downvote = serializers.SerializerMethodField()
voted = serializers.SerializerMethodField()
word_count = serializers.SerializerMethodField()
def get_word_count(self, obj):
line_soup = bs(obj.content.strip(), 'html.parser')
# naive way to get words count
words_count = len(line_soup.text.split())
return words_count
def get_created_at(self, obj):
if obj.date is None:
return None
return obj.date.astimezone(pytz.timezone('US/Pacific'))
def get_upvote(self, obj):
return models.Vote.objects.filter(blog=obj, vote_type=True).count()
def get_downvote(self, obj):
return models.Vote.objects.filter(blog=obj, vote_type=False).count()
def get_voted(self, obj):
voted = 0
user_vote = models.Vote.objects.filter(user=self.context.get('user'),
blog=obj)
if len(user_vote) > 0:
if user_vote[0].vote_type:
voted = 1
else:
voted = -1
return voted
class Meta:
fields = ('id', 'publisher_profile', 'title', 'snippet',
'header_image', 'created_at', 'updated_at', 'view_count',
'upvote', 'downvote', 'word_count', 'voted', 'is_public',
'is_publish', 'is_approved')
model = models.Blog
class CommentSerializer(serializers.ModelSerializer):
poster = UserSerializer()
community = CommunitySerializer()
originalPost = PostSerializer()
class Meta:
model = Comment
fields = [
'post', 'community', 'poster', 'originalPost', 'originalPostId'
]
def to_internal_value(self, data):
internal_value = super(CommentSerializer, self).to_internal_value(data)
ogpostid = data["originalPost"]["id"]
internal_value.update({"ogpostid": ogpostid})
return internal_value
def create(self, validated_data):
print(validated_data)
userData = validated_data.pop('poster')
user = User.objects.get_or_create(username=userData['username'],
email=userData['email'],
first_name=userData['first_name'],
last_name=userData['last_name'],
password=userData['password'])[0]
validated_data['poster'] = user
communityData = validated_data.pop('community')
community = Community.objects.get_or_create(
name=communityData['name'])[0]
validated_data['community'] = community
originalPostData = validated_data.pop('originalPost')
originalPost, created = Post.objects.get_or_create(
id=validated_data['ogpostid'])
validated_data['originalPost'] = originalPost
validated_data['originalPostId'] = validated_data["ogpostid"]
del validated_data["ogpostid"]
comment = Comment.objects.create(**validated_data)
return comment
class ProductReviewSerializer(serializers.ModelSerializer):
product = ProductSerializer(read_only=True, )
user = UserSerializer(read_only=True, )
class Meta:
model = ProductReview
fields = ('id', 'user', 'product', 'text', 'rating', 'created_at',
'updated_at')
def validate(self, data):
if 'product_id' not in self.context[
'request'].data: # Проверяем product_id
raise serializers.ValidationError(
'product_id: This field is required.')
product_id = self.context['request'].data['product_id']
if not isinstance(product_id, int):
raise serializers.ValidationError('product_id should be integer')
if not Product.objects.filter(id=product_id):
raise serializers.ValidationError('Wrong product_id')
user_id = self.context[
'request'].user.id # Проверяем что отзыв на один продукт только один
if ProductReview.objects.filter(user=user_id).filter(
product=product_id):
if self.context['request'].stream.method == 'POST':
raise serializers.ValidationError(
'Maximum one review per user per product')
elif self.context['request'].stream.method in ['PUT', 'PATCH']:
if product_id != self.instance.product_id:
raise serializers.ValidationError(
"You already reviewed this product")
return data
def create(self, validated_data):
""" Простановка значения поля user по-умолчанию и product по product.id"""
validated_data['user'] = self.context['request'].user
validated_data['product'] = Product.objects.get(
id=self.context['request'].data['product_id'])
return super().create(validated_data)
class RoomSerializer(serializers.ModelSerializer):
user = UserSerializer(read_only=True)
photos = PhotoSerializer(read_only=True, many=True)
is_fav = serializers.SerializerMethodField()
class Meta:
model = Room
exclude = ("modified", )
read_only_fields = (
"user",
"created",
"updated",
"id",
)
def validate(self, data):
if self.instance:
check_in = data.get("check_in", self.instance.check_in)
check_out = data.get("check_out", self.instance.check_out)
else:
check_in = data.get("check_in")
check_out = data.get("check_out")
if check_in == check_out:
raise serializers.ValidationError(
"Check-in and Check-out can't be set the same time")
return data
def get_is_fav(self, obj):
request = self.context.get("request")
if request:
user = request.user
if user.is_authenticated:
return obj in request.user.favs.all()
return False
def create(self, validated_data):
request = self.context.get("request")
room = Room.objects.create(**validated_data, user=request.user)
return room
def get_leaderboard_from_data(self, data, game_name):
users = []
for raw_user_data in data:
try:
user = User.objects.get(phone=raw_user_data['phone'])
except User.DoesNotExist:
continue
score = getattr(user.get_latest_scores(), game_name, None)
if score is None:
continue
user_data = UserSerializer(user).data
user_data['score'] = score
users.append(user_data)
if game_name == 'reaction_time':
result = sorted(users, key=lambda k: k['score'])
else:
result = sorted(users, key=lambda k: -k['score'])
return result
class DebitorListSerializer(ModelSerializer):
balance = serializers.SerializerMethodField()
user = UserSerializer()
class Meta:
model = EventAttendee
exclude = ('updated_at', 'deleted_at',)
def to_representation(self, instance):
response = super().to_representation(instance)
data = {
'user': UserSerializerWithNoDummyEmailAndPhone(instance.user,
context={'event': self.context['event']}).data,
}
response.update(data)
return response
def get_balance(self, obj):
from orders.utils import get_latest_order_of_main_user, get_net_positive_balance_credit_from_latest_order
return get_net_positive_balance_credit_from_latest_order(get_latest_order_of_main_user(obj.user, obj.event))
