ammar/zod-backend
1
0
Fork 0
mirror of https://github.com/HamzaSha1/zod-backend.git synced 2025-08-26 06:09:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #110 from KiwiTechLLC/dev

Browse Source 
Dev
This commit is contained in:
Ankitajain-kiwi
2023-07-25 17:36:49 +05:30
committed by GitHub
parent 7cb792c6cf 3b31d08996
commit cbd3d139a5
22 changed files with 777 additions and 322 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
account/templates/templated_email/junior_approval_mail.email
View File

@ -8,7 +8,7 @@
<tr>
<td style="padding: 0 27px 15px;">
<p style="margin: 0; font-size: 16px; line-height: 20px; padding: 36px 0 0; font-weight: 500; color: #1f2532;">
Hi {{full_name}},
Hello,
</p>
</td>
</tr>

3
account/utils.py
View File

@ -22,7 +22,7 @@ from junior.models import Junior
from guardian.models import Guardian
from account.models import UserDelete
from base.messages import ERROR_CODE
from django.utils import timezone
# Define delete
# user account condition,
@ -228,3 +228,4 @@ def generate_code(value, user_id):
return code
OTP_EXPIRY = timezone.now() + timezone.timedelta(days=1)

6
account/views.py
View File

@ -22,7 +22,7 @@ from django.conf import settings
"""App Import"""
from guardian.models import Guardian
from junior.models import Junior
from guardian.utils import upload_image_to_alibaba
from guardian.utils import upload_image_to_alibaba, OTP_EXPIRY
from account.models import UserDeviceDetails, UserPhoneOtp, UserEmailOtp, DefaultTaskImages, UserNotification
from django.contrib.auth.models import User
"""Account serializer"""
@ -228,7 +228,7 @@ class ForgotPasswordAPIView(views.APIView):
'verification_code': verification_code
}
)
expiry = timezone.now() + timezone.timedelta(days=1)
expiry = OTP_EXPIRY
user_data, created = UserEmailOtp.objects.get_or_create(email=email)
if created:
user_data.expired_at = expiry
@ -399,7 +399,7 @@ class ReSendEmailOtp(viewsets.ModelViewSet):
def create(self, request, *args, **kwargs):
otp = generate_otp()
if User.objects.filter(email=request.data['email']):
expiry = timezone.now() + timezone.timedelta(days=1)
expiry = OTP_EXPIRY
email_data, created = UserEmailOtp.objects.get_or_create(email=request.data['email'])
if created:
email_data.expired_at = expiry

5
base/constants.py
View File

@ -61,7 +61,8 @@ TASK_STATUS = (
('2', 'in-progress'),
('3', 'rejected'),
('4', 'requested'),
('5', 'completed')
('5', 'completed'),
('6', 'expired')
)
# sign up method
SIGNUP_METHODS = (
@ -106,3 +107,5 @@ MAX_ARTICLE_SURVEY = 10
# real time url
time_url = "http://worldtimeapi.org/api/timezone/Asia/Riyadh"
ARTICLE_CARD_IMAGE_FOLDER = 'article-card-images'

11
base/messages.py
View File

@ -76,12 +76,18 @@ ERROR_CODE = {
"2043": "Article Survey with given id doesn't exist.",
"2044": "Task does not exist",
"2045": "Invalid guardian",
# past due date
"2046": "Due date must be future date",
# invalid junior id msg
"2047": "Invalid Junior ID ",
"2048": "Choose right file for image",
# task request
"2049": "This task is already requested ",
"2059": "Already exist junior"
"2059": "Already exist junior",
# task status
"2060": "Task does not exist or not in pending state",
"2061": "Please insert image or check the image is valid or not."
}
"""Success message code"""
SUCCESS_CODE = {
@ -129,7 +135,8 @@ SUCCESS_CODE = {
"3031": "Article Survey has been removed successfully.",
"3032": "Task request sent successfully",
"3033": "Valid Referral code",
"3034": "Invite guardian successfully"
"3034": "Invite guardian successfully",
"3035": "Task started successfully"
}
"""status code error"""
STATUS_CODE_ERROR = {

2
docker-compose.yml
View File

@ -3,6 +3,7 @@ services:
nginx:
image: nginx:latest
container_name: nginx
restart: always
ports:
- "8000:8000"
volumes:
@ -13,6 +14,7 @@ services:
web:
build: .
container_name: django
restart: always
command: bash -c "pip install -r requirements.txt && python manage.py collectstatic --noinput && python manage.py migrate && gunicorn zod_bank.wsgi -b 0.0.0.0:8000 -t 300 --log-level=info"
volumes:
- .:/usr/src/app

18
guardian/migrations/0020_alter_juniortask_task_status.py Normal file
View File

@ -0,0 +1,18 @@
# Generated by Django 4.2.2 on 2023-07-25 07:44
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('guardian', '0019_guardian_is_invited_guardian_is_password_set'),
]
operations = [
migrations.AlterField(
model_name='juniortask',
name='task_status',
field=models.CharField(choices=[('1', 'pending'), ('2', 'in-progress'), ('3', 'rejected'), ('4', 'requested'), ('5', 'completed'), ('6', 'expired')], default=1, max_length=15),
),
]

4
guardian/models.py
View File

@ -5,7 +5,7 @@ from django.contrib.auth import get_user_model
"""Import Django app"""
from base.constants import GENDERS, TASK_STATUS, PENDING, TASK_POINTS, SIGNUP_METHODS
"""import Junior model"""
from junior.models import Junior
import junior.models
"""Add user model"""
User = get_user_model()
@ -105,7 +105,7 @@ class JuniorTask(models.Model):
"""image that is uploaded by junior"""
image = models.URLField(null=True, blank=True, default=None)
"""associated junior with the task"""
junior = models.ForeignKey(Junior, on_delete=models.CASCADE, related_name='junior', verbose_name='Junior')
junior = models.ForeignKey('junior.Junior', on_delete=models.CASCADE, related_name='junior', verbose_name='Junior')
"""task status"""
task_status = models.CharField(choices=TASK_STATUS, max_length=15, default=PENDING)
"""task is active or not"""

9
guardian/serializers.py
View File

@ -215,6 +215,7 @@ class TaskDetailsSerializer(serializers.ModelSerializer):
junior = JuniorDetailSerializer()
remaining_time = serializers.SerializerMethodField('get_remaining_time')
is_expired = serializers.SerializerMethodField('get_is_expired')
def get_remaining_time(self, obj):
""" remaining time to complete task"""
@ -228,12 +229,16 @@ class TaskDetailsSerializer(serializers.ModelSerializer):
return str(time_difference.days) + ' days ' + str(time_only)
return str(NUMBER['zero']) + ' days ' + '00:00:00:00000'
def get_is_expired(self, obj):
""" task expired or not"""
if obj.due_date < datetime.today().date():
return True
return False
class Meta(object):
"""Meta info"""
model = JuniorTask
fields = ['id', 'guardian', 'task_name', 'task_description', 'points', 'due_date','default_image', 'image',
'requested_on', 'rejected_on', 'completed_on',
'requested_on', 'rejected_on', 'completed_on', 'is_expired',
'junior', 'task_status', 'is_active', 'remaining_time', 'created_at','updated_at']

45
guardian/views.py
View File

@ -1,6 +1,11 @@
"""Views of Guardian"""
# django imports
# Import IsAuthenticated
# Import viewsets and status
# Import PageNumberPagination
# Import User
# Import timezone
from rest_framework.permissions import IsAuthenticated
from rest_framework import viewsets, status
from rest_framework.pagination import PageNumberPagination
@ -18,15 +23,15 @@ from django.utils import timezone
# from utils file
# Import account's serializer
# Import account's task
# Import notification constant
# Import send_notification function
from .serializers import (UserSerializer, CreateGuardianSerializer, TaskSerializer, TaskDetailsSerializer,
TopJuniorSerializer, ApproveJuniorSerializer, ApproveTaskSerializer)
from .models import Guardian, JuniorTask
from junior.models import Junior, JuniorPoints
from account.models import UserEmailOtp, UserNotification
from .tasks import generate_otp
from account.utils import send_otp_email
from account.utils import custom_response, custom_error_response
from account.utils import custom_response, custom_error_response, OTP_EXPIRY, send_otp_email
from base.messages import ERROR_CODE, SUCCESS_CODE
from base.constants import NUMBER
from .utils import upload_image_to_alibaba
@ -51,24 +56,29 @@ class SignupViewset(viewsets.ModelViewSet):
serializer_class = UserSerializer
def create(self, request, *args, **kwargs):
"""Create user profile"""
if request.data['user_type'] in ['1', '2']:
try:
if request.data['user_type'] in [str(NUMBER['one']), str(NUMBER['two'])]:
serializer = UserSerializer(context=request.data['user_type'], data=request.data)
if serializer.is_valid():
user = serializer.save()
"""Generate otp"""
otp = generate_otp()
expiry = timezone.now() + timezone.timedelta(days=1)
# expire otp after 1 day
expiry = OTP_EXPIRY
# create user email otp object
UserEmailOtp.objects.create(email=request.data['email'], otp=otp,
user_type=str(request.data['user_type']), expired_at=expiry)
"""Send email to the register user"""
send_otp_email(request.data['email'], otp)
send_notification(REGISTRATION, None, user.id, {})
# send push notification for registration
send_notification.delay(REGISTRATION, None, user.id, {})
return custom_response(SUCCESS_CODE['3001'],
response_status=status.HTTP_200_OK)
return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
else:
return custom_error_response(ERROR_CODE['2028'], response_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
class UpdateGuardianProfile(viewsets.ViewSet):
"""Update guardian profile"""
@ -78,6 +88,7 @@ class UpdateGuardianProfile(viewsets.ViewSet):
def create(self, request, *args, **kwargs):
"""Create guardian profile"""
try:
data = request.data
image = request.data.get('image')
image_url = ''
@ -98,6 +109,8 @@ class UpdateGuardianProfile(viewsets.ViewSet):
serializer.save()
return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
class AllTaskListAPIView(viewsets.ModelViewSet):
@ -123,6 +136,7 @@ class TaskListAPIView(viewsets.ModelViewSet):
def list(self, request, *args, **kwargs):
"""Create guardian profile"""
try:
status_value = self.request.GET.get('status')
search = self.request.GET.get('search')
if search and str(status_value) == '0':
@ -142,6 +156,8 @@ class TaskListAPIView(viewsets.ModelViewSet):
# use TaskDetailsSerializer serializer
serializer = TaskDetailsSerializer(paginated_queryset, many=True)
return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
class CreateTaskAPIView(viewsets.ModelViewSet):
"""create task for junior"""
@ -150,6 +166,7 @@ class CreateTaskAPIView(viewsets.ModelViewSet):
http_method_names = ('post', )
def create(self, request, *args, **kwargs):
try:
image = request.data['default_image']
junior = request.data['junior']
allowed_extensions = ['.jpg', '.jpeg', '.png']
@ -177,6 +194,8 @@ class CreateTaskAPIView(viewsets.ModelViewSet):
send_notification.delay(TASK_CREATED, None, junior_id.auth.id, {})
return custom_response(SUCCESS_CODE['3018'], serializer.data, response_status=status.HTTP_200_OK)
return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
class SearchTaskListAPIView(viewsets.ModelViewSet):
"""Update guardian profile"""
@ -194,14 +213,16 @@ class SearchTaskListAPIView(viewsets.ModelViewSet):
def list(self, request, *args, **kwargs):
"""Create guardian profile"""
try:
queryset = self.get_queryset()
paginator = self.pagination_class()
# use pagination
paginated_queryset = paginator.paginate_queryset(queryset, request)
# use TaskSerializer serializer
serializer = TaskDetailsSerializer(paginated_queryset, many=True)
return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
class TopJuniorListAPIView(viewsets.ModelViewSet):
@ -218,6 +239,7 @@ class TopJuniorListAPIView(viewsets.ModelViewSet):
def list(self, request, *args, **kwargs):
"""Fetch junior list of those who complete their tasks"""
try:
junior_total_points = self.get_queryset().order_by('-total_points')
# Update the position field for each JuniorPoints object
@ -227,6 +249,8 @@ class TopJuniorListAPIView(viewsets.ModelViewSet):
serializer = self.get_serializer(junior_total_points, many=True)
return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
class ApproveJuniorAPIView(viewsets.ViewSet):
@ -243,6 +267,7 @@ class ApproveJuniorAPIView(viewsets.ViewSet):
def create(self, request, *args, **kwargs):
""" junior list"""
try:
queryset = self.get_queryset()
# action 1 is use for approve and 2 for reject
if request.data['action'] == '1':
@ -256,6 +281,8 @@ class ApproveJuniorAPIView(viewsets.ViewSet):
return custom_response(SUCCESS_CODE['3023'], serializer.data, response_status=status.HTTP_200_OK)
else:
return custom_response(SUCCESS_CODE['3024'], response_status=status.HTTP_200_OK)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
class ApproveTaskAPIView(viewsets.ViewSet):
"""approve junior by guardian"""
@ -274,6 +301,7 @@ class ApproveTaskAPIView(viewsets.ViewSet):
def create(self, request, *args, **kwargs):
""" junior list"""
# action 1 is use for approve and 2 for reject
try:
queryset = self.get_queryset()
# use ApproveJuniorSerializer serializer
serializer = ApproveTaskSerializer(context={"guardian_code": queryset[0].guardian_code,
@ -291,3 +319,6 @@ class ApproveTaskAPIView(viewsets.ViewSet):
return custom_response(SUCCESS_CODE['3026'], response_status=status.HTTP_200_OK)
else:
return custom_response(ERROR_CODE['2038'], response_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)

8
junior/admin.py
View File

@ -2,7 +2,7 @@
"""Third party Django app"""
from django.contrib import admin
"""Import Django app"""
from .models import Junior, JuniorPoints
from .models import Junior, JuniorPoints, JuniorGuardianRelationship
# Register your models here.
@admin.register(Junior)
class JuniorAdmin(admin.ModelAdmin):
@ -21,3 +21,9 @@ class JuniorPointsAdmin(admin.ModelAdmin):
def __str__(self):
"""Return email id"""
return self.junior.auth.email
@admin.register(JuniorGuardianRelationship)
class JuniorGuardianRelationshipAdmin(admin.ModelAdmin):
"""Junior Admin"""
list_display = ['guardian', 'junior', 'relationship']

31
junior/migrations/0017_juniorguardianrelationship.py Normal file
View File

@ -0,0 +1,31 @@
# Generated by Django 4.2.2 on 2023-07-25 07:44
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('guardian', '0020_alter_juniortask_task_status'),
('junior', '0016_juniorpoints_referral_points'),
]
operations = [
migrations.CreateModel(
name='JuniorGuardianRelationship',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('relationship', models.CharField(blank=True, choices=[('1', 'parent'), ('2', 'legal_guardian')], default='1', max_length=31, null=True)),
('created_at', models.DateTimeField(auto_now_add=True)),
('updated_at', models.DateTimeField(auto_now=True)),
('guardian', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='guardian_relation', to='guardian.guardian', verbose_name='Guardian')),
('junior', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='junior_relation', to='junior.junior', verbose_name='Junior')),
],
options={
'verbose_name': 'Junior Guardian Relation',
'verbose_name_plural': 'Junior Guardian Relation',
'db_table': 'junior_guardian_relation',
},
),
]

34
junior/models.py
View File

@ -7,6 +7,9 @@ from django.contrib.auth import get_user_model
from django.contrib.postgres.fields import ArrayField
"""Import django app"""
from base.constants import GENDERS, SIGNUP_METHODS, RELATIONSHIP
# Import guardian's model
from guardian.models import Guardian
"""Define User model"""
User = get_user_model()
# Create your models here.
@ -31,7 +34,7 @@ User = get_user_model()
"""Define junior points model"""
# points of the junior
# position of the junior
# define junior guardian relation model
class Junior(models.Model):
"""Junior model"""
auth = models.ForeignKey(User, on_delete=models.CASCADE, related_name='junior_profile', verbose_name='Email')
@ -46,9 +49,6 @@ class Junior(models.Model):
dob = models.DateField(max_length=15, null=True, blank=True, default=None)
# Image of the junior"""
image = models.URLField(null=True, blank=True, default=None)
# relationship"""
relationship = models.CharField(max_length=31, choices=RELATIONSHIP, null=True, blank=True,
default='1')
# Sign up method"""
signup_method = models.CharField(max_length=31, choices=SIGNUP_METHODS, default='1')
# Codes"""
@ -109,3 +109,29 @@ class JuniorPoints(models.Model):
def __str__(self):
"""Return email id"""
return f'{self.junior.auth}'
class JuniorGuardianRelationship(models.Model):
"""Junior Guardian relationship model"""
guardian = models.ForeignKey(Guardian, on_delete=models.CASCADE, related_name='guardian_relation',
verbose_name='Guardian')
# associated junior with the task
junior = models.ForeignKey(Junior, on_delete=models.CASCADE, related_name='junior_relation', verbose_name='Junior')
# relation between guardian and junior"""
relationship = models.CharField(max_length=31, choices=RELATIONSHIP, null=True, blank=True,
default='1')
"""Profile created and updated time"""
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
class Meta(object):
""" Meta class """
db_table = 'junior_guardian_relation'
"""verbose name of the model"""
verbose_name = 'Junior Guardian Relation'
verbose_name_plural = 'Junior Guardian Relation'
def __str__(self):
"""Return email id"""
return f'{self.guardian.user}'

67
junior/serializers.py
View File

@ -9,14 +9,14 @@ from rest_framework_simplejwt.tokens import RefreshToken
"""Import django app"""
from account.utils import send_otp_email, generate_code
from junior.models import Junior, JuniorPoints
from junior.models import Junior, JuniorPoints, JuniorGuardianRelationship
from guardian.tasks import generate_otp
from base.messages import ERROR_CODE, SUCCESS_CODE
from base.constants import PENDING, IN_PROGRESS, REJECTED, REQUESTED, COMPLETED, NUMBER, JUN, ZOD
from guardian.models import Guardian, JuniorTask
from account.models import UserEmailOtp
from account.models import UserEmailOtp, UserNotification
from junior.utils import junior_notification_email, junior_approval_mail
from guardian.utils import real_time, update_referral_points
from guardian.utils import real_time, update_referral_points, convert_timedelta_into_datetime
from notifications.utils import send_notification
from notifications.constants import INVITED_GUARDIAN, APPROVED_JUNIOR
@ -249,18 +249,11 @@ class JuniorProfileSerializer(serializers.ModelSerializer):
class AddJuniorSerializer(serializers.ModelSerializer):
"""Add junior serializer"""
auth_token = serializers.SerializerMethodField('get_auth_token')
def get_auth_token(self, obj):
"""auth token"""
refresh = RefreshToken.for_user(obj)
access_token = str(refresh.access_token)
return access_token
class Meta(object):
"""Meta info"""
model = Junior
fields = ['id', 'gender','dob', 'relationship', 'auth_token', 'is_invited']
fields = ['id', 'gender','dob', 'is_invited']
def create(self, validated_data):
@ -268,6 +261,7 @@ class AddJuniorSerializer(serializers.ModelSerializer):
with transaction.atomic():
email = self.context['email']
guardian = self.context['user']
relationship = self.context['relationship']
full_name = self.context['first_name'] + ' ' + self.context['last_name']
guardian_data = Guardian.objects.filter(user__username=guardian).last()
user_data = User.objects.create(username=email, email=email,
@ -278,11 +272,13 @@ class AddJuniorSerializer(serializers.ModelSerializer):
user_data.save()
junior_data = Junior.objects.create(auth=user_data, gender=validated_data.get('gender'),
dob=validated_data.get('dob'), is_invited=True,
relationship=validated_data.get('relationship'),
guardian_code=[guardian_data.guardian_code],
junior_code=generate_code(JUN, user_data.id),
referral_code=generate_code(ZOD, user_data.id),
referral_code_used=guardian_data.referral_code,
is_password_set=False, is_verified=True)
JuniorGuardianRelationship.objects.create(guardian=guardian_data, junior=junior_data,
relationship=relationship)
"""Generate otp"""
otp_value = generate_otp()
expiry_time = timezone.now() + timezone.timedelta(days=1)
@ -375,18 +371,11 @@ class JuniorPointsSerializer(serializers.ModelSerializer):
class AddGuardianSerializer(serializers.ModelSerializer):
"""Add guardian serializer"""
auth_token = serializers.SerializerMethodField('get_auth_token')
def get_auth_token(self, obj):
"""auth token"""
refresh = RefreshToken.for_user(obj)
access_token = str(refresh.access_token)
return access_token
class Meta(object):
"""Meta info"""
model = Guardian
fields = ['id', 'auth_token']
fields = ['id']
def create(self, validated_data):
@ -394,15 +383,17 @@ class AddGuardianSerializer(serializers.ModelSerializer):
with transaction.atomic():
email = self.context['email']
junior = self.context['user']
relationship = self.context['relationship']
full_name = self.context['first_name'] + ' ' + self.context['last_name']
junior_data = Junior.objects.filter(auth__username=junior).last()
instance = User.objects.filter(username=email).last()
if instance:
guardian_data = Guardian.objects.filter(user=user).update(is_invited=True,
guardian_data = Guardian.objects.filter(user=instance).update(is_invited=True,
referral_code=generate_code(ZOD,
instance.id),
referral_code_used=junior_data.referral_code,
is_verified=True)
UserNotification.objects.create(user=instance)
return guardian_data
else:
user = User.objects.create(username=email, email=email,
@ -412,7 +403,7 @@ class AddGuardianSerializer(serializers.ModelSerializer):
password = User.objects.make_random_password()
user.set_password(password)
user.save()
Guardian.objects.create(user=user, is_invited=True,
guardian_data = Guardian.objects.create(user=user, is_invited=True,
referral_code=generate_code(ZOD, user.id),
referral_code_used=junior_data.referral_code,
is_password_set=False, is_verified=True)
@ -422,9 +413,37 @@ class AddGuardianSerializer(serializers.ModelSerializer):
UserEmailOtp.objects.create(email=email, otp=otp_value,
user_type=str(NUMBER['two']), expired_at=expiry_time,
is_verified=True)
UserNotification.objects.create(user=user)
JuniorGuardianRelationship.objects.create(guardian=guardian_data, junior=junior_data,
relationship=relationship)
"""Notification email"""
junior_notification_email(email, full_name, email, password)
junior_approval_mail(email, full_name)
send_notification(INVITED_GUARDIAN, None, junior_data.auth.id, {})
send_notification(APPROVED_JUNIOR, None, email, {})
send_notification.delay(INVITED_GUARDIAN, None, junior_data.auth.id, {})
send_notification.delay(APPROVED_JUNIOR, None, guardian_data.user.id, {})
return guardian_data
class StartTaskSerializer(serializers.ModelSerializer):
"""User task Serializer"""
task_duration = serializers.SerializerMethodField('get_task_duration')
def get_task_duration(self, obj):
""" remaining time to complete task"""
due_date = datetime.combine(obj.due_date, datetime.max.time())
# fetch real time
real_datetime = real_time()
# Perform the subtraction
if due_date > real_datetime:
time_difference = due_date - real_datetime
time_only = convert_timedelta_into_datetime(time_difference)
return str(time_difference.days) + ' days ' + str(time_only)
return str(NUMBER['zero']) + ' days ' + '00:00:00:00000'
class Meta(object):
"""Meta class"""
model = JuniorTask
fields = ('id', 'task_duration')
def update(self, instance, validated_data):
instance.task_status = str(NUMBER['two'])
instance.save()
return instance

5
junior/urls.py
View File

@ -4,7 +4,7 @@ from django.urls import path, include
from .views import (UpdateJuniorProfile, ValidateGuardianCode, JuniorListAPIView, AddJuniorAPIView,
InvitedJuniorAPIView, FilterJuniorAPIView, RemoveJuniorAPIView, JuniorTaskListAPIView,
CompleteJuniorTaskAPIView, JuniorPointsListAPIView, ValidateReferralCode,
InviteGuardianAPIView)
InviteGuardianAPIView, StartTaskAPIView)
"""Third party import"""
from rest_framework import routers
@ -45,5 +45,6 @@ router.register('invite-guardian', InviteGuardianAPIView, basename='invite-guard
urlpatterns = [
path('api/v1/', include(router.urls)),
path('api/v1/remove-junior/', RemoveJuniorAPIView.as_view()),
path('api/v1/complete-task/', CompleteJuniorTaskAPIView.as_view())
path('api/v1/complete-task/', CompleteJuniorTaskAPIView.as_view()),
path('api/v1/start-task/', StartTaskAPIView.as_view())
]

89
junior/views.py
View File

@ -20,10 +20,14 @@ import requests
# Import account's serializer
# Import account's task
# import junior serializer
# Import update_positions_based_on_points
# Import upload_image_to_alibaba
# Import custom_response, custom_error_response
# Import constants
from junior.models import Junior, JuniorPoints
from .serializers import (CreateJuniorSerializer, JuniorDetailListSerializer, AddJuniorSerializer,\
RemoveJuniorSerializer, CompleteTaskSerializer, JuniorPointsSerializer,
AddGuardianSerializer)
AddGuardianSerializer, StartTaskSerializer)
from guardian.models import Guardian, JuniorTask
from guardian.serializers import TaskDetailsSerializer
from base.messages import ERROR_CODE, SUCCESS_CODE
@ -43,7 +47,10 @@ from .utils import update_positions_based_on_points
# approve junior API
# create referral code
# validation API
# invite guardian API
# by junior
# Start task
# by junior API
# Create your views here.
class UpdateJuniorProfile(viewsets.ViewSet):
"""Update junior profile"""
@ -53,10 +60,12 @@ class UpdateJuniorProfile(viewsets.ViewSet):
def create(self, request, *args, **kwargs):
"""Use CreateJuniorSerializer"""
try:
request_data = request.data
image = request.data.get('image')
image_url = ''
if image:
# check image size
if image.size == NUMBER['zero']:
return custom_error_response(ERROR_CODE['2035'], response_status=status.HTTP_400_BAD_REQUEST)
# convert into file
@ -74,6 +83,8 @@ class UpdateJuniorProfile(viewsets.ViewSet):
serializer.save()
return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
class ValidateGuardianCode(viewsets.ViewSet):
"""Check guardian code exist or not"""
@ -82,14 +93,18 @@ class ValidateGuardianCode(viewsets.ViewSet):
def list(self, request, *args, **kwargs):
"""check guardian code"""
try:
guardian_code = self.request.GET.get('guardian_code').split(',')
for code in guardian_code:
# fetch guardian object
guardian_data = Guardian.objects.filter(guardian_code=code).exists()
if guardian_data:
# successfully check guardian code
return custom_response(SUCCESS_CODE['3013'], response_status=status.HTTP_200_OK)
else:
return custom_error_response(ERROR_CODE["2022"], response_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
class JuniorListAPIView(viewsets.ModelViewSet):
"""Junior list of assosicated guardian"""
@ -97,9 +112,11 @@ class JuniorListAPIView(viewsets.ModelViewSet):
serializer_class = JuniorDetailListSerializer
queryset = Junior.objects.all()
permission_classes = [IsAuthenticated]
http_method_names = ('get',)
def list(self, request, *args, **kwargs):
""" junior list"""
try:
update_positions_based_on_points()
guardian_data = Guardian.objects.filter(user__email=request.user).last()
# fetch junior object
@ -109,26 +126,32 @@ class JuniorListAPIView(viewsets.ModelViewSet):
serializer = JuniorDetailListSerializer(queryset, many=True)
return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
return custom_error_response(ERROR_CODE['2045'], response_status=status.HTTP_200_OK)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
class AddJuniorAPIView(viewsets.ModelViewSet):
"""Add Junior by guardian"""
queryset = Junior.objects.all()
serializer_class = AddJuniorSerializer
permission_classes = [IsAuthenticated]
http_method_names = ('post',)
def create(self, request, *args, **kwargs):
""" junior list"""
info = {'user': request.user, 'email': request.data['email'], 'first_name': request.data['first_name'],
try:
info_data = {'user': request.user, 'relationship': str(request.data['relationship']), 'email': request.data['email'], 'first_name': request.data['first_name'],
'last_name': request.data['last_name']}
if User.objects.filter(username=request.data['email']):
return custom_error_response(ERROR_CODE['2059'], response_status=status.HTTP_400_BAD_REQUEST)
# use AddJuniorSerializer serializer
serializer = AddJuniorSerializer(data=request.data, context=info)
serializer = AddJuniorSerializer(data=request.data, context=info_data)
if serializer.is_valid():
# save serializer
serializer.save()
return custom_response(SUCCESS_CODE['3021'], serializer.data, response_status=status.HTTP_200_OK)
return custom_error_response(serializer.error, response_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
class InvitedJuniorAPIView(viewsets.ModelViewSet):
"""Junior list of assosicated guardian"""
@ -137,6 +160,7 @@ class InvitedJuniorAPIView(viewsets.ModelViewSet):
queryset = Junior.objects.all()
permission_classes = [IsAuthenticated]
pagination_class = PageNumberPagination
http_method_names = ('get',)
def get_queryset(self):
"""Get the queryset for the view"""
@ -146,6 +170,7 @@ class InvitedJuniorAPIView(viewsets.ModelViewSet):
return junior_queryset
def list(self, request, *args, **kwargs):
""" junior list"""
try:
queryset = self.get_queryset()
paginator = self.pagination_class()
# pagination
@ -153,6 +178,8 @@ class InvitedJuniorAPIView(viewsets.ModelViewSet):
# use JuniorDetailListSerializer serializer
serializer = JuniorDetailListSerializer(paginated_queryset, many=True)
return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
class FilterJuniorAPIView(viewsets.ModelViewSet):
@ -161,6 +188,7 @@ class FilterJuniorAPIView(viewsets.ModelViewSet):
permission_classes = [IsAuthenticated]
pagination_class = PageNumberPagination
queryset = Junior.objects.all()
http_method_names = ('get',)
def get_queryset(self):
"""Get the queryset for the view"""
@ -173,6 +201,7 @@ class FilterJuniorAPIView(viewsets.ModelViewSet):
def list(self, request, *args, **kwargs):
"""Create guardian profile"""
try:
queryset = self.get_queryset()
paginator = self.pagination_class()
# use Pagination
@ -180,6 +209,8 @@ class FilterJuniorAPIView(viewsets.ModelViewSet):
# use JuniorDetailListSerializer serializer
serializer = JuniorDetailListSerializer(paginated_queryset, many=True)
return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
class RemoveJuniorAPIView(views.APIView):
@ -189,6 +220,7 @@ class RemoveJuniorAPIView(views.APIView):
permission_classes = [IsAuthenticated]
def put(self, request, format=None):
try:
junior_id = self.request.GET.get('id')
guardian = Guardian.objects.filter(user__email=self.request.user).last()
# fetch junior query
@ -204,6 +236,8 @@ class RemoveJuniorAPIView(views.APIView):
return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
else:
return custom_error_response(ERROR_CODE['2034'], response_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
class JuniorTaskListAPIView(viewsets.ModelViewSet):
@ -212,9 +246,11 @@ class JuniorTaskListAPIView(viewsets.ModelViewSet):
permission_classes = [IsAuthenticated]
pagination_class = PageNumberPagination
queryset = JuniorTask.objects.all()
http_method_names = ('get',)
def list(self, request, *args, **kwargs):
"""Create guardian profile"""
try:
status_value = self.request.GET.get('status')
search = self.request.GET.get('search')
if search and str(status_value) == '0':
@ -238,6 +274,8 @@ class JuniorTaskListAPIView(viewsets.ModelViewSet):
# use TaskDetailsSerializer serializer
serializer = TaskDetailsSerializer(paginated_queryset, many=True)
return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
class CompleteJuniorTaskAPIView(views.APIView):
@ -280,22 +318,28 @@ class JuniorPointsListAPIView(viewsets.ModelViewSet):
"""Junior Points viewset"""
serializer_class = JuniorPointsSerializer
permission_classes = [IsAuthenticated]
http_method_names = ('get',)
def get_queryset(self):
"""get queryset"""
return JuniorTask.objects.filter(junior__auth__email=self.request.user).last()
def list(self, request, *args, **kwargs):
"""profile view"""
try:
queryset = self.get_queryset()
# update position of junior
update_positions_based_on_points()
serializer = JuniorPointsSerializer(queryset)
return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
class ValidateReferralCode(viewsets.ViewSet):
"""Check guardian code exist or not"""
permission_classes = [IsAuthenticated]
http_method_names = ('get',)
def get_queryset(self):
"""Get queryset based on referral_code."""
@ -314,19 +358,23 @@ class ValidateReferralCode(viewsets.ViewSet):
def list(self, request, *args, **kwargs):
"""check guardian code"""
try:
if self.get_queryset():
return custom_response(SUCCESS_CODE['3033'], response_status=status.HTTP_200_OK)
return custom_error_response(ERROR_CODE["2019"], response_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
class InviteGuardianAPIView(viewsets.ModelViewSet):
"""Invite guardian by junior"""
serializer_class = AddGuardianSerializer
permission_classes = [IsAuthenticated]
http_method_names = ('post',)
def create(self, request, *args, **kwargs):
""" junior list"""
try:
info = {'user': request.user, 'email': request.data['email'], 'first_name': request.data['first_name'],
'last_name': request.data['last_name']}
'last_name': request.data['last_name'], 'relationship': str(request.data['relationship'])}
# use AddJuniorSerializer serializer
serializer = AddGuardianSerializer(data=request.data, context=info)
if serializer.is_valid():
@ -334,3 +382,30 @@ class InviteGuardianAPIView(viewsets.ModelViewSet):
serializer.save()
return custom_response(SUCCESS_CODE['3034'], serializer.data, response_status=status.HTTP_200_OK)
return custom_error_response(serializer.error, response_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
class StartTaskAPIView(views.APIView):
"""Update junior task API"""
serializer_class = StartTaskSerializer
model = JuniorTask
permission_classes = [IsAuthenticated]
def put(self, request, format=None):
try:
task_id = self.request.data.get('task_id')
task_queryset = JuniorTask.objects.filter(id=task_id, junior__auth__email=self.request.user).last()
if task_queryset and task_queryset.task_status == str(NUMBER['one']):
# use StartTaskSerializer serializer
serializer = StartTaskSerializer(task_queryset, data=request.data, partial=True)
if serializer.is_valid():
# save serializer
serializer.save()
return custom_response(SUCCESS_CODE['3035'], serializer.data, response_status=status.HTTP_200_OK)
return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
else:
# task in another state
return custom_error_response(ERROR_CODE['2060'], response_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)

10
web_admin/admin.py
View File

@ -5,7 +5,7 @@ web_admin admin file
from django.contrib import admin
# local imports
from web_admin.models import Article, ArticleCard, ArticleSurvey, SurveyOption
from web_admin.models import Article, ArticleCard, ArticleSurvey, SurveyOption, DefaultArticleCardImage
@admin.register(Article)
@ -17,7 +17,7 @@ class ArticleAdmin(admin.ModelAdmin):
@admin.register(ArticleCard)
class ArticleCardAdmin(admin.ModelAdmin):
"""Article Card Admin"""
list_display = ['id', 'article', 'title', 'description', 'image']
list_display = ['id', 'article', 'title', 'description', 'image_url']
@admin.register(ArticleSurvey)
@ -30,3 +30,9 @@ class ArticleSurveyAdmin(admin.ModelAdmin):
class SurveyOptionAdmin(admin.ModelAdmin):
"""Survey Option Admin"""
list_display = ['id', 'survey', 'option', 'is_answer']
@admin.register(DefaultArticleCardImage)
class DefaultArticleCardImagesAdmin(admin.ModelAdmin):
"""Default Article Card Images Option Admin"""
list_display = ['image_name', 'image_url']

28
web_admin/migrations/0003_defaultarticlecardimage_and_more.py Normal file
View File

@ -0,0 +1,28 @@
# Generated by Django 4.2.2 on 2023-07-24 14:15
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('web_admin', '0002_alter_articlecard_image'),
]
operations = [
migrations.CreateModel(
name='DefaultArticleCardImage',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('image_name', models.CharField(max_length=20)),
('image_url', models.URLField()),
('created_at', models.DateTimeField(auto_now_add=True)),
('updated_at', models.DateTimeField(auto_now=True)),
],
),
migrations.RenameField(
model_name='articlecard',
old_name='image',
new_name='image_url',
),
]

16
web_admin/models.py
View File

@ -28,7 +28,7 @@ class ArticleCard(models.Model):
article = models.ForeignKey(Article, on_delete=models.CASCADE, related_name='article_cards')
title = models.CharField(max_length=255)
description = models.TextField()
image = models.URLField(null=True, blank=True, default=None)
image_url = models.URLField(null=True, blank=True, default=None)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
@ -65,3 +65,17 @@ class SurveyOption(models.Model):
def __str__(self):
"""Return title"""
return f'{self.id} | {self.survey}'
class DefaultArticleCardImage(models.Model):
"""
Default images upload in oss bucket
"""
image_name = models.CharField(max_length=20)
image_url = models.URLField()
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
def __str__(self):
"""return image_name as an object"""
return self.image_name

130
web_admin/serializers.py
View File

@ -3,14 +3,18 @@ web_admin serializers file
"""
# django imports
from rest_framework import serializers
from django.contrib.auth import get_user_model
from base.constants import ARTICLE_SURVEY_POINTS, MAX_ARTICLE_CARD, MIN_ARTICLE_SURVEY, MAX_ARTICLE_SURVEY
from base.constants import (ARTICLE_SURVEY_POINTS, MAX_ARTICLE_CARD, MIN_ARTICLE_SURVEY, MAX_ARTICLE_SURVEY, NUMBER,
USER_TYPE, ARTICLE_CARD_IMAGE_FOLDER)
# local imports
from base.messages import ERROR_CODE
from guardian.utils import upload_image_to_alibaba
from web_admin.models import Article, ArticleCard, SurveyOption, ArticleSurvey
from web_admin.models import Article, ArticleCard, SurveyOption, ArticleSurvey, DefaultArticleCardImage
from web_admin.utils import pop_id
USER = get_user_model()
class ArticleCardSerializer(serializers.ModelSerializer):
"""
@ -18,23 +22,25 @@ class ArticleCardSerializer(serializers.ModelSerializer):
"""
id = serializers.IntegerField(required=False)
image = serializers.FileField(required=False)
image_url = serializers.URLField(required=False)
class Meta:
"""
meta class
"""
model = ArticleCard
fields = ('id', 'title', 'description', 'image')
fields = ('id', 'title', 'description', 'image', 'image_url')
def create(self, validated_data):
image = validated_data.get('image', '')
filename = f"article/{image.name}"
if 'image' in validated_data and validated_data['image'] is not None:
image = validated_data.pop('image')
filename = f"{ARTICLE_CARD_IMAGE_FOLDER}/{image.name}"
# upload image on ali baba
validated_data['image'] = upload_image_to_alibaba(image, filename)
validated_data['image_url'] = upload_image_to_alibaba(image, filename)
article_card = ArticleCard.objects.create(article_id='1', **validated_data)
return article_card
class SurveyOptionSerializer(serializers.ModelSerializer):
"""
survey option serializer
@ -81,7 +87,6 @@ class ArticleSerializer(serializers.ModelSerializer):
def validate(self, attrs):
"""
to validate request data
:param attrs:
:return: validated attrs
"""
article_cards = attrs.get('article_cards', None)
@ -97,7 +102,6 @@ class ArticleSerializer(serializers.ModelSerializer):
"""
to create article.
ID in post data dict is for update api.
:param validated_data:
:return: article object
"""
article_cards = validated_data.pop('article_cards')
@ -107,6 +111,11 @@ class ArticleSerializer(serializers.ModelSerializer):
for card in article_cards:
card = pop_id(card)
if 'image' in card and card['image'] is not None:
image = card.pop('image')
filename = f"{ARTICLE_CARD_IMAGE_FOLDER}/{image.name}"
# upload image on ali baba
card['image_url'] = upload_image_to_alibaba(image, filename)
ArticleCard.objects.create(article=article, **card)
for survey in article_survey:
@ -122,8 +131,7 @@ class ArticleSerializer(serializers.ModelSerializer):
def update(self, instance, validated_data):
"""
to update article and related table
:param instance:
:param validated_data:
:param instance: article object,
:return: article object
"""
article_cards = validated_data.pop('article_cards')
@ -139,10 +147,19 @@ class ArticleSerializer(serializers.ModelSerializer):
card = ArticleCard.objects.get(id=card_id, article=instance)
card.title = card_data.get('title', card.title)
card.description = card_data.get('description', card.description)
card.image = card_data.get('image', card.image)
if 'image' in card_data and card_data['image'] is not None:
image = card_data.pop('image')
filename = f"{ARTICLE_CARD_IMAGE_FOLDER}/{image.name}"
# upload image on ali baba
card.image_url = upload_image_to_alibaba(image, filename)
card.save()
else:
card_data = pop_id(card_data)
if 'image' in card_data and card_data['image'] is not None:
image = card_data.pop('image')
filename = f"{ARTICLE_CARD_IMAGE_FOLDER}/{image.name}"
# upload image on ali baba
card_data['image_url'] = upload_image_to_alibaba(image, filename)
ArticleCard.objects.create(article=instance, **card_data)
# Update or create survey sections
@ -170,3 +187,92 @@ class ArticleSerializer(serializers.ModelSerializer):
SurveyOption.objects.create(survey=survey, **option_data)
return instance
class DefaultArticleCardImageSerializer(serializers.ModelSerializer):
"""
Article Card serializer
"""
image = serializers.FileField(required=False)
image_url = serializers.URLField(required=False)
class Meta:
"""
meta class
"""
model = DefaultArticleCardImage
fields = ('image_name', 'image', 'image_url')
def validate(self, attrs):
"""
to validate data
:return: validated data
"""
if 'image' not in attrs and attrs.get('image') is None:
raise serializers.ValidationError({'details': ERROR_CODE['2061']})
return attrs
def create(self, validated_data):
"""
to create and upload image
:return: card_image object
"""
image = validated_data.pop('image')
filename = f"{ARTICLE_CARD_IMAGE_FOLDER}/{image.name}"
if image and image.size == NUMBER['zero']:
raise serializers.ValidationError(ERROR_CODE['2035'])
# upload image on ali baba
validated_data['image_url'] = upload_image_to_alibaba(image, filename)
card_image = DefaultArticleCardImage.objects.create(**validated_data)
return card_image
class UserManagementListSerializer(serializers.ModelSerializer):
"""
user management serializer
"""
name = serializers.SerializerMethodField()
phone_number = serializers.SerializerMethodField()
user_type = serializers.SerializerMethodField()
class Meta:
"""
meta class
"""
model = USER
fields = ('name', 'email', 'phone_number', 'user_type', 'is_active')
@staticmethod
def get_name(obj):
"""
:param obj: user object
:return: full name
"""
return (obj.first_name + obj.last_name) if obj.last_name else obj.first_name
@staticmethod
def get_phone_number(obj):
"""
:param obj: user object
:return: user phone number
"""
if profile := obj.guardian_profile.all().first():
return profile.phone
elif profile := obj.junior_profile.all().first():
return profile.phone
else:
return None
@staticmethod
def get_user_type(obj):
"""
:param obj: user object
:return: user type
"""
if obj.guardian_profile.all().first():
return dict(USER_TYPE).get('2')
elif obj.junior_profile.all().first():
return dict(USER_TYPE).get('1')
else:
return None

4
web_admin/urls.py
View File

@ -6,12 +6,14 @@ from django.urls import path, include
from rest_framework import routers
# local imports
from web_admin.views import ArticleViewSet
from web_admin.views import ArticleViewSet, DefaultArticleCardImagesViewSet, UserManagementViewSet
# initiate router
router = routers.SimpleRouter()
router.register('article', ArticleViewSet, basename='article')
router.register('default-card-images', DefaultArticleCardImagesViewSet, basename='default-card-images')
router.register('user', UserManagementViewSet, basename='user')
urlpatterns = [
path('api/v1/', include(router.urls)),

84
web_admin/views.py
View File

@ -3,18 +3,22 @@ web_admin views file
"""
# django imports
from rest_framework.viewsets import GenericViewSet, mixins
from rest_framework.response import Response
from rest_framework.filters import OrderingFilter, SearchFilter
from rest_framework import status
from rest_framework.decorators import action
from rest_framework.permissions import IsAuthenticated
from rest_framework.permissions import IsAuthenticated, AllowAny
from django.contrib.auth import get_user_model
# local imports
from account.utils import custom_response, custom_error_response
from base.constants import USER_TYPE
from base.messages import SUCCESS_CODE, ERROR_CODE
from web_admin.models import Article, ArticleCard, ArticleSurvey
from web_admin.models import Article, ArticleCard, ArticleSurvey, DefaultArticleCardImage
from web_admin.permission import AdminPermission
from web_admin.serializers import ArticleSerializer, ArticleCardSerializer
from web_admin.serializers import (ArticleSerializer, ArticleCardSerializer, DefaultArticleCardImageSerializer,
UserManagementListSerializer)
USER = get_user_model()
class ArticleViewSet(GenericViewSet, mixins.CreateModelMixin, mixins.UpdateModelMixin,
@ -137,7 +141,7 @@ class ArticleViewSet(GenericViewSet, mixins.CreateModelMixin, mixins.UpdateModel
return custom_error_response(ERROR_CODE["2043"], response_status=status.HTTP_400_BAD_REQUEST)
@action(methods=['post'], url_name='test-add-card', url_path='test-add-card',
detail=False, serializer_class=ArticleCardSerializer)
detail=False, serializer_class=ArticleCardSerializer, permission_classes=[AllowAny])
def add_card(self, request):
"""
:param request:
@ -147,3 +151,73 @@ class ArticleViewSet(GenericViewSet, mixins.CreateModelMixin, mixins.UpdateModel
serializer.is_valid(raise_exception=True)
serializer.save()
return custom_response(SUCCESS_CODE["3000"])
@action(methods=['get'], url_name='test-list-card', url_path='test-list-card',
detail=False, serializer_class=ArticleCardSerializer, permission_classes=[AllowAny])
def list_card(self, request):
"""
:param request:
:return:
"""
queryset = ArticleCard.objects.all()
serializer = self.serializer_class(queryset, many=True)
return custom_response(None, serializer.data)
class DefaultArticleCardImagesViewSet(GenericViewSet, mixins.CreateModelMixin, mixins.ListModelMixin):
"""
api to upload and list default article card images
"""
serializer_class = DefaultArticleCardImageSerializer
permission_classes = [IsAuthenticated, AdminPermission]
queryset = DefaultArticleCardImage.objects.all()
def create(self, request, *args, **kwargs):
"""
api method to upload default article card images
:param request:
:return: success message
"""
serializer = self.serializer_class(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return custom_response(SUCCESS_CODE["3000"])
def list(self, request, *args, **kwargs):
"""
api method to list default article card images
:param request:
:return: default article card images
"""
queryset = self.queryset
serializer = self.serializer_class(queryset, many=True)
return custom_response(None, data=serializer.data)
class UserManagementViewSet(GenericViewSet, mixins.ListModelMixin):
"""
api to manage (list, view, edit) user
"""
serializer_class = UserManagementListSerializer
permission_classes = []
queryset = USER.objects.prefetch_related(
'guardian_profile', 'junior_profile')
def get_queryset(self):
if self.request.query_params.get('user_type') == dict(USER_TYPE).get('2'):
return self.queryset.filter(junior_profile__isnull=True)
elif self.request.query_params.get('user_type') == dict(USER_TYPE).get('1'):
return self.queryset.filter(guardian_profile__isnull=True)
else:
return self.queryset
def list(self, request, *args, **kwargs):
"""
api method to list all the user
:param request:
:return:
"""
queryset = self.get_queryset()
serializer = self.serializer_class(queryset, many=True)
return custom_response(None, data=serializer.data)