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 handle(self, *args, **options):
length = options['length']
manager = BaseUserManager()
if length:
return manager.make_random_password(length)
else:
return manager.make_random_password()
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 add_email(self, email_address, **kwargs):
try:
email = self.emails.get(
address=BaseUserManager.normalize_email(email_address))
email.bounced = kwargs['bounced'] if kwargs.get(
'bounced', None) is not None else email.bounced
email.bounced_date = kwargs['bounced_date'] if kwargs.get(
'bounced_date', None) is not None else email.bounced_date
email.save()
except ObjectDoesNotExist:
PersonEmail.objects.create(
address=BaseUserManager.normalize_email(email_address),
person=self,
**kwargs)
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 register_user(request, email, password):
email = BaseUserManager.normalize_email(email)
email = email.lower()
exists = User.objects.filter(email=email).exists()
if exists:
return Response({'error', 'bad request'}, status=status.HTTP_400_BAD_REQUEST)
user = User()
user.username = email
user.email = email
user.set_password(password)
user.is_active = False
try:
with transaction.atomic():
user.save()
profile = Profile()
profile.user = user
profile.save()
except Exception as ex:
raise ex
queue = get_notification_queue("email")
body = make_confirmation_message(confirm_registration, RefreshToken.for_user(user), user.id)
message_queue_provider.send_confirmation(queue, email, "Registration confirmation", body)
return Response({'user_id': user.id, 'email': email, "msg": "Check email"}, status=status.HTTP_200_OK)
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 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 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)
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 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):
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 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)
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 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 test_user_model_normalization(username, email):
username_normal = normalize("NFKC", username)
email_normal = BaseUserManager.normalize_email(email)
user = User(username=username, email=email, first_name="Foo", last_name="Bar")
user.clean()
assert user.username == username_normal
assert user.email == email_normal
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 emails_splitter(emails_str: str,
raise_exception: bool = False) -> List[str]:
"""
Split emails from string to set of normalized values
"""
emails_str = emails_str.strip()
if not emails_str:
return list()
if ',' in emails_str:
emails = emails_str.split(',')
else:
emails = emails_str.split()
result = [
BaseUserManager.normalize_email(email.strip()) for email in emails
]
for email in result:
try:
EmailValidator(f'email "{email}" is incorrect')(email)
except ValidationError as e:
if raise_exception:
raise e
else:
logger.error('email %s is incorrect', email)
return result
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 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):
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 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 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')
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 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 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 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 validate_email(self, value):
if value is not None:
user = User.objects.filter(email=value)
if user:
raise serializers.ValidationError("Email is already taken")
return BaseUserManager.normalize_email(value)
return value
def create_user(self,
username,
email,
first_name,
last_name,
first_name_kana,
last_name_kana,
phone_number,
password=None):
if not username:
raise ValueError("Users must have an username")
if not email:
raise ValueError("Users must have an email")
if not first_name:
raise ValueError("Users must have a first name")
if not last_name:
raise ValueError("Users must have a last name")
if not first_name_kana:
raise ValueError("Users must have a first name kana")
if not last_name_kana:
raise ValueError("Users must have a last name kana")
if not phone_number:
raise ValueError("Users must have a phone number")
user = self.model(username=username,
email=BaseUserManager.normalize_email(email),
first_name=first_name,
last_name=last_name,
first_name_kana=first_name_kana,
last_name_kana=last_name_kana,
phone_number=phone_number)
user.set_password(password)
user.save(using=self._db)
return user
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
