def my_jwt_response_handler(token, user=None, request=None):
return {
'token': token,
'user': UserSerializer(user, context={
'request': request
}).data
}
def post(self, request, *args, **kwargs):
"""
Function to handle POST requests.
Creates a new user.
"""
logger.info(f"Request: {request}. args: {args}, kwargs: {kwargs}")
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
username = serializer.data.get("username")
logger.info(f"User with username: {username} has been created.")
return Response(serializer.data, status=status.HTTP_201_CREATED)
logger.info(f"Bad request with errors: {serializer.errors}")
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class ClientSubscriptionSerializer(serializers.ModelSerializer):
subscription = SubscriptionSerializer()
client = UserSerializer()
class Meta:
model = ClientSubscription
fields = '__all__'
class PostSerializer(serializers.ModelSerializer):
images = serializers.SerializerMethodField(read_only=True)
content = serializers.CharField()
mission = serializers.CharField(source="mission.name")
user = UserSerializer(read_only=True)
is_like = serializers.SerializerMethodField(read_only=True)
favorite_count = serializers.IntegerField(source="postlike_set.count",
read_only=True)
comment_count = serializers.IntegerField(source="comment_set.count",
read_only=True)
class Meta:
model = Post
fields = [
"id",
"images",
"content",
"mission",
"user",
"is_like",
"favorite_count",
"comment_count",
"created_at",
]
def get_images(self, obj):
post_images = obj.postimage_set.order_by("priority")
return [post_image.image.url for post_image in post_images]
def get_is_like(self, obj):
user = self.context["request"].user
if user and user.is_authenticated:
return obj.postlike_set.filter(user=user).exists()
return False
def get(self, request, *args, **kwargs):
"""
Method to handle GET requests
Returns all the users in the DB.
"""
logger.info(f"Request: {request}. args: {args}, kwargs: {kwargs}")
users = User.objects.all()
serializer = UserSerializer(users, many=True)
return Response(serializer.data)
class EventSerializer(serializers.HyperlinkedModelSerializer):
user = UserSerializer(source="get_user", read_only=True)
calendar = CalendarSerializer(source="get_calendar", read_only=True)
class Meta:
model = Event
fields = ('id', 'title', 'text', 'start_date', 'finish_date',
'is_archived', 'user', 'repeat_type', 'notification_type',
'notice', 'calendar')
def __update_user(self, id, name, last_name):
try:
user = DjangoUser.objects.get(id=id)
user.first_name = name
user.last_name = last_name
user.save(update_fields=['first_name', 'last_name'])
except Exception as e:
print(e, id)
error = var.ERRORS.USER_UPDATE
return er.APIExceptionDetail().get(HTTP_500_INTERNAL_SERVER_ERROR,
error['message'], error['code'],
error['severity'],
error['title'])
return fn.SuccessResponse(var.SUCCESS.USER_UPDATE,
data={'user': UserSerializer(user).data})
def __create_user(self, name, lastName, username, password):
try:
try:
userFilter = DjangoUser.objects.get(email=username)
user = userFilter
user.set_password(password)
user.save()
request = fn.SuccessResponse(var.SUCCESS.USER_CREATE)
except DjangoUser.DoesNotExist:
user = DjangoUser.objects.create_user(username=username,
email=username,
password=password,
first_name=name,
last_name=lastName)
request = self.__send_email_with_token(
user=user, email_props=var.OBJECT.VERIFY_EMAIL)
except Exception as e:
print(e, username)
error = var.ERRORS.USER_CREATE
return er.APIExceptionDetail().get(HTTP_500_INTERNAL_SERVER_ERROR,
error['message'], error['code'],
error['severity'],
error['title'])
try:
person = Person.objects.get(user=user)
except Person.DoesNotExist:
person = Person.objects.create(user=user)
request.data['item'] = UserSerializer(user).data
return request
class InvoiceSerializer(serializers.ModelSerializer):
user = UserSerializer(read_only=True)
products = ProductSerializer(many=True, read_only=True)
total = serializers.FloatField(read_only=True)
class Meta:
model = Invoice
fields = (
'id',
'user',
'products',
'created',
'closed',
'total',
)
def create(self, validated_data):
user_id = self.context.get('request').data.get('user')
product_id = self.context.get('request').data.get('product')
User = get_user_model()
user = User.objects.get(id=user_id)
inctance = Invoice(user=user)
inctance.save()
inctance.products.add(product_id)
return inctance
def update(self, instance, validated_data):
product_id = self.context['request'].data.get('product_id', False)
status = self.context['request'].data.get('status', None)
if product_id and int(product_id) not in \
instance.products.all().values_list('id', flat=True):
instance.products.add(product_id)
if status is not None:
instance.closed = status
instance.save()
return instance
def put(self, request, user_id):
user = User.objects.get(pk=user_id)
profile = UserProfile.objects.get(user_id=user_id)
profileSerializer = UserSerializer(
profile,
data={
'first_name': request.data.get('profile').get('first_name'),
'last_name': request.data.get('profile').get('last_name'),
'phone_number':
request.data.get('profile').get('phone_number'),
'age': request.data.get('profile').get('age'),
'gender': request.data.get('profile').get('gender')
},
partial=True)
profileSerializer.is_valid(raise_exception=True)
profileSerializer.save()
if request.data.get('password'):
serializer = self.serializer_class(user,
data={
'email':
request.data.get('email'),
'password':
request.data.get('password')
},
partial=True)
else:
serializer = self.serializer_class(
user, data={'email': request.data.get('email')}, partial=True)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(
{
'success': 'Updated Successfully!',
'data': serializer.data
},
status=status.HTTP_200_OK)
def __dto(self, user):
return fn.SuccessResponse(var.SUCCESS.USER_VERIFY,
{'user': UserSerializer(user).data})
class ChildCommentSerializer(serializers.ModelSerializer):
user = UserSerializer(read_only=True)
class Meta:
model = Comment
fields = ["id", "user", "content", "created_at"]
def get_user(self, obj):
user = User.objects.get(id=obj["user_id"])
serializer = UserSerializer(instance=user)
return serializer.data
class NewsSerializer(AuditSerializerMixin, ModelSerializer):
create_user = UserSerializer(read_only=True)
class Meta:
model = News
fields = '__all__'
class ProductsMessageSerializer(AuditSerializerMixin, ModelSerializer):
create_user = UserSerializer(read_only=True)
class Meta:
model = ProductsMessage
fields = '__all__'
class CalendarSerializer(serializers.HyperlinkedModelSerializer):
user = UserSerializer(source="get_user", read_only=True)
class Meta:
model = Calendar
fields = ('id', 'title', 'color', 'is_public', 'show', 'user')
