def generateOTP(email, mobileNumbaer):
OTP_list = []
mobileOTP = random.randint(100000, 999999)
account_sid = "AC89c39362b649bb9d1bb3c8e98de26bae"
auth_token = "6fe185b97904d41e6f8729052b178390"
client = Client(account_sid, auth_token)
client.messages.create(to="+91" + str(mobileNumbaer), from_="+12055707697",
body="this is eshopper OTP" + str(mobileOTP))
OTP_list.append(mobileOTP)
emailOTP = str(BaseUserManager().make_random_password(8))
print("loginPassword="******"*****@*****.**"
receiver = email
msg = MIMEMultipart()
msg['From'] = sender
msg['To'] = receiver
msg['Subject'] = "ChitChat Password"
msg.attach(MIMEText(emailOTP, 'plain'))
server = smtplib.SMTP('smtp.gmail.com', 587)
server.starttls()
server.login(sender, "finelyear2020")
text = msg.as_string()
server.sendmail(sender, receiver, text)
OTP_list.append(emailOTP)
return OTP_list
def get(self, request, uidb64, token):
try:
id = force_text(urlsafe_base64_decode(uidb64))
user = CustomUser.objects.get(pk=id)
if not token_generator.check_token(user, token):
return redirect('login' + '?message=' +
'User already activated')
if user.is_active:
return redirect('uname_pw_gen')
user.is_active = True
password = BaseUserManager().make_random_password(10)
user.set_password(password)
user.save()
email_body = 'Hi ' + user.first_name + ' \n Your username: '******'\n Your Password: '******'Account Activated',
email_body,
'*****@*****.**',
[user.email],
)
email.send(fail_silently=False)
messages.success(request, 'Account activated successfully')
return redirect('uname_pw_gen')
except Exception as ex:
pass
return redirect('uname_pw_gen')
def post(self, request):
payload = {'access_token': request.data.get("token")} # validate the token
r = requests.get('https://www.googleapis.com/oauth2/v2/userinfo', params=payload)
data = json.loads(r.text)
if 'error' in data:
content = {'message': 'wrong google token / this google token is already expired.'}
return Response(content)
# create user if not exist
try:
user = User.objects.get(email=data['email'])
except User.DoesNotExist:
user = User()
user.username = data['name']
# provider random default password
user.password = make_password(BaseUserManager().make_random_password())
user.email = data['email']
user.save()
score = UserScore(user=user,name=user.email, current_question = 1)
score.save()
token = RefreshToken.for_user(user) # generate token without username & password
response = {}
response['username'] = user.username
response['access_token'] = str(token.access_token)
response['refresh_token'] = str(token)
return Response(response)
def post(self, request):
r = requests.get(
'https://oauth2.googleapis.com/tokeninfo?id_token={}'.format(
request.data.get("token")))
data = json.loads(r.text)
if 'error' in data:
content = {
'message':
'wrong google token / this google token is already expired.'
}
return HttpResponse(json.dumps(content))
# create user if not exist
try:
user = User.objects.get(email=data['email'])
except User.DoesNotExist:
user = User()
user.username = data['email']
user.password = make_password(
BaseUserManager().make_random_password())
user.email = data['email']
user.save()
token = RefreshToken.for_user(
user) # generate token without username & password
response = {
'username': user.username,
'access_token': str(token.access_token),
'refresh_token': str(token)
}
return HttpResponse(json.dumps(response))
def post(self, request):
User = get_user_model()
user_access_token = request.data['access_token']
# get users email
# https://graph.facebook.com/{your-user-id}?fields=id,name,email&access_token={your-user-access-token}
user_info_url = FACEBOOK_URL
user_info_payload = {
"fields": "id,name,email",
"access_token": user_access_token,
}
user_info_request = requests.get(
user_info_url, params=user_info_payload)
user_info_response = json.loads(user_info_request.text)
print(user_info_response)
# create user if not exist
try:
user = User.objects.get(email=user_info_response["email"])
except User.DoesNotExist:
user = User()
user.username = user_info_response["email"]
# provider random default password
user.password = make_password(
BaseUserManager().make_random_password())
user.email = user_info_response["email"]
user.save()
token = RefreshToken.for_user(
user
) # generate token without username & password
response = {}
response["username"] = user.username
response["access"] = str(token.access_token)
response["refresh"] = str(token)
return Response(response)
def requestor_signup(request):
if request.method == 'POST':
first_name = request.POST['firstname-review']
last_name = request.POST['lastname-review']
mobile_number = request.POST['phone-review']
address = request.POST['address-review']
apt_no = request.POST['apt-no-review']
user = User(username=mobile_number,
first_name=first_name,
last_name=last_name,
email='',
password=BaseUserManager().make_random_password(),
user_type=2)
user.save()
coord_location = helper.gmaps_geocode(address)
requestor = Requestor(
user=user,
# PhoneNumberField requires country code
mobile_number='+1' + mobile_number,
lon=coord_location['lng'],
lat=coord_location['lat'],
address_str=address,
apt_no=apt_no)
requestor.save()
return render(request, 'errand_matcher/request-errand.html', {
'requestor': requestor,
'requestor_new': True
})
else:
return render(request, 'errand_matcher/requestor-signup.html',
{'GMAPS_API_KEY': os.environ.get('GMAPS_API_KEY')})
def create_user_by_data(self, user_data):
"""
Create the user by the Django model
"""
from openedx.core.djangoapps.user_authn.views.registration_form import AccountCreationForm
from common.djangoapps.student.helpers import do_create_account
# Check and remove email if its already registered
aux_pass = BaseUserManager().make_random_password(12)
aux_pass = aux_pass.lower()
user_pass = aux_pass if 'pass' not in user_data else user_data['pass'] # Temporary password
if user_data['email'] == 'null':
user_data['email'] = str(uuid.uuid4()) + '@invalid.invalid'
form = AccountCreationForm(
data={
"username": self.generate_username(user_data),
"email": user_data['email'],
"password": user_pass,
"name": user_data['nombreCompleto'],
},
tos_required=False,
ignore_email_blacklist=True
)
user, _, reg = do_create_account(form)
reg.activate()
reg.save()
#from common.djangoapps.student.models import create_comments_service_user
#create_comments_service_user(user)
return user
def post(self, request):
payload = request.data.get("token") # Make readable
token = token_validation(payload)
# Create a user if no exist
try:
#Check if user exists already
user = User.objects.get(username=token.email)
except User.DoesNotExist:
#Create new user
user = User()
user.username = token.email
# provider random default password
user.password = make_password(
BaseUserManager().make_random_password())
user.email = token.email
user.save()
#Genereate token without username and password
token = RefreshToken.for_user(user)
response = {}
response['username'] = user.username
response['access_token'] = str(token.access_token)
response['refreash_token'] = str(token)
print("User logged in: ", user.username)
return Response(response)
def user_reset_password(request, id):
if not request.user.is_staff:
raise PermissionDenied
if request.method == "PUT":
user = User.objects.filter(id=id).first()
# Cannot change password for superuser
if user.is_superuser:
raise PermissionDenied
# Change password
password = BaseUserManager().make_random_password(16)
user.set_password(password) # replace with your real password
user.save()
# Logout user
[
s.delete() for s in Session.objects.all()
if s.get_decoded().get('_auth_user_id') == user.id
]
# Email notification
send_mail(
'KIV/PIA Piškvorky - Jakub Vítek - Reset hesla',
"Vynucena změna hesla, nové heslo " + password,
'*****@*****.**',
[user.email],
fail_silently=False,
)
return HttpResponse("ok")
return HttpResponse("not put")
class User(AbstractBaseUser, PermissionsMixin):
"""
Model to define my User model.
It is based on django AbstractBaseUser and uses PermissionsMixin.
It inherits `password` and `last_login` from AbstractBaseUser and
`is_superuser`, `groups` and `user_permissions` from PermissionsMixin.
"""
email = models.EmailField(_('email address'), unique=True)
name = models.CharField(_('name'), max_length=100)
date_joined = models.DateTimeField(_('date joined'), auto_now_add=True)
is_active = models.BooleanField(default=True)
objects = BaseUserManager()
USERNAME_FIELD = 'email'
class Meta:
db_table = 'users'
def save(self, *args, **kwargs):
if not self.pk:
if not self.password:
raise ValueError('password must be set')
self.set_password(self.password)
return super().save(*args, **kwargs)
def generate_code_corfo(user_id):
"""
Generate Corfo Code
"""
aux_code = BaseUserManager().make_random_password(8).upper()
code = 'U{}COD{}'.format(user_id, aux_code)
return code
def test_created_successfully(self):
user = User.objects.create_user(
username='******',
password=BaseUserManager().make_random_password())
title = 'New post'
self.client.force_authenticate(user)
image_data = INITIAL_POSTS_DATA[0][1].read_bytes()
response = self.client.post(
self.url, {
'image':
SimpleUploadedFile(
'uploaded_img.jpg', image_data, content_type='image'),
'title':
title
})
response_json = response.json()
self.assertTrue(response_json.pop('id'))
self.assertTrue(response_json.pop('uploaded_at'))
self.assertIn('http://testserver/media/images/uploaded_img',
response_json.pop('image'))
self.assertEqual(response_json, {
'title': title,
'owner': {
'id': user.id,
'username': user.username
}
})
self.assertEqual(response.status_code, 201)
def signup_view(request):
"""
This view generates view for sign up form.
"""
form = SignUpForm(request.POST)
if form.is_valid():
username = form.cleaned_data.get('username')
email = form.cleaned_data.get('email')
password = BaseUserManager().make_random_password()
send_mail(
f"Registration Electronic library",
f"Hello!\nYour login: {username}, password: {password}\nUse it to registrate in platform\n",
settings.EMAIL_HOST_USER, [
email,
])
user = User.objects.create_user(username=username,
email=email,
password=password)
user.save()
print("User:"******", email:", email, ", password:", password)
# confirmation page redirect
# return home_view(request)
return render(request, 'registration/signup_successful.html')
return render(request, 'registration/signup.html', {'form': form})
def admin_create_user(request):
if request.method == 'POST':
usertype = request.POST.get('user_type')
password1 = request.POST.get('password1')
form = ClientAgentSignupForm(request.POST)
if form.is_valid():
form = form.save(commit=False)
form.user_type = usertype
form.save()
subject = 'Thank you for registering to our site'
message = 'email: {},password: {}'.format(form.email, password1)
email_from = settings.EMAIL_HOST_USER
email_user = form.email
recipient_list = [
email_user,
]
send_mail(subject, message, email_from, recipient_list)
messages.add_message(
request, messages.SUCCESS,
'User %s added successfully' % (form.first_name))
return redirect('admin_manage_permissions')
else:
print(form.errors)
else:
password = BaseUserManager().make_random_password(8)
form = ClientAgentSignupForm()
arg = {'password1': password, 'form': form}
return render(request, 'admin/admin_create_user.html', arg)
def post(self, request):
data_from_sso = request.data
sso_id = data_from_sso['user']['id']
access_token = data_from_sso['access_token']
if SignedUsers.objects.filter(sso_id=sso_id).count() == 0:
sso_user = request.data['user']
password = BaseUserManager().make_random_password(45)
sso_user['id'] = None
sso_user['password'] = password
sso_user['confirm_password'] = password
is_lecturer = sso_user['is_lecturer']
serializer = UserSerializer(data=sso_user)
try:
response = self.users_service.create_user(
user_serializer=serializer, lecturer=is_lecturer)
except UsersServiceException as e:
return e.response
created_user = response.json
user = Users.objects.filter(pk=created_user['id']).get()
SignedUsers.objects.create(sso_id=sso_id,
user=user,
access_token=access_token)
else:
SignedUsers.objects.filter(sso_id=sso_id).update(
access_token=access_token)
return HttpResponse()
def register_patient(request):
if request.method == "POST":
user_form = UserRegistrationForm2(request.POST)
patient_form = PatientRegistrationForm(request.POST)
if user_form.is_valid() and patient_form.is_valid():
user = user_form.save(commit=False)
user.user_type = 2
usrn = user.first_name[0] + user.last_name
i=1
while MedUser.objects.filter(username=usrn).exists():
usrn = user.first_name[0] + user.last_name
usrn = usrn + str(i)
i = i+1
user.username = usrn
pwd = BaseUserManager().make_random_password()
user.set_password(pwd)
user.save()
patient = patient_form.save(commit=False)
patient.user = user
patient.creator = MedUser.objects.get(username = request.user)
patient.save()
user_form.add_error(None, "Patient registered with username = {} with random password = {}"
.format(user.username,pwd))
else:
user_form = UserRegistrationForm2()
patient_form = PatientRegistrationForm()
return render(request, "accounts/register.html", {'user_form': user_form, 'user_type_form': patient_form})
def update(self, instance, validated_data):
if ('assignment' in validated_data
and validated_data['assignment'] != None
and not instance.assignment and
not User.objects.filter(delegate__id=instance.id).exists()):
names = instance.name.split(' ')
username = names[0] + '_' + str(instance.id)
password = BaseUserManager().make_random_password(10)
user = User.objects.create_user(username=username,
password=password,
delegate=instance,
user_type=User.TYPE_DELEGATE,
first_name=names[0],
last_name=names[-1],
email=instance.email,
last_login=datetime.now())
send_mail('An account has been created for {0}.'.format(instance.name),
'Username: {0}\n'.format(username) \
+ 'Password: {0}\n'.format(password) \
+ 'Please save this information! You will need it for '
+ 'important information and actions. You can access '
+ 'this account at huxley.bmun.org.',
'*****@*****.**',
[instance.email], fail_silently=False)
return super(DelegateSerializer, self).update(instance, validated_data)
class MyUser(AbstractBaseUser):
class Meta:
db_table = 'users'
verbose_name = '유저'
verbose_name_plural = '유저들'
objects = BaseUserManager()
uid = models.CharField(primary_key=True,
unique=True,
max_length=100,
verbose_name='유저 UID (Firebase 에서 자동 생성)')
last_login = models.DateTimeField(auto_now=True, verbose_name='최근 로그인 일자')
is_active = models.BooleanField(default=True, verbose_name='활성화 여부')
is_admin = models.BooleanField(default=False, verbose_name='관리자 여부')
USERNAME_FIELD = 'uid'
@property
def is_staff(self):
return self.is_admin
def has_perm(self, perm, obj=None):
return self.is_active
def has_module_perms(self, app_label):
return self.is_active
def post(self, request, *args, **kwargs):
try:
serializer = PasswordResetSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
query = serializer.validated_data['query'][6:].encode()
decriptedQuery = base64.decodestring(query).decode()
username = decriptedQuery[3:decriptedQuery.find('&')]
static = decriptedQuery[decriptedQuery.find('&') + 8:]
user = User.objects.get(username=username)
token = Token.objects.get(key=static)
if not _TokenHelpers.is_token_expired(token):
newPassword = BaseUserManager().make_random_password(8)
hasshedPassword = make_password(newPassword)
user.password = hasshedPassword
user.save()
email = {
'email_to': user.email,
'name_to': username,
'email_type': eEmailType.CHANGED_PASSWORD,
'context': {
"username": username,
"password": newPassword
}
}
service = EmailService(request)
if service.addToQueue(email):
if service.sendQueue():
return Response(True)
return Response(False)
return Response(False)
except Exception as ex:
return Response(False)
def create_user(data, ngo_name, mode=None):
# create user if user does not exist
try:
if mode == 'login':
email_or_username = data['email']
if '@' in email_or_username:
user = User.objects.get(email=email_or_username)
else:
user = User.objects.get(username=email_or_username)
else:
user = User.objects.get(email=data['email'])
if mode == 'register':
return Response({'error': 'User already registered'}, status=401)
except User.DoesNotExist:
if mode == 'login':
return Response({'error': 'User not found'}, status=401)
user = User()
if data.get('username'):
user.username = data['username']
else:
user.username = data['email']
if data.get('password'):
user.password = make_password(data['password'])
else: # provider random default password
user.password = make_password(BaseUserManager().make_random_password())
user.email = data.get('email')
user.save()
if ngo_name:
user.is_active = False
user.save()
ngo = Ngo.objects.get(name=ngo_name)
NgoAccount.objects.create(user=user, ngo=ngo)
if mode == 'login' and not user.is_active:
error = {
'error': 'Your account has not been confirmed yet.',
'ngo_account_confirmed': is_ngo_account_confirmed(user)
}
return Response(error, status=401)
if mode == 'login' and not check_password(data['password'], user.password):
return Response({'error': 'User credentials incorrect'}, status=401)
ngo_id = -1
try:
ngo_id = NgoAccount.objects.get(user=user).ngo_id
except Exception:
pass
token = RefreshToken.for_user(user) # generate token without username & password
response = {'username': user.username,
'ngo_id': ngo_id,
'access_token': str(token.access_token),
'refresh_token': str(token),
}
return Response(response)
def post(self, request):
# create user if not exist
is_new = False
soft_account = True
url = "https://oauth2.googleapis.com/tokeninfo?id_token={}".format(
request.data)
request = requests.get(url)
response = json.loads(request.text)
google_internal_id = response.get('sub')
if google_internal_id is None:
return Response('Invalid Token', 400)
try:
user = GoogleIdUsers.objects.get(
sub_google_id=google_internal_id).user
except GoogleIdUsers.DoesNotExist:
user = User()
user.username = response.get('name')
# provider random default password
user.password = make_password(
BaseUserManager().make_random_password())
user.email = response.get('email')
user.first_name = response.get('given_name')
if response.get('family_name') is None:
user.last_name = ""
else:
user.last_name = response.get('family_name')
is_new = True
user.save()
google_sub = GoogleIdUsers()
google_sub.sub_google_id = google_internal_id
google_sub.user = user
google_sub.save()
try:
company = Company.objects.get(id_user=user)
except Company.DoesNotExist:
soft_account = False
token = RefreshToken.for_user(
user) # generate token without username & password
user_formated = {
'email': user.email,
'givenName': user.first_name,
'familyName': user.last_name,
'photo': response.get("picture"),
'username': user.username,
}
response = {
"is_new": is_new,
"completeRegistry": soft_account,
"username": user.username,
"userId": user.pk,
"access_token": str(token.access_token),
"refresh_token": str(token),
"user": user_formated
}
return Response(response)
def post(self, request):
payload = {
'access_token': request.data.get("access_token")
} # validate the token
r = requests.get('https://www.googleapis.com/oauth2/v1/tokeninfo',
params=payload)
data = json.loads(r.text)
if 'error' in data:
content = {
'message':
'wrong google token / this google token is already expired.'
}
return Response(content)
# create user if not exist
try:
user = User.objects.get(email=data['email'])
token = Token.objects.get(user=user)
except User.DoesNotExist:
user = User()
user.username = data['email']
# provider random default password
user.password = make_password(
BaseUserManager().make_random_password())
user.email = data['email']
user.save()
token = Token.objects.create(user=user)
response = {}
response['email'] = user.email
response['token'] = token.key
return Response(response)
class User(AbstractBaseUser, PermissionsMixin):
#Id implemented by django
USERNAME_FIELD = 'email'
voornaam = models.CharField(max_length=128)
naam = models.CharField(max_length=128)
email = models.CharField(max_length=128, unique=True)
activation_key = models.CharField(max_length=128, null=True, blank=True)
key_expires = models.DateTimeField(null=True, blank=True)
is_active = models.BooleanField(default=True)
is_admin = models.BooleanField(default=False)
straatnaam = models.CharField(max_length=128)
huisnr = models.CharField(max_length=10)
busnr = models.CharField(max_length=10, null=True, blank=True)
postcode = models.CharField(max_length=50)
plaats = models.CharField(max_length=128)
telefoonnr = models.IntegerField()
objects = BaseUserManager()
REQUIRED_FIELDS = [
'voornaam',
'naam',
'postcode',
'plaats',
'telefoonnr',
]
def __str__(self):
return self.email
def get_full_name(self):
# The user is identified by their email address
return self.email
def get_short_name(self):
# The user is identified by their email address
return self.email
def has_perm(self, perm, obj=None):
"Does the user have a specific permission?"
# Simplest possible answer: Yes, always
return True
def has_module_perms(self, app_label):
"Does the user have permissions to view the app `app_label`?"
# Simplest possible answer: Yes, always
return True
@property
def is_staff(self):
"Is the user a member of staff?"
# Simplest possible answer: All admins are staff
return self.is_admin
def create_mem(request):
if request.method == 'POST':
fname = request.POST['name']
Email = request.POST['email']
phone = request.POST['phone']
alt_phone = request.POST['alt_phone']
designation = request.POST['designation']
address = request.POST['address']
role = request.POST['role']
mapped_to = request.POST['mapped_to']
mapped_to_nm = request.POST['mapped_to_nm']
by_online = "no"
if CustomUser.objects.filter(email=Email).exists():
messages.info(request, 'Email Taken')
return redirect('create_mem')
else:
password = BaseUserManager().make_random_password(10)
user = CustomUser.objects.create_user(username=Email,
password=password,
email=Email,
first_name=fname,
phone=phone,
alt_phone=alt_phone,
designation=designation,
address=address,
role=role,
mapped_to=mapped_to,
mapped_to_name=mapped_to_nm,
by_online=by_online)
user.save()
if user.role == "Referral Partner":
ini = "ORP"
num = '{:03d}'.format(user.id)
newusername = ini + num
user.username = newusername
user.save()
email_body = 'Hi ' + user.first_name + ' \n Your username: '******'\n Your Password: '******'Account Activated',
email_body,
'',
[user.email],
)
email.send(fail_silently=False)
messages.success(request, 'Account Created successfully')
if request.user.role == "Admin":
# return render(request, 'account/dashboard.html')
return redirect('dashboard')
elif request.user.role == "Referral Partner":
# return render(request, 'account/base.html')
return redirect('base')
return render(request, 'account/create_mem.html')
class CustomUser(AbstractBaseUser):
"""User model class, extends Base Django User"""
username = models.CharField(max_length=30, unique=True)
password = models.CharField(max_length=128)
email = models.CharField(max_length=60, unique=True)
is_active = models.BooleanField(default=False)
USERNAME_FIELD = 'username'
objects = BaseUserManager()
class Meta:
db_table = 'tbl_users'
@staticmethod
def create(username, password, email):
"""
Creates user instance and tries to add it into database.
Returns:
user instance if added successfully,
None otherwise.
"""
user = CustomUser(username=username, email=email)
user.set_password(password)
try:
user.save()
return user
except IntegrityError:
return None
@staticmethod
def get_by_username(username):
"""
Returns:
user instance if found,
None otherwise.
"""
try:
return CustomUser.objects.get(username=username)
except ObjectDoesNotExist:
return None
@staticmethod
def change_password(username, new_password):
"""
Method to change user password.
Returns:
user instance if password was changed,
None otherwise.
"""
try:
user = CustomUser.objects.get(username=username)
except ObjectDoesNotExist:
return None
user.set_password(new_password)
try:
user.save()
return user
except IntegrityError:
return None
def post(self, request):
payload = {
'access_token': request.data.get("token")
} # validate the token
r = requests.get('https://www.googleapis.com/oauth2/v2/userinfo',
params=payload)
data = json.loads(r.text)
if 'error' in data:
content = {
'message':
'wrong google token / this google token is already expired.'
}
return Response(content)
pro = Professional.objects.filter(email=data['email']).first()
# create user if not exist
try:
user = User.objects.get(email=data['email'])
if not is_professional(user):
raise AuthenticationFailed()
except User.DoesNotExist:
user = User()
user.username = data['email']
# provider random default password
user.password = make_password(
BaseUserManager().make_random_password())
user.email = data['email']
user.is_active = 1
user.save()
pro_group = Group.objects.get(name='Professional')
user.groups.add(pro_group)
if not pro:
pro = Professional(full_name=data['name'],
email=data['email'],
password=user.password,
terms_and_condition_status=1)
pro.user_id = user.id
pro.created_by = user.id
pro.created_from = get_user_address(request)
pro.job_alert_status = True
pro.save()
token = RefreshToken.for_user(
user) # generate token without username & password
data = {}
data['username'] = user.username
data['access'] = str(token.access_token)
data['refresh'] = str(token)
data['user'] = {
'id': user.id,
'email': user.email,
'type': 'professional'
}
data['pro'] = ProfessionalSerializer(pro, many=False).data
data['token_lifetime'] = SIMPLE_JWT
return Response(data)
def handle(self, *args, **options):
length = options['length']
manager = BaseUserManager()
if length:
return manager.make_random_password(length)
else:
return manager.make_random_password()
def my_reset_password(self, request, user_id):
user = get_object_or_404(self.model, pk=user_id)
new_password = str(random.randint(
0, 9)) + BaseUserManager().make_random_password(length=8)
user.set_password(new_password)
user.save()
messages.add_message(request, 80, new_password, fail_silently=True)
return HttpResponseRedirect('../#iw-modal')
def save(self, commit=True):
user = super(SignUpForm, self).save(commit=False)
clean_email = self.cleaned_data["email"]
clean_password = BaseUserManager().make_random_password()
user.set_password(clean_password)
user.email = clean_email
user.save()
return user
def post(self, request, format=None):
'''
function to handle POST request for Google Oauth
'''
# Tasks left
# Fetching authorization code from frontend
# Using the above to send to Google to get Access token
auth_code = request.data["code"]
payload = {
'code': auth_code,
'client_id':
'939204723287-lr57oipdf4ifpbor35p0i1jdrq8708jc.apps.googleusercontent.com',
'client_secret': os.environ.get('GOOGLE_CLIENT_SECRET'),
'redirect_uri':
'https://master.d1irig95qyvz8m.amplifyapp.com/google/oauth',
'grant_type': 'authorization_code'
}
r = requests.post('https://www.googleapis.com/oauth2/v4/token',
params=payload)
resp = json.loads(r.text)
new_payload = {'access_token': resp["access_token"]}
r2 = requests.get('https://www.googleapis.com/oauth2/v2/userinfo',
params=new_payload)
data = json.loads(r2.text)
if 'error' in data:
return Response({'message': 'wrong or expired google token'},
status=status.HTTP_401_UNAUTHORIZED)
try:
user = User.objects.get(email=data['email'])
message = 'success'
except Exception as e:
user = User()
user.name = data['name']
user.email = data['email']
user.password_hash = make_password(
BaseUserManager().make_random_password())
user.save()
message = 'new user'
token = jwt.encode(
{
'email': data['email'],
'random': str(datetime.now().timestamp())
},
SECRET_FOR_JWT,
algorithm='HS256').decode()
return Response(
{
'token': token,
'message': message,
'name': data['name'],
'email': data['email']
},
status=status.HTTP_200_OK)