def register(request):
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = RegistrationForm(request.POST)
# check whether it's valid:
if form.is_valid():
# x = form.save()
print(form.cleaned_data)
# {'username': '******', 'password': '******'}
password = form.cleaned_data.get('password')
token = encrypt(password, 5)
form.cleaned_data['password'] = token
print(decrypt(token, 26 - 5))
print(form.cleaned_data)
tutorial_serializer = UserSerializer(data=form.cleaned_data)
if tutorial_serializer.is_valid():
tutorial_serializer.save()
username = form.cleaned_data.get('username')
#messages.success(request, "New account created: ",username)
#login(request, tutorial_serializer)
#return redirect("main:homepage")
# process the data in form.cleaned_data as required
# ...
# redirect to a new URL:
response = {"status": "Account Created"}
return render(request=request,
template_name="main/home.html",
context={"response": response})
# if a GET (or any other method) we'll create a blank form
else:
form = RegistrationForm
return render(request=request,
template_name="main/register.html",
context={"form": form})
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(serializer.errors,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def retrieve(self, request, pk, *args, **kwargs):
i = self.serializer_class(get_object_or_404(Achievement, id=pk)).data
u = User.objects.get(id=i['addedBy'])
i['addedBy'] = UserSerializer(u).data
# i['addedBy'] = ProfileSerializer(Profile.objects.get(user=u)).data
if i['approvedBy']:
i['approvedBy'] = StaffSerializer(
Staff.objects.get(id=i['approvedBy'])).data
if i['institution']:
i['institution'] = InstitutionSerializer(
Institution.objects.get(id=i['institution'])).data
if i['tags']:
i['tags'] = TagSerializer(Tag.objects.filter(id__in=i['tags']),
many=True).data
if i['mentors']:
i['mentors'] = StaffSerializer(
Staff.objects.filter(id__in=i['mentors']), many=True).data
if i['teamMembers']:
i['teamMembers'] = UserSerializer(
User.objects.filter(id__in=i['teamMembers']), many=True).data
return JsonResponse(i)
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 get_achievements_json_format(user):
achievements = AchievementSerializer(Achievement.objects.filter(addedBy = user)\
.prefetch_related('tags', 'mentors', 'teamMembers')\
.select_related('addedBy', 'approvedBy', 'institution'), many = True).data
for i in achievements:
u = User.objects.get(id=i['addedBy'])
i['addedBy'] = UserSerializer(u).data
if i['approvedBy']:
i['approvedBy'] = StaffSerializer(
Staff.objects.get(id=i['approvedBy'])).data
if i['institution']:
i['institution'] = InstitutionSerializer(
Institution.objects.get(id=i['institution'])).data
if i['tags']:
i['tags'] = TagSerializer(Tag.objects.filter(id__in=i['tags']),
many=True).data
if i['mentors']:
i['mentors'] = StaffSerializer(
Staff.objects.filter(id__in=i['mentors']), many=True).data
if i['teamMembers']:
i['teamMembers'] = UserSerializer(
User.objects.filter(id__in=i['teamMembers']), many=True).data
return achievements
def put(self, request, pk, format=None):
user = self.get_object(pk=pk)
serializer = UserSerializer(user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response({"msg": "success"})
return Response({"msg": "error"})
def post(self, request, format=None):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def register(request):
if request.method == 'POST':
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user:
return Response(serializer.data,
status=status.HTTP_201_CREATED)
def post(self, request, format='json'):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user:
token = Token.objects.create(user=user)
json = serializer.data
json['token'] = token.key
return Response(json, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, id=None):
user = User.objects.filter(id=id).last()
if request.user.is_superuser or request.user == user:
serializer = UserSerializer(user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=400)
return Response(
{'result': 'You are not authorized to see the result.'},
status=401)
def fetch_user(username):
user = User.objects.get_by_natural_key(username)
# serializer = CustomersSerializer(account.customers).data
# serializer.pop("username")
# user = dict()
# user["first_name"] = account.first_name
# user["last_name"] = account.last_name
# user["email"] = account.email
# user["account info"] = serializer
user_serializer = UserSerializer(data=UserSerializer(user))
return user_serializer
def register(request):
if request.method != 'POST':
return HttpResponse(status=405)
data = JSONParser().parse(request)
data['registerDate'] = datetime.datetime.now().date()
data['password_hash'] = encode_password(data.get('password', ''))
del data['password']
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return HttpResponse(status=201)
return JsonResponse(serializer.errors, status=400)
def create(self, request):
"""
User registration.
POST /users
"""
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(
serializer.errors,
status=status.HTTP_400_BAD_REQUEST,
)
class EmployeeSerializer(serializers.ModelSerializer):
"""
Employee model serializer
"""
user = UserSerializer()
added_by = UserSerializer()
company_name = CompanySerializer()
class Meta:
model = Employee
fields = [
'url', 'id', 'user', 'company_name', 'alternate_contact_no',
'alternate_email', 'job_title', 'street', 'zip_code', 'city',
'country', 'added_by', 'registration_date'
]
def post(self, request, format=None):
requestbody = request.body.decode('utf-8')
body = json.loads(requestbody)
email = body['email']
password = body['password']
account = authenticate(email=email, password=password)
if account is not None:
if account.is_active:
login(request, account)
serialized = UserSerializer(account)
return Response(serialized.data)
else:
return Response({
'status': 'Unauthorized',
'message': 'This account has been disabled.'
}, status=status.HTTP_401_UNAUTHORIZED)
else:
return Response({
'status': 'Unauthorized',
'message': 'Username/password combination invalid.'
}, status=status.HTTP_401_UNAUTHORIZED)
def current_user(request):
"""
Determine the current user by their token, and return their data
"""
serializer = UserSerializer(request.user)
return Response(serializer.data)
def createDefaultProfileForAllUsers(request):
jsonResult = {}
if request.user.is_superuser:
users = User.objects.filter(profile=None)
jsonResult["updatedUsers"] = UserSerializer(users,
many=True,
context={
'request': request
}).data
for user in users:
profile = Profile.objects.create(user=user,
fullname=user.username,
bio="",
website="")
user.profile = profile
user.save()
jsonResult["message"] = "Users got default profile."
# SETTINGS FULLNAME FOR USERS WHO DON'T HAVE IT
profiles = Profile.objects.filter(Q(fullname=None) | Q(fullname=""))
for profile in profiles:
profile.fullname = profile.user.username
profile.save()
return JsonResponse(jsonResult)
class ProjectUserSerializer(serializers.ModelSerializer):
user = UserSerializer(many=False, read_only=True)
project = ProjectSerializer(many=False, read_only=True)
class Meta:
model = models.ProjectUser
fields = ('pk', 'user', 'project', 'joining_date', 'role', 'is_active')
def get(self, request, country_id):
print("QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ")
people = User.objects.filter(country_id=country_id)
# print(people.get(0))
serializer = UserSerializer(people, many=True)
print(serializer.data)
return Response(serializer.data)
def my_jwt_response_handler(token, user=None, request=None):
return {
'token': token,
'user': UserSerializer(user, context={
'request': request
}).data
}
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
if serializer.validated_data[
'encrypted_password'] == serializer.validated_data[
'smtp_password']:
serializer.validated_data.pop('smtp_password', None)
user = serializer.save()
user.set_password(
serializer.validated_data['encrypted_password'])
user.save()
return Response(serializer.data, status=201)
else:
return Response({'result': 'Both password should match.'})
return Response(serializer.errors, status=400)
def user_detail(request, pk):
"""
Retrieve, update or delete user
You can only change fields 'exp' and 'stage'
:param request: request
:param pk: User's id in db
:return: Response
"""
try:
snippet = User.objects.get(pk=pk)
except User.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = UserSerializer(snippet)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = UserSerializer(snippet, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
snippet.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
class ArticleSerializer(serializers.ModelSerializer):
url = serializers.CharField(source='get_absolute_url')
author = UserSerializer()
category = CategorySerializer()
comments_count = serializers.IntegerField()
class Meta:
model = Article
fields = ('id', 'title', 'url', 'author', 'category', 'created', 'updated', 'comments_count')
def post(self, request):
"""Handle the posting of data."""
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
response = {"code": SUCCESS_CODE,
"id": user.id,
"email": serializer.validated_data["email"],
}
return Response(response, status=status.HTTP_201_CREATED)
response = {"code": ERROR_CODE,
"errors": serializer.errors
}
return Response(response, status=status.HTTP_400_BAD_REQUEST)
def getSuperUsers(request):
jsonResult = {}
if request.user.is_superuser:
users = User.objects.filter(is_superuser=True)
jsonResult["users"] = UserSerializer(users,
many=True,
context={
'request': request
}).data
return JsonResponse(jsonResult)
def get_user_info_by_email(self, request):
data = request.data
email = data.get('email')
user = User.objects.filter(email=email)
serializer = UserSerializer(user, many=True)
return JsonResponse(serializer.data[0])
def get(self, request, pk, format=None):
try:
theorem_statement = TheoremStatement.objects.filter(
owner=request.user).get(pk=pk)
except TheoremStatement.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
users_in = User.objects.filter(
prooffortheoremuser__theorem_statement=theorem_statement)
users = User.objects.all().difference(users_in)
serializer = UserSerializer(users, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
def login(request):
if request.method != 'POST':
return HttpResponse(status=405)
data = JSONParser().parse(request)
try:
password_hash = encode_password(data.get('password', ''))
obj = User.objects.get(username=data.get('username', ''),
password_hash=password_hash)
except User.DoesNotExist:
return HttpResponse(status=401)
payload = UserSerializer(obj).data
payload = {
key: value
for key, value in payload.items() if key in {'username'}
}
token = encode_jwt(payload)
response = HttpResponse(status=200)
response['Authorization'] = 'Bearer {}'.format(token)
return response
def get_user_detail(username):
try:
obj = User.objects.get(username=username)
except User.DoesNotExist:
return HttpResponse(status=404)
serializer = UserSerializer(obj)
data = serializer.data
del data['password_hash']
data['age'] = relativedelta(datetime.datetime.now(),
dateutil.parser.parse(data['birthDate'])).years
return JsonResponse(data)
