def patch(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 == True:
idea = Idea.objects.get(id=request.data.get('id', None))
repo_link = request.data.get('repo_link', None)
if repo_link == None or repo_link == "":
return Response({"message": "Github Repository Link required"},
status=status.HTTP_400_BAD_REQUEST)
idea.repo_link = repo_link
idea.is_completed = True
idea.save()
idea_serializer = IdeaSerializer(idea)
return Response(
{
"message": "Idea successfully marked as completed",
"Idea": idea_serializer.data
},
status=status.HTTP_200_OK)
else:
return Response({"message": "Not an Admin"},
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)
req_data = request.data
keys = {"PENDING": 0, "PUBLISHED": 1, "REJECTED": 2}
if user.is_superuser == True:
try:
idea = Idea.objects.get(id=req_data['idea_id'])
idea.is_reviewed = req_data['is_reviewed']
idea.reviewer_id = user
idea.save()
serializer = IdeaSerializer(idea)
return Response(
{
"message": "Idea reviewed successfully",
"idea": serializer.data
},
status=status.HTTP_200_OK)
except:
return Response({"message": "Invalid Idea Id"},
status=status.HTTP_400_BAD_REQUEST)
else:
return Response({"message": "Only Admin can Access"},
status=status.HTTP_403_FORBIDDEN)
def get(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)
date = request.query_params.get("date", None)
if date == None or date == "":
return Response({"message": "Date missing"},
status=status.HTTP_400_BAD_REQUEST)
date = date.split('-')
day = int(date[0])
month = int(date[1])
year = int(date[2])
questions = Question.objects.filter(
date_time__date=datetime.date(year, month, day))
serializer = QuestionSerializer(questions, many=True)
if len(serializer.data) == 0:
return Response({"message": "No Question Found"},
status=status.HTTP_204_NO_CONTENT)
return Response({"message": serializer.data},
status=status.HTTP_200_OK)
def get(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 == True:
answers = Answer.objects.filter(evaluated=False)
if len(answers) == 0:
return Response({"message": "No Answers Found"},
status=status.HTTP_204_NO_CONTENT)
response = []
for answer in answers:
user = answer.user_id
serializer = AnswerSerializer(answer)
serializer = serializer.data
serializer['username'] = user.username
response.append(serializer)
return Response({"message": response}, status=status.HTTP_200_OK)
else:
return Response({"message": "Not an Admin"},
status=status.HTTP_403_FORBIDDEN)
def get(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)
req_data = request.data
if user.is_superuser == True:
objects = SocialMediaDetails.objects.all()
serializers = SocialMediaDetailsSerializer(objects, many=True)
return Response(
{
"message": "Social Media Details",
"Details": serializers.data
},
status=status.HTTP_200_OK)
else:
return Response({"message": "Not an Admin"},
status=status.HTTP_403_FORBIDDEN)
def get(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)
offset = request.query_params.get('offset', None)
if offset != None and offset != "":
offset = int(offset)
start = offset * 5
end = (offset + 1) * 5
req_data = request.data
keys = {"PENDING": 0, "PUBLISHED": 1, "REJECTED": 2}
if user.is_superuser == True:
ideas = list(
Idea.objects.filter(is_reviewed=keys['REJECTED'],
is_deleted=False))
serializer = IdeaSerializer(ideas, many=True)
if offset == None or offset == "":
serializer_data = serializer.data
else:
serializer_data = serializer.data[start:end]
if len(serializer_data) == 0:
return Response({"message": "No Idea Found"},
status=status.HTTP_204_NO_CONTENT)
for idea in serializer_data:
user = User.objects.get(id=idea['user_id'])
idea['username'] = user.username
return Response({"message": serializer_data},
status=status.HTTP_200_OK)
else:
return Response({"message": "Not an Admin"},
status=status.HTTP_403_FORBIDDEN)
def get(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)
questions = Question.objects.all()
if len(questions) == 0:
return Response({"message": "No Questions Found"},
status=status.HTTP_204_NO_CONTENT)
serializer = QuestionSerializer(questions, many=True)
return Response({"message": serializer.data},
status=status.HTTP_200_OK)
def get(self, request, pk):
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)
try:
question = Question.objects.get(id=pk)
serializer = QuestionSerializer(question)
return Response({"message": serializer.data},
status=status.HTTP_200_OK)
except Question.DoesNotExist:
return Response({"message": "Questions Does Not Exist"},
status=status.HTTP_400_BAD_REQUEST)
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 == True:
req_data = request.data
try:
answer = Answer.objects.get(id=req_data['answer_id'])
if answer.evaluated == True:
return Response({"message": "Answer Already Evaluated"},
status=status.HTTP_400_BAD_REQUEST)
marks = req_data.get("marks", None)
if marks == None or marks == "":
return Response({"message": "Please provide marks"},
status=status.HTTP_400_BAD_REQUEST)
answer.marks = marks
answer.evaluated = True
answer.save()
serializer = AnswerSerializer(answer)
return Response(
{
"message": "Marks Saved",
"Answer": serializer.data
},
status=status.HTTP_200_OK)
except Answer.DoesNotExist:
return Response({"message": "ANswer Does Not Exist"},
status=status.HTTP_400_BAD_REQUEST)
else:
return Response({"message": "Not an Admin"},
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 == True:
serializer = QuestionSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response({"message": serializer.data},
status=status.HTTP_200_OK)
else:
return Response({"message": "Invalid Question"},
status=status.HTTP_400_BAD_REQUEST)
else:
return Response({"message": "Not an Admin"},
status=status.HTTP_403_FORBIDDEN)
def get(self, request, format=None):
# Get User and delete the token
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)
response = {
"message": "Admin logged out",
"Details": {
"id": user.id,
"email": user.email
}
}
usertoken = UserToken.objects.get(user=user.id)
usertoken.delete()
return Response(response, status=status.HTTP_200_OK)
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 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)
req_data = {}
req_data['answer_body'] = request.data.get("answer_body", None)
req_data['answer_type'] = request.data.get("answer_type", None)
req_data['daily_challenge'] = request.data.get("daily_challenge", None)
req_data['weekly_challenge'] = request.data.get(
"weekly_challenge", None)
req_data['user_id'] = user.id
print(req_data['answer_body'])
print(req_data['answer_type'])
print(req_data['daily_challenge'])
print(req_data['weekly_challenge'])
print(req_data['user_id'])
if req_data['daily_challenge'] and req_data['weekly_challenge']:
print("Both are None")
return Response({"message": "Invlaid Answer"},
status=status.HTTP_400_BAD_REQUEST)
if req_data['daily_challenge'] != None:
answer = Answer.objects.filter(
Q(user_id=user.id)
& Q(daily_challenge=req_data['daily_challenge']))
else:
answer = Answer.objects.filter(
Q(user_id=user.id)
& Q(weekly_challenge=req_data['weekly_challenge']))
trial = AnswerSerializer(answer, many=True)
print(trial.data)
if len(answer) != 0:
answer = answer[0]
if answer.answer_type == 1 and req_data[
'answer_body'] != None and answer.evaluated == False:
temp = req_data['answer_body'].split(",")
empty = True
for link in temp:
if link != "" and link != " ":
empty = False
if empty:
return Response({"message": "Please enter answer"},
status=status.HTTP_400_BAD_REQUEST)
answer.answer_body = req_data['answer_body']
answer.save()
serializer = AnswerSerializer(answer)
return Response(
{
"message": "Answer saved",
"Answer": serializer.data
},
status=status.HTTP_200_OK)
else:
print("Already Answered")
return Response({"message": "Already Answered"},
status=status.HTTP_400_BAD_REQUEST)
serializer = AnswerSerializer(data=req_data)
if serializer.is_valid():
serializer.save()
return Response(
{
"message": "Answer Saved",
"Answer": serializer.data
},
status=status.HTTP_200_OK)
else:
print(serializer.errors)
return Response({"message": "Invalid Answer"},
status=status.HTTP_400_BAD_REQUEST)
