def init_users(self, request, pk=None):
url = request.data['url']
print(url)
print(":next")
response = urllib.request.urlopen(url)
reader = csv.DictReader(response.read().decode('utf-8').splitlines())
header = ["name", "roll_number", "status", "card_no", "image_url"]
if request.data['mode'] == 'create':
for each in reader:
print(each)
row = {}
for field in header:
row[field] = each[field]
serializer = UserSerializer(data=row)
if serializer.is_valid():
serializer.save()
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.data['mode'] == 'update':
for each in reader:
print(each)
row = {}
user = User.objects.get(pk=each["roll_number"])
for field in header:
row[field] = each[field]
serializer = UserSerializer(user, data=row)
if serializer.is_valid():
serializer.save()
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
return Response(data=None, status=status.HTTP_201_CREATED)
def post(self,request,format=None):
postData=request.data
postData['is_active']=False
postData['profile']['validatedcode']= self.get_validationcode()
serializer=UserSerializer(data=postData)
if serializer.is_valid() :
serializer.save()
## send email
pending_message="Hello %s,\n\nThank you for your registration.\n Your account is pendinng. We will review and activate in a due course and send you a notification then.\nRegards,\nSite admin\n\n" % (serializer.data['first_name'],)
send_mail("Pending account",pending_message,"*****@*****.**",[serializer.data['email']], fail_silently=True)
url="http://%s/accounts/validate" % (request.get_host,)
pending_message="Hello %s,\n\nA new account as been added. Please reivew and activate it by clicking on the below url:\n%s\n\nSite admin\n\n" % ('Admin',url,)
mail_admins("Pending account",pending_message, fail_silently=True)
return Response(serializer.data)
error =ResponseRes.get_serializer_error(serializer.errors)
return Response({
'status': 'Failed',
'message': 'This account could not be created. Reason:' + error})
def put(self, request, user_id):
user = self.get_object(user_id)
serializer = UserSerializer(instance = user, data = request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response({"error": serializer.errors})
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response({"error": serializer.errors},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def post(self, request):
user = request.data.dict()
hash_pwd = make_password(user['password'])
user['password'] = hash_pwd
serializer = UserSerializer(data=user)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def post(self, req, id):
owner_id = checkCredentials(req)
if not owner_id:
return add_access_headers(
HttpResponse(
json.dumps({
'status': 'err',
'msg': 'User NOT logged in!'
}),
content_type="application/json",
))
user = None
try:
user = User.objects.get(pk=id)
except:
return add_access_headers(
HttpResponse(
json.dumps({
'status': 'err',
'msg': 'User CANNOT be updated!'
}),
content_type="application/json",
))
if user.role != 'admin':
return add_access_headers(
HttpResponse(
json.dumps({
'status':
'err',
'msg':
'Not sufficient rights for this operation!'
}),
content_type="application/json",
))
data = req.data.copy()
data['password'] = user.password
serializer = UserSerializer(user, data=data)
if not serializer.is_valid():
return add_access_headers(
HttpResponse(
json.dumps({
'status': 'err',
'msg': 'User CANNOT be updated!'
}),
content_type="application/json",
))
serializer.save()
return add_access_headers(
HttpResponse(
json.dumps({'status': 'ok'}),
content_type="application/json",
))
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response({
'status': 'successs',
'message': 'user created successfully'
})
return Response({'status': 'errors', 'message': serializer.errors})
def post(self, request):
secret_key = os.getenv("GOOGLE_RECAPTCHA_SECRET")
data = {
'secret': secret_key,
'response': request.data.get('g-recaptcha-response', None)
}
resp = requests.post('https://www.google.com/recaptcha/api/siteverify',
data=data)
print(resp.json())
if not resp.json().get('success'):
return Response(data={'error': 'ReCAPTCHA not verified.'},
status=status.HTTP_406_NOT_ACCEPTABLE)
user_data = {}
user_data['email'] = request.data.get("email", None)
user_data['username'] = request.data.get("username", None)
user_data['platform'] = request.data.get("platform", 0)
user_data['password'] = request.data.get("password", None)
if len(user_data['password']) < 6:
return Response({"Invalid Password"},
status=status.HTTP_400_BAD_REQUEST)
serializer = UserSerializer(data=user_data)
if serializer.is_valid():
serializer.save()
user = User.objects.filter(
Q(username__iexact=user_data['username'])
& Q(email=user_data['email']))
user = user[0]
token = get_token({
"username": user.username,
"platform": user.platform,
"date_time": str(datetime.datetime.today())
})
user_data['token'] = token
del user_data['password']
try:
usertoken = UserToken.objects.get(user=user.id)
return Response({"message": "User Already Logged in"},
status=status.HTTP_400_BAD_REQUEST)
except UserToken.DoesNotExist:
UserToken.objects.create(token=token, user=user)
return Response(
{
"message": "User Signed up successfully",
"User": user_data
},
status=status.HTTP_201_CREATED)
else:
return Response({"message": serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
def update(self, request, pk=None):
try:
item = User.objects.get(pk=pk)
except User.DoesNotExist:
return Response(status=404)
serializer = UserSerializer(item, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=400)
def post(self, request, *args, **kwargs):
if not request.data:
raise ValidationError('You must provide arguments for create.')
if not isinstance(request.data, list):
raise ValidationError('You must provide a list of objects.')
serializer = UserSerializer(data=request.data, many=True)
serializer.is_valid(raise_exception=True)
serializer.save()
return serializer.data
def post(self, request, *args, **kwargs):
if not request.data:
raise ValidationError('You must provide arguments for create.')
if not isinstance(request.data, list):
raise ValidationError('You must provide a list of objects.')
serializer = UserSerializer(data=request.data, many=True)
serializer.is_valid(raise_exception=True)
serializer.save()
return serializer.data
def usuario_lista(request):
"""
Lista (GET) todos los usuarios o crea (POST) un nuevo usuario
:param request:
:return:
"""
# LISTA TODOS LOS USUARIOS
if request.method == 'GET':
try:
lista_json = []
lista_users = Usuario.objects.all()
for user in lista_users:
if user.user.is_active and not user.user.is_staff:
user_json = {
'username': user.user.username,
'first_name': user.user.first_name,
'last_name': user.user.last_name,
'email': user.user.email,
'id': user.id,
'balance': user.balance
}
lista_json.append(user_json)
return Response(lista_json)
except KeyError:
return Response({"message": "Atributos incorrectos"}, status=status.HTTP_400_BAD_REQUEST)
# CREA UN USUARIO
elif request.method == 'POST':
try:
data = JSONParser().parse(request)
# Verifica que los datos no sean vacios
if not data:
return Response({"message": "No se enviaron datos"}, status=status.HTTP_400_BAD_REQUEST)
# ENCRIPTA EL PASSWORD
data['password'] = make_password(data['password'])
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return Response({
'username': serializer.data['username'],
'first_name': serializer.data['first_name'],
'last_name': serializer.data['last_name'],
'email': serializer.data['email']
}, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
except KeyError:
return Response({"message": "Atributos incorrectos"}, status=status.HTTP_400_BAD_REQUEST)
except IntegrityError:
return Response({"message": "Atributos duplicados"}, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, id, *args, **kwargs):
if not request.data:
raise ValidationError('You must provide an updated instance.')
session = settings.SQLALCHEMY_SESSION()
instance = session.query(User).filter(User.id == id).first()
if not instance:
raise ValidationError('Object does not exist')
serializer = UserSerializer(instance, data=request.data, partial=True)
serializer.is_valid(raise_exception=True)
serializer.save()
return serializer.data
def UserList(request):
if request.method == "GET":
users = User.objects.all()
serializer = UserSerializer(users, many=True)
return JsonResponse(serializer.data, safe=False)
elif request.method == "POST":
data = JSONParser().parse(request)
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def put(self, request, id, *args, **kwargs):
if not request.data:
raise ValidationError('You must provide an updated instance.')
session = settings.SQLALCHEMY_SESSION()
instance = session.query(User).filter(User.id == id).first()
if not instance:
raise ValidationError('Object does not exist')
serializer = UserSerializer(instance, data=request.data, partial=True)
serializer.is_valid(raise_exception=True)
serializer.save()
data = serializer.data
session.close()
return data
def post(self, request, format=None):
"""
회원가입
---
parameters:
- username: string (필수)
- email: email (필수)
- password: string (필수)
- department: string
- enterYear: integer
- github: string
"""
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
subject = 'UniDev 인증 메일입니다.'
message = render_to_string(
'user_activate.html', {
'user':
user,
'domain':
get_current_site(request).domain,
'uid':
urlsafe_base64_encode(force_bytes(
user.pk)).decode('utf-8'),
'token':
account_activation_token.make_token(user),
})
email = EmailMessage(subject, message, to=[user.email])
email.send()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self,request):
postData=request.data
user = User.objects.get(pk=postData['id'])
serializer = UserSerializer(user,data=postData)
if serializer.is_valid():
serializer.save()
res=ResponseRes.get_serializer_res(serializer,'Profile has been updated successfully')
return Response(res)
return Response({'status': 'Modify error',
'message':'Profile could not be modified. Reason:' + ResponseRes.get_serializer_error(serializer.errors)},
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format='json'):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user:
return Response(serializer.data,
status=status.HTTP_201_CREATED)
def setup_user(request):
try:
if request.method == 'POST':
data = JSONParser().parse(request)
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
inventory = app.models.inventory(
user_id=app.models.user.objects.get(
id=serializer["id"].value))
inventory.save()
return HttpResponse(JSONRenderer().render(serializer.data),
status=201)
else:
return HttpResponse(serializer.errors, status=404)
except Exception as e:
return HttpResponse(e, status=400)
def post(self, request, *args, **kwargs):
if not request.user.is_authenticated:
return JsonResponse({'Status': False, 'Error': 'Log in required'}, status=403)
if 'password' in request.data:
try:
validate_password(request.data['password'])
except Exception as password_error:
error_array = []
for item in password_error:
error_array.append(item)
return JsonResponse({'Status': False, 'Errors': {'password': error_array}})
else:
request.user.set_password(request.data['password'])
user_serializer = UserSerializer(request.user, data=request.data, partial=True)
if user_serializer.is_valid():
user_serializer.save()
return JsonResponse({'Status': True})
else:
return JsonResponse({'Status': False, 'Errors': user_serializer.errors})
def post(self, req):
data = req.data.copy()
if 'password' in data:
bytes = bcrypt.hashpw(data['password'].encode(), bcrypt.gensalt())
data['password'] = bytes.decode()
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return add_access_headers(
HttpResponse(
json.dumps({'status': 'ok'}),
content_type="application/json",
))
else:
return add_access_headers(
HttpResponse(
json.dumps({'status': 'not_ok'}),
content_type="application/json",
))
def post(self, request, format="json"):
try:
serializer = UserSerializer(data=request.data)
if serializer.is_valid(raise_exception=True):
user = serializer.save()
if user:
token = Token.objects.create(user=user)
response = serializer.data
response["token"] = token.key
return Response(response, status=status.HTTP_201_CREATED)
except IntegrityError as e:
raise serializers.ValidationError()
def post(self, request):
req_data = {}
req_data['email'] = request.data.get("email", None)
req_data['username'] = request.data.get("username", None)
req_data['platform'] = request.data.get("platform", 0)
req_data['password'] = request.data.get("password", None)
req_data['is_superuser'] = True
# Hardcoded the password and email address
if (req_data.get('password', None) == os.getenv('ADMIN_PASSWORD') and
req_data.get('username', None) == os.getenv('ADMIN_USERNAME')
and req_data.get('email',
None) == os.getenv('ADMIN_EMAIL_ID')):
try:
# Checking if Admin already signed up
user = User.objects.get(username=req_data['username'],
email=req_data['email'])
return Response({"message": "Admin already signed Up"},
status=status.HTTP_400_BAD_REQUEST)
except User.DoesNotExist:
# Creating superuser (Admin)
print(req_data)
serializer = UserSerializer(data=req_data)
if serializer.is_valid():
serializer.save()
user = User.objects.get(username=req_data['username'],
email=req_data['email'])
user.is_superuser = True
user.password = req_data['password']
user.save()
return Response({"message": "Admin signed up"},
status=status.HTTP_200_OK)
else:
return Response({"message": "Invalid Data"},
status=status.HTTP_400_BAD_REQUEST)
else:
return Response({"message": "Invalid Email and Password"},
status=status.HTTP_400_BAD_REQUEST)
def User1(request): #for accesing users and registering new users
if request.method == "GET":
id = request.session['user_id']
user = User.objects.get(id=id)
if user is not None:
if user.type == "SuperAdmin":
users = User.objects.filter(type="Man") | User.objects.filter(
type="Admin")
elif user.type == "Admin":
users = User.objects.filter(type="Man")
elif user.type == "Man":
serializer = UserSerializer(user)
return JsonResponse(serializer.data, safe=False)
serializer = UserSerializer(users, many=True)
return JsonResponse(serializer.data, safe=False)
# return HttpResponse(user.username)
return HttpResponse("No such user")
if request.method == "POST":
id = request.session['user_id']
user = User.objects.get(id=id)
if user is not None:
data = JSONParser().parse(request)
user_type = data["type"]
serializer = UserSerializer(data=data)
if user.type == "SuperAdmin":
if serializer.is_valid():
serializer.save()
return redirect('/user1')
elif user.type == "Admin":
if user_type == "Man":
if serializer.is_valid():
serializer.save()
return redirect('/user1')
return HttpResponse("Forbidden Operation")
def post(self, request):
"""Register new user and create user profile"""
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
profile = Profile.objects.create(user=user,
fname=user.first_name,
lname=user.last_name)
profile.save()
location = Location.objects.create(profile=profile)
location.save()
if user:
json = serializer.data
return Response(json, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def register(request):
user_serializer = UserSerializer(data=request.data)
if user_serializer.is_valid():
user = user_serializer.save()
request.data['user_id'] = user.id
else:
return Response(user_serializer.errors, status=HTTP_400_BAD_REQUEST)
client_serializer = ClientSerializer(data=request.data)
data = {}
if client_serializer.is_valid():
client = client_serializer.save()
data['response'] = 'successfully registered a new client'
data['token'] = Token.objects.get(user=client.user).key
else:
return Response(client_serializer.errors, status=HTTP_400_BAD_REQUEST)
return Response(data)
def signup(request):
try:
User.objects.get(username=request.data.get("username"))
return Response({'msg':"Username taken."}, status=status.HTTP_400_BAD_REQUEST)
except User.DoesNotExist:
pass
usertype = request.data.get("usertype")
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user_instance = serializer.save()
if usertype != 'seeker' and usertype != 'provider':
return Response(status=status.HTTP_400_BAD_REQUEST)
user_instance.profile.usertype = usertype
user_instance.profile.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def signup(request):
try:
User.objects.get(username=request.data.get("username"))
return Response({'msg': "Username taken."},
status=status.HTTP_400_BAD_REQUEST)
except User.DoesNotExist:
pass
usertype = request.data.get("usertype")
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user_instance = serializer.save()
if usertype != 'seeker' and usertype != 'provider':
return Response(status=status.HTTP_400_BAD_REQUEST)
user_instance.profile.usertype = usertype
user_instance.profile.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
if {'first_name', 'last_name', 'email', 'password', 'company', 'position', 'type'}.issubset(request.data):
try:
validate_password(request.data['password'])
except Exception as password_error:
error_array = []
for item in password_error:
error_array.append(item)
return JsonResponse({'Status': False, 'Errors': {'password': error_array}})
else:
request.data._mutable = True
request.data.update({})
user_serializer = UserSerializer(data=request.data)
if user_serializer.is_valid():
user = user_serializer.save()
user.set_password(request.data['password'])
user.save()
new_user_registered_signal.delay(user_id=user.id)
return JsonResponse({'Status': True})
else:
return JsonResponse({'Status': False, 'Errors': user_serializer.errors})
return JsonResponse({'Status': False, 'Errors': 'Не указаны все необходимые аргументы'})
def register(request):
serializer = UserSerializer(data=request.data)
data = {}
st = None
if serializer.is_valid():
user = serializer.save()
st = status.HTTP_201_CREATED
request.data['user'] = user.id
client = ClientSerializer(data=request.data)
if client.is_valid():
client.save()
data['response'] = 'succesfully registered a new user'
st = status.HTTP_201_CREATED
else:
data = serializer.errors
st = status.HTTP_400_BAD_REQUEST
else:
data = serializer.errors
st = status.HTTP_400_BAD_REQUEST
return Response(data, status=st)
def post(self, request, *args, **kwargs):
serializer = UserSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return serializer.data
def usuario_lista(request):
"""
Lista (GET) todos los usuarios o crea (POST) un nuevo usuario
:param request:
:return:
"""
# LISTA TODOS LOS USUARIOS
if request.method == 'GET':
try:
lista_json = []
lista_users = Usuario.objects.all()
for user in lista_users:
if user.user.is_active and not user.user.is_staff:
user_json = {
'username': user.user.username,
'first_name': user.user.first_name,
'last_name': user.user.last_name,
'email': user.user.email,
'id': user.id,
'balance': user.balance
}
lista_json.append(user_json)
return Response(lista_json)
except KeyError:
return Response({"message": "Atributos incorrectos"},
status=status.HTTP_400_BAD_REQUEST)
# CREA UN USUARIO
elif request.method == 'POST':
try:
data = JSONParser().parse(request)
# Verifica que los datos no sean vacios
if not data:
return Response({"message": "No se enviaron datos"},
status=status.HTTP_400_BAD_REQUEST)
# ENCRIPTA EL PASSWORD
data['password'] = make_password(data['password'])
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return Response(
{
'username': serializer.data['username'],
'first_name': serializer.data['first_name'],
'last_name': serializer.data['last_name'],
'email': serializer.data['email']
},
status=status.HTTP_201_CREATED)
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
except KeyError:
return Response({"message": "Atributos incorrectos"},
status=status.HTTP_400_BAD_REQUEST)
except IntegrityError:
return Response({"message": "Atributos duplicados"},
status=status.HTTP_400_BAD_REQUEST)
def usuario_datos(request, id_user):
"""
Obtiene (GET), modifica (PUT) o borra (DELETE) un usuario
:param request:
:param id_user: el id del usuario que se quiere obtener, borrar o modificar
:return:
"""
if id_user.isdigit():
usuario = get_object_or_404(User, pk=int(id_user))
else:
usuario = get_object_or_404(User, username=id_user)
usuario = get_object_or_404(Usuario, user_id=usuario.id)
# VERIFICA QUE EL USUARIO ESTE ACCEDIENDO A SUS DATOS Y NO A LOS DE OTRO
if not request.user.is_staff:
if request.user.id != usuario.user_id:
return Response({"message": "No tiene permisos para acceder"}, status=status.HTTP_401_UNAUTHORIZED)
# OBTIENE UN USUARIO
if request.method == 'GET':
return Response({
'username': usuario.user.username,
'first_name': usuario.user.first_name,
'last_name': usuario.user.last_name,
'email': usuario.user.email,
'id': usuario.id,
'balance': usuario.balance
})
# ACTUALIZA LOS DATOS DE UN USUARIO VALIDANDO LOS CAMPOS INGRESADOS
elif request.method == 'PUT':
try:
data = JSONParser().parse(request)
# ENCRIPTA EL PASSWORD
if 'password' in data:
data['password'] = make_password(data['password'])
serializer = UserSerializer(usuario, data=data)
if serializer.is_valid(raise_exception=True):
serializer.save()
return Response({
'username': serializer.data['username'],
'first_name': serializer.data['first_name'],
'last_name': serializer.data['last_name'],
'email': serializer.data['email']
})
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
except KeyError:
return Response({"message": "Atributos incorrectos"}, status=status.HTTP_400_BAD_REQUEST)
except IntegrityError:
return Response({"message": "Atributos duplicados"}, status=status.HTTP_400_BAD_REQUEST)
# BORRA UN USUARIO
elif request.method == 'DELETE':
if usuario.validar_delete():
usuario.user.delete()
usuario.delete()
return Response({"message": "El usuario ha sido borrado"}, status=status.HTTP_204_NO_CONTENT)
return Response({"message": "No puede borrar"}, status=status.HTTP_400_BAD_REQUEST)
def add_users(request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response('successfully added', status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs):
serializer = UserSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return serializer.data
def post(self, request):
secret_key = os.getenv("GOOGLE_RECAPTCHA_SECRET")
data = {
'secret': secret_key,
'response': request.data.get('g-recaptcha-response', None)
}
resp = requests.post('https://www.google.com/recaptcha/api/siteverify',
data=data)
if not resp.json().get('success'):
return Response(data={'error': 'ReCAPTCHA not verified.'},
status=status.HTTP_406_NOT_ACCEPTABLE)
req_data = request.data
if req_data.get("platform", None) == None:
req_data['platform'] = 0
print("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&")
print(req_data)
print("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$")
user = User.objects.filter(
Q(username=req_data.get('username', None))
& Q(email=req_data.get('email', None)))
trial = UserSerializer(user, many=True)
print(trial.data)
if len(user) == 0:
print("creating new user")
serializer = UserSerializer(data=req_data)
if serializer.is_valid():
print("Everythong is valid")
serializer.save()
user = User.objects.filter(
Q(username__iexact=req_data['username'])
& Q(email=req_data.get('email', None)))
user = user[0]
token = get_token({
"username": user.username,
"platform": user.platform,
"date_time": str(datetime.datetime.today()),
"email": user.email
})
req_data['email'] = user.email
req_data['token'] = token
try:
usertoken = UserToken.objects.get(user=user.id)
social_media_details(user,
req_data.get('platform_name', None),
req_data.get('social_user_id', None))
return Response(
{
"message": "User Already Logged in",
"User": {
"id": user.id,
"username": user.username,
"platform": user.platform,
"email": user.email,
"token": usertoken.token
}
},
status=status.HTTP_200_OK)
except UserToken.DoesNotExist:
UserToken.objects.create(token=token, user=user)
social_media_details(user,
req_data.get('platform_name', None),
req_data.get('social_user_id', None))
return Response(
{
"message": "User Signed up successfully",
"User": req_data
},
status=status.HTTP_201_CREATED)
else:
print(serializer.errors)
return Response({"message": serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
else:
print("User already there")
user = user[0]
if req_data.get("password", None) == None:
req_data['password'] = "******"
m = hashlib.md5()
m.update(req_data['password'].encode("utf-8"))
if user.password == str(m.digest()):
print("password is correct")
token = get_token({
"username": user.username,
"platform": user.platform,
"date_time": str(datetime.datetime.today()),
"email": user.email
})
try:
usertoken = UserToken.objects.get(user=user.id)
social_media_details(user,
req_data.get('platform_name', None),
req_data.get('social_user_id', None))
return Response({
"message": "User Logged in",
"User": {
"id": user.id,
"username": user.username,
"platform": user.platform,
"email": user.email,
"token": usertoken.token
}
})
except:
UserToken.objects.create(token=token, user=user)
social_media_details(user,
req_data.get('platform_name', None),
req_data.get('social_user_id', None))
return Response({
"message": "User Logged in",
"User": {
"id": user.id,
"username": user.username,
"platform": user.platform,
"email": user.email,
"token": token
}
})
else:
print("Invalid password")
return Response({"message": "Invalid Password"},
status=status.HTTP_403_FORBIDDEN)
def post(self, request):
token = request.headers.get('Authorization', None)
if token is None or token == "":
return Response({"message": "Authorization credentials missing"},
status=status.HTTP_403_FORBIDDEN)
user = get_user(token)
if user is None:
return Response({"message": "User Already Logged Out"},
status=status.HTTP_403_FORBIDDEN)
if user.is_superuser == False:
return Response({"message": "Not an Admin"},
status=status.HTTP_403_FORBIDDEN)
if 'file' not in request.data:
return Response({"message": "File Missing"},
status=status.HTTP_400_BAD_REQUEST)
file = request.data['file']
extension = file.name.split('.')[-1]
if extension not in ['csv', 'xls', 'xlsx']:
return Response({"message": "Invalid File Format"},
status=status.HTTP_400_BAD_REQUEST)
content = file.read()
records = pyexcel.iget_records(file_type=extension,
file_content=content)
print(
"____________________________________________________________________"
)
for record in records:
##### USERNAME ########
username = record.get('username', None)
if username == "":
print("LOGS: USER -> Username Missing")
continue
##### EMAIL ########
email = record.get('email', None)
if email == "":
email = None
##### ANSWER ########
answer_body = record.get('answer_body', None)
if answer_body == "":
answer_body = None
##### MARKS ########
evaluated = False
marks = record.get('marks', None)
if marks == "":
marks = 0
evaluated = False
else:
marks = int(marks)
evaluated = True
platform = 1
user = User.objects.filter(
Q(username__iexact=username) & Q(email=email))
if len(user) != 0:
##### QUESTION ########
daily_challenge = record.get('daily_challenge', None)
if daily_challenge == "":
print("LOGS: QUESTION -> Question Missing")
continue
try:
question = Question.objects.get(id=daily_challenge)
except Question.DoesNotExist:
print("LOGS: QUESTION -> Question Not Found")
continue
user = user[0]
answer = {
"answer_type": 0,
"answer_body": answer_body,
"daily_challenge": question.id,
"user_id": user.id,
"marks": marks,
"evaluated": evaluated
}
else:
user_data = {
"username": username,
"email": email,
"platform": platform
}
user_serializer = UserSerializer(data=user_data)
if user_serializer.is_valid():
user_serializer.save()
print("LOGS: USER -> New User created username = "******"":
print("LOGS: QUESTION -> Question Missing")
continue
try:
question = Question.objects.get(id=daily_challenge)
except Question.DoesNotExist:
print("LOGS: QUESTION -> Question Not Found")
continue
answer = {
"answer_type": 0,
"answer_body": answer_body,
"daily_challenge": question.id,
"user_id": user.id,
"marks": marks,
"evaluated": evaluated
}
else:
print("LOGS: USER -> Invalid user username = "******"LOGS: ANSWER -> Answer Already Stored for user " +
username)
except:
serializer = AnswerSerializer(data=answer)
if serializer.is_valid():
serializer.save()
new_answer = Answer.objects.get(
user_id=answer['user_id'], daily_challenge=question.id)
new_answer.evaluated = evaluated
new_answer.save()
print("LOGS: ANSWER -> Answer stored for " + username)
else:
print("LOGS: ANSWER -> Invalid Answer of " + username)
print(
"____________________________________________________________________"
)
return Response({"message": "Records saved succesfully"},
status=status.HTTP_200_OK)
def create(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=201)
return Response(serializer.errors, status=400)
