class InspectionAttachmentSerializer(FileSerializerMixin, 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 = InspectionAttachment
fields = ('id', 'file', 'filename', 'uploader', 'uploaded_at', 'inspection')
download_url_name = 'inspectionattachment-download'
def override_permission_check_field_name(self, field_name):
if field_name == 'filename':
return 'file'
return field_name
class CollectionLetterSerializer(FileSerializerMixin, 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 = CollectionLetter
fields = ('id', 'lease', 'file', 'filename', 'uploader', 'uploaded_at')
download_url_name = 'collectionletter-download'
def override_permission_check_field_name(self, field_name):
if field_name == 'filename':
return 'file'
return field_name
def _get_users(project, list_view=False):
users = [project.user]
if not list_view:
attributes = Attribute.objects.filter(
value_type=Attribute.TYPE_USER).values_list("identifier",
flat=True)
user_attribute_ids = []
for attribute in attributes:
user_id = project.attribute_data.get(attribute, None)
if user_id:
user_attribute_ids.append(user_id)
users += list(User.objects.filter(uuid__in=user_attribute_ids))
return UserSerializer(users, many=True).data
def update(self, request, pk):
"""
Updates a User with the given data
:param request: HttpRequest
:param pk: User primary key
:return: Response
"""
user = get_object_or_404(User, pk=pk)
self.check_object_permissions(request, user)
serializer = UserSerializer(user, data=request.data)
if serializer.is_valid():
user = serializer.save()
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
class MessageWebSocketSerializer(serializers.ModelSerializer):
permissions = serializers.SerializerMethodField()
author = UserSerializer(many=False, read_only=True)
class Meta:
model = Message
fields = ["content", "author", "created_on", "permissions"]
read_only_fields = ["created_on", "id"]
def get_permissions(self, obj):
return {
"write":
obj.has_object_write_permission_socket(self.context["user"]),
"read":
obj.has_object_read_permission_socket(self.context["user"]),
}
def post(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
try:
serializer.is_valid(raise_exception=True)
except TokenError as e:
raise InvalidToken(e.args[0])
user = User.objects.get(email=request.data['email'])
req = request
req.user = user
user_serializer = UserSerializer(instance=user,
context={'request': req})
res = {'user': user_serializer.data, **serializer.validated_data}
return Response(res, status=status.HTTP_200_OK)
def post(self, request, format=None):
username = request.data.get('username', '')
password = request.data.get('password', '')
user = auth.authenticate(username=username, password=password)
if user is not None:
if user.is_active:
auth.login(request, user)
return http.JsonResponse(
UserSerializer(user, context={
'request': request
}).data)
else:
return http.HttpResponseBadRequest("User is deactivate")
else:
return http.HttpResponseBadRequest("Username or password is wrong")
class ChatSerializer(serializers.ModelSerializer):
user = UserSerializer()
subject = SubjectSerializer()
favorite = serializers.SerializerMethodField()
def get_favorite(self, message):
user = self.context.get("request_user", None)
if not user is None:
return ChatFavorites.objects.filter(Q(user = user) & Q(message = message)).exists()
return False
class Meta:
model = TalkMessages
fields = ('text', 'user', 'subject', 'image_url', 'create_date', 'favorite', 'id')
def user_register(request):
if request.user.is_authenticated or request.method != 'POST':
return HttpResponse(status=400)
data = json.loads(request.body)
user = authenticate(**data)
if not user:
user = User.objects.create_user(**data)
user.save()
login(request, user)
context = UserSerializer(user).data
return JsonResponse(context, status=201)
return HttpResponse(status=400)
def login(cls, email, password):
try:
user = User.objects.get(email=email)
except User.DoesNotExist:
return Response(data={'message': '404001 用户未注册'},
status=status.HTTP_404_NOT_FOUND)
if user.check_password(password):
token = get_jwt_token(user)
return Response({
'jwt': token,
'user': UserSerializer(user).data
},
status=status.HTTP_200_OK)
else:
return Response(data={'message': '401001 密码错误'},
status=status.HTTP_401_UNAUTHORIZED)
def post(self, request, format=None):
token = request.data.get('userToken')
site_id = request.data.get('siteId')
user_id = request.data.get('userId')
site = Site.objects.get(id=site_id)
user = User.objects.get(id=user_id)
site.users.remove(user)
users = User.objects.all()
user_serializer = UserSerializer(users, many=True)
user = Token.objects.get(key=token).user
sites = user.sites.all()
site_serializer = SiteUserSerializer(sites, many=True)
return Response({
'users': user_serializer.data,
'sites': site_serializer.data
})
class CompanyKeyFiguresLogoSerializer(serializers.ModelSerializer):
"""
CompanySerializer, which also serializes key figures of the company and his logo.
"""
user = UserSerializer()
key_figures = KeyFiguresSerializer(source="keyfigures")
logo = serializers.ImageField(source="user.profile.company_logo",
allow_null=True,
default=None)
class Meta:
model = Company
fields = ("isin", "name", "country", "cash", "shares", "user",
"key_figures", "id", "logo")
read_only_fields = fields
def put(self, request, *args, **kwargs):
"""
更新用户信息
"""
form = UpdateUserInfoForm(request.data, request.FILES)
if not form.is_valid():
return Response({'Detail': form.errors}, status=status.HTTP_400_BAD_REQUEST)
cld = form.cleaned_data
serializer = UserSerializer(request.user)
try:
serializer.update_userinfo(request, request.user, cld)
except Exception as e:
return Response({'Detail': e.args}, status=status.HTTP_400_BAD_REQUEST)
return Response(serializer.data, status=status.HTTP_206_PARTIAL_CONTENT)
def create_user(request):
if request.method == "POST":
user_serializer = UserSerializer(data=request.data)
if user_serializer.is_valid():
User.objects.create_user(
username=user_serializer.validated_data["username"],
password=user_serializer.validated_data["password"])
return Response(JSONResponse().addData(
"User", user_serializer.data).addData("status",
"User created!").send(),
status=status.HTTP_201_CREATED)
else:
return Response(JSONResponse().addError(
0, "User could not be created").addError(
1, user_serializer.errors).send(),
status=status.HTTP_400_BAD_REQUEST)
def friends_list(self, request):
groups = Group.objects.filter(
Q(owner=request.user) | Q(members=request.user)).distinct()
serializer = FriendsListSerializer(groups, many=True)
friends = []
for group in serializer.data:
friends = [
*friends, *list(
filter(lambda member: member.id != request.user.id,
group.get('members')))
]
serializer = UserSerializer(set(friends), many=True)
paginator = PageNumberPagination()
paginator.page_size = 50
data = paginator.paginate_queryset(serializer.data, request)
return paginator.get_paginated_response(data=data)
def put(self, request, pk):
"""
Updates a user
:param request: HttpRequest object
:param pk: user pk
:return: HttpResponse object
"""
user = get_object_or_404(User, pk=pk)
self.check_object_permissions(request, user)
serializer = UserSerializer(user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
class InventorySupplyHeaderSerializer(serializers.ModelSerializer):
"""
This header serializer is used in case of listing contents of particular InventoryReport (not InventorySupply)
Instead of serializing all details of a supply (supplies.models.Supply), only ID and name is serialized
The rest of details can be accessed by '/api/inventories/supplies/<int:pk>' with ID provided by this serializer
This will future-proof that adding more details to supply (e.g. image) won't attach unnecessary data to InventoryReport details view
"""
supply = SupplyHeaderSerializer(source='inventory_supply',
many=False,
read_only=True)
checked_by = UserSerializer()
class Meta:
model = InventorySupply
fields = ('supply', 'is_checked', 'checked_by')
def post(self, request, *args, **kwargs):
data = request.data
token = data.get('token', )
user = get_object_or_404(User, token=token)
if user is not None:
if user.is_active:
login(request, user)
serializer = UserSerializer(user)
return Response(data=serializer.data,
status=status.HTTP_200_OK)
else:
return Response(status=status.HTTP_404_NOT_FOUND)
else:
return Response(status=status.HTTP_404_NOT_FOUND)
def post(self, request, format=None):
response = Response()
#hashs password for proper safety
request.data["password"] = make_password(request.data["password"])
new_user = UserSerializer(data=request.data)
if new_user.is_valid():
user = new_user.save()
response.status_code = 201
token = Token.objects.create(user=user)
response['token'] = token.key
else:
response.status_code = 400
response['error'] = new_user.errors
return response
def setUp(self):
self.user_attributes = {
"email": "*****@*****.**",
"password": "******",
"first_name": "Test",
"last_name": "Me",
"major": "Testing Studies",
"minor": "Unit Testing",
"year": 2,
"self_bio": "I'm a unit test that should pass",
}
self.serializer = UserSerializer(data=self.user_attributes)
if self.serializer.is_valid():
user = self.serializer.save()
self.user = User.objects.get(email=self.user_attributes['email'])
def update(self, request, pk):
# Debemos comprobar el sl usuario que se desea actualizar existe
user = get_object_or_404(User, pk=pk)
self.check_object_permissions(request, user)
# Serializame este usuario(instance=user) con estos datos(data=request.data)
serializer = UserSerializer(instance=user, data=request.data)
# Validamos
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 patch(self, request, pk):
"""PATCH method for editing user's name and password"""
instance = User.objects.get(pk=pk)
serializer = UserUpdateSerializer(instance,
data=request.data,
partial=True)
if not serializer.is_valid():
return Response(data=serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
try:
new_user = serializer.save()
except:
return Response(data={'error': sys.exc_info()[0]},
status=status.HTTP_400_BAD_REQUEST)
serializer = UserSerializer(new_user)
return Response(data=serializer.data, status=status.HTTP_202_ACCEPTED)
def test_login_token(self):
user = DummyUser().create()
user.is_active = True
user.save()
response = self.client.post(reverse('user:login'), {
'email': DummyUser().EMAIL,
'password': DummyUser().PASSWORD,
})
expected_data = {
'token': user.token,
'user': UserSerializer(user).data,
}
expected_data_json = JSONRenderer().render(expected_data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.content, expected_data_json)
def update(self, request, pk):
"""
Actualiza el usuario con pk <pk> si existe.
:param request: objeto de tipo HttpRequest
:param pk: pk del usuario que queremos actualizar
:return: 202 si OK o 400 con errores
"""
user = get_object_or_404(User, pk=pk)
self.check_object_permissions(request, user)
serializer = UserSerializer(user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
class TreeCommentSerializer(serializers.ModelSerializer):
descendants = CommentSerializer(many=True, read_only=True)
user = UserSerializer(read_only=True)
comment_html = serializers.CharField()
class Meta:
model = BlogComment
fields = [
"id",
"comment_html",
"submit_date",
"user",
"parent",
"descendants",
]
extra_kwargs = {"submit_date": {"format": "%Y-%m-%d %H:%M:%S"}}
class ConsultaEventoSerializer(serializers.ModelSerializer):
ubicacion = UbicacionSerializer()
rubro = RubroEventoSerializer(read_only=True)
rubro_id = serializers.PrimaryKeyRelatedField(
queryset=RubroEvento.objects.all(), source='rubro', write_only=True)
contacto = ContactoSerializer(many=True)
necesidades = NecesidadSerializer(many=True)
voluntarios = VoluntarioSerializer(many=True)
organizacion = UserSerializer()
class Meta:
model = Evento
fields = ('id', 'nombre', 'descripcion', 'fecha_hora_inicio',
'fecha_hora_fin', 'rubro', 'rubro_id', 'ubicacion',
'contacto', 'organizacion_id', 'necesidades', 'organizacion',
'voluntarios')
class CommunitySerializer(serializers.ModelSerializer):
users = UserSerializer(many=True, required=False)
class Meta:
model = Community
fields = ['name', 'users']
extra_kwargs = {'name': {'validators': []}}
def create(self, validated_data):
usersData = validated_data.pop('users')
community = Community.objects.create(**validated_data)
for user in usersData:
user, created = User.objects.get_or_create(
username=user['username'],
email=user['email'],
first_name=user['first_name'],
last_name=user['last_name'],
password=user['password'])
community.users.add(user)
return community
def update(self, community, validated_data):
usersData = validated_data.pop('users')
community.name = validated_data['name']
users_list = []
for user in usersData:
user, created = User.objects.get_or_create(
username=user['username'],
email=user['email'],
first_name=user['first_name'],
last_name=user['last_name'],
password=user['password'])
users_list.append(user)
community.users.set(users_list)
community.save()
return community
def validate(self, data):
value = data['name']
if (value == '') or (len(value) > 30) or (" "
in value) or value.isspace():
raise serializers.ValidationError("Community name invalid")
return data
class ProjectShortSerializer(serializers.ModelSerializer):
creator = UserSerializer(read_only=True)
status_name = serializers.SerializerMethodField
class Meta:
model = models.Project
fields = ('id', 'name', 'status', 'creator')
def validate_status(self, value):
if value > 3 or value < 1:
raise serializers.ValidationError('Project status must be between 1 and 3')
return value
def validate_id(self, value):
if value > 0:
raise serializers.ValidationError('Project status must be geater than 0')
return value
def signup(self, request, **kwargs):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
password = PasswordSerializer(data=request.data)
if password.is_valid():
user = serializer.save()
password = password.save()
user.password = password
user.save()
payload = api_settings.JWT_PAYLOAD_HANDLER(user)
response_data = {
"user": self._get_shallow_user_info(serializer),
"token": api_settings.JWT_ENCODE_HANDLER(payload)
}
return Response(response_data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, *args, **kwargs):
user = request.user
new_data = request.data.get('new_data', {})
password_changed = {}
if 'password' in new_data:
user.set_password(new_data.pop('password'))
password_changed = {'password': '******'}
serializer = UserSerializer(user, data=new_data, partial=True)
if serializer.is_valid():
serializer.save()
return Response({**serializer.data, **password_changed})
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
