Пример #1
0
    def post(self, request, *args, **kwargs):
        email = request.POST.get("email", "0")
        firstname = request.POST.get("firstname", "0")
        lastname = request.POST.get("lastname", "0")
        site = request.POST.get("site", "0")
        # see if it already exists
        user = User.objects.filter(
            email=BaseUserManager.normalize_email(email))
        if (user):
            user = user[0]
            if user.is_active:
                # force a new email to be sent
                user.is_registering = True
                user.save()
                return HttpResponse(json.dumps({"error": "already_approved"}),
                                    content_type='application/javascript')
            else:
                return HttpResponse(json.dumps({"error": "already_pending"}),
                                    content_type='application/javascript')

        user = User.deleted_objects.filter(
            email=BaseUserManager.normalize_email(email))
        if (user):
            return HttpResponse(json.dumps({"error": "is_deleted"}),
                                content_type='application/javascript')

        user = User(email=BaseUserManager.normalize_email(email),
                    firstname=firstname,
                    lastname=lastname,
                    is_active=False,
                    is_admin=False,
                    is_registering=True)
        user.save()
        user.site = Site.objects.get(name=site)
        user.save(update_fields=['site'])
        sitePriv = SitePrivilege.objects.filter(site=user.site)
        userId = user.id
        userUrl = "http://" + request.get_host() + "/admin/core/user/" + str(
            userId)
        for sp in sitePriv:
            subject, from_email, to = 'Authorize OpenCloud User Account', '*****@*****.**', str(
                sp.user)
            text_content = 'This is an important message.'
            html_content = """<p>Please authorize the following user on site """ + site + """: <br><br>User: """ + firstname + """ """ + lastname + """<br>Email: """ + email + """<br><br>
Check the checkbox next to Is Active property at <a href=""" + userUrl + """> this link</a> to authorize the user, and then click the Save button. If you do not recognize this individual, or otherwise do not want to approve this account, please ignore this email. If you do not approve this request in 48 hours, the account will automatically be deleted.</p>"""
            msg = EmailMultiAlternatives(subject, text_content, from_email,
                                         [to])
            msg.attach_alternative(html_content, "text/html")
            msg.send()
        return HttpResponse(serializers.serialize("json", [
            user,
        ]),
                            content_type='application/javascript')
Пример #2
0
    def register(self, request, **cleaned_data):
        User = compat.get_user_model()
        if Site._meta.installed:
            site = Site.objects.get_current()
        else:
            site = RequestSite(request)
        user_fields = {}
        # keep non password fields
        for field in compat.get_registration_fields():
            if not field.startswith('password'):
                user_fields[field] = cleaned_data[field]
            if field == 'email':
                user_fields[field] = BaseUserManager.normalize_email(user_fields[field])
        new_user = User(is_active=False, **user_fields)
        new_user.clean()
        new_user.set_password(cleaned_data['password1'])
        new_user.save()
        attributes = models.Attribute.objects.filter(
                asked_on_registration=True)
        if attributes:
            for attribute in attributes:
                attribute.set_value(new_user, cleaned_data[attribute.name])
        registration_profile = RegistrationProfile.objects.create_profile(new_user)
        registration_profile.send_activation_email(site)

        signals.user_registered.send(sender=self.__class__,
                                     user=new_user,
                                     request=request)
        return new_user
Пример #3
0
 def validate_email(self, value):
     if not value:
         raise CustomValidation('-1', "이메일주소를 입력하세요.")
     user = get_user_model().objects.filter(email=value)
     if user:
         raise CustomValidation('-5', "이미 등록된 이메일주소입니다.")
     return BaseUserManager.normalize_email(value)
Пример #4
0
 def create_user(self, email, password=None):
     now = timezone.now()
     email = BaseUserManager.normalize_email(email)
     user = self.model(email=email, last_login=now)
     user.set_password(password)
     user.save(using=self._db)
     return user
Пример #5
0
    def signup(self, request):
        serializer = SignUpSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors,
                            status=status.HTTP_400_BAD_REQUEST)

        email = serializer.data['email']
        password = serializer.data['password']
        username = serializer.data['username']
        department_id = serializer.data['department']
        email = BaseUserManager.normalize_email(email)
        user = UserService.get_user_by_username_or_email(email)
        if user:
            return Response({'error': "Email has been used"},
                            status=status.HTTP_401_UNAUTHORIZED)
        now = timezone.now()
        user = User.objects.create(email=email,
                                   username=username,
                                   is_staff=False,
                                   is_superuser=False,
                                   is_active=True,
                                   last_login=now,
                                   date_joined=now)
        user.set_password(password)
        profile = UserProfile.objects.create(user=user)
        if department_id:
            depart = Department.objects.get(id=department_id)
            profile.department = depart

        user.save()
        profile.save()
        return Response({'message': 'Create user successfully'},
                        status=status.HTTP_200_OK)
Пример #6
0
    def create_superuser(self, username, email, password, **extra_fields):
        email = BaseUserManager.normalize_email(email)
        user = self.model(username=username, email=email, is_staff=True, is_active=True, is_superuser=True)

        user.set_password(password)
        user.save(using=self._db)
        return user
Пример #7
0
 def validate_email(self, value):
     value = value.lower().strip()
     value = BaseUserManager.normalize_email(value)
     if User.objects.filter(email=value).exists():
         raise serializers.ValidationError(
             {'detail': "Email already exists."})
     return value
Пример #8
0
 def create_user(self, email, password=None):
     now = timezone.now()
     email = BaseUserManager.normalize_email(email)
     user = self.model(email=email, last_login=now)
     user.set_password(password)
     user.save(using=self._db)
     return user
Пример #9
0
    def create_user(self, email, password):
        user = User(email=BaseUserManager.normalize_email(email), )
        user.set_password(password)
        user.save(using=self._db)

        Token.objects.create(user=user)
        return user
def signup(request):
    
    if request.method == "POST":
        logger.info("Processing signup request...")
        uform = UserForm(request.POST, instance=User())
        pform = UserprofileForm(request.POST, instance=Userprofile())
        logger.info("New signup request.")
        
        if uform.is_valid() and pform.is_valid():
            email = BaseUserManager.normalize_email(uform.cleaned_data['email'])
            djangouser = User.objects.create_user(uform.cleaned_data['username'],
                                     email,
                                     uform.cleaned_data['password'])
            
            logger.debug("User created in database as " + 
                         djangouser.username)
            djangouser.last_name = uform.cleaned_data['last_name']
            djangouser.first_name = uform.cleaned_data['first_name']
            djangouser._dateofbirth = pform.cleaned_data['dateofbirth']
            djangouser._gender = pform.cleaned_data['gender']
            djangouser._height = pform.cleaned_data['height']
            djangouser._weight = pform.cleaned_data['weight']

            if pform.cleaned_data['notes']:
                djangouser._notes = pform.cleaned_data['notes']
                
            else:
                djangouser._notes = ''

            logger.debug("Signup request processed with the following info:" +
                            "\n\t Username: "******"\n\t Email: " + djangouser.email +
                            "\n\t First Name: " + djangouser.first_name +
                            "\n\t Last Name: " + djangouser.last_name +
                            "\n\t Date of Birth: " + str(djangouser._dateofbirth) +
                            "\n\t Gender: " + djangouser._gender +
                            "\n\t Height: " + str(djangouser._height) +
                            "\n\t Weight: " + str(djangouser._weight) +
                            "\n\t Notes: " + djangouser._notes
                        )
            logger.debug("Sending 'user_initiated' signal...")
            signals.user_initiated.send(sender=None, 
                                instance=djangouser,
                                dateofbirth=djangouser._dateofbirth,
                                gender=djangouser._gender,
                                height=djangouser._height,
                                weight=djangouser._weight,
                                notes=djangouser._notes)
            djangouser.save()
            logger.debug("User creation successful.")
            return HttpResponseRedirect('..')
            
    else:
        logger.info("Loading signup page...")
        uform = UserForm(instance=User())
        pform = UserprofileForm(instance=Userprofile())
    return render(request,
                  'healthtracker/signup.html',
                  {'user_form':uform, 'userprofile_form':pform}
                  )
Пример #11
0
 def save(self, commit=True):
     print(" === save === ")
     user = super(RegisterForm, self).save(commit=False)
     user.email = BaseUserManager.normalize_email(self.cleaned_data["email"])
     if commit:
         user.save()
     return user
Пример #12
0
def login(request):
    if request.method == 'GET':
        user = request.user
        if user.is_authenticated():
            if user.is_superuser:
                return HttpResponseRedirect(reverse('basketball:commissioner-dashboard'))
            else:
                return HttpResponseRedirect(reverse('basketball:edit-player-info', args=[user.player.pk]))
        redirect_next = request.GET.get('next', reverse('basketball:leagues'))
        context = {'error': False, 'next': redirect_next}
    elif request.method == 'POST':
        username = request.POST.get('username', '')
        password = request.POST.get('password', '')
        try:
            username = User.objects.get(email=BaseUserManager.normalize_email(username)).get_username
        except User.DoesNotExist:
            pass
        user = authenticate(username=username, password=password)
        if user is not None:
            auth_login(request, user)
            redirect_next = request.POST.get('next')
            if not redirect_next:
                redirect_next = reverse('basketball:leagues')
            return HttpResponseRedirect(redirect_next)
        else:
            context = {'error': True}

    return render(request, 'basketball/login.html', context)
Пример #13
0
    def create_user(self, email, password, first_name, last_name, has_set_password=True, **extra_fields):
        """Creates and saves a User with the given email and password.

        Arguments:
            email {str} -- username
            password {str} -- forreals
            **extra_fields {dict} -- Other user model fields that can be passed in to set the user

        Keyword Arguments:

        Returns:
            User -- user instance
        """

        now = timezone.now()
        email = BaseUserManager.normalize_email(email.lower())

        user = self.model(email=email, first_name=first_name, last_name=last_name,
                          is_staff=False, is_active=True, is_superuser=False,
                          is_new=True, has_set_password=has_set_password,
                          last_login=now, date_joined=now, **extra_fields)
        user.set_password(password)
        user.save()

        return user
Пример #14
0
	def validate_email(self,value):
		"""
		Method for validating email id
		"""
		userAccount = User.objects.filter(email=value)
		if userAccount:
			raise serializers.ValidationError("Email is already taken")
		return BaseUserManager.normalize_email(value)
Пример #15
0
    def create_user(self, username, email, password=None):
        if not email:
            raise ValueError('Users must have an email address')

        user = self.model(email=BaseUserManager.normalize_email(email), username=username, date_of_birth=datetime.date(1981,12,29))
        user.set_password(password)
        user.save(using=self._db)
        return user
Пример #16
0
 def create_user(self, email=None, password=None, **extra_fields):
     if not email:
         raise ValueError('No email!')
     email = BaseUserManager.normalize_email(email)
     user = self.model(email=email, is_superuser=False, **extra_fields)
     user.set_password(password)
     user.save(using=self._db)
     return user
Пример #17
0
 def create_user(self, email, user_name, last_name, first_name, password, **other_fields):
     if not email:
         raise ValueError(_('provide an email'))
     email = BaseUserManager.normalize_email(email=email)
     user = Register(email=email, user_name=user_name, first_name=first_name, last_name=last_name, **other_fields)
     user.set_password(password)
     user.save()
     return user
Пример #18
0
    def create_user(self, email, password=None):
        if not email:
            raise ValueError('メールアドレスの登録が必須です')

        user = self.model(email=BaseUserManager.normalize_email(email))
        user.set_password(password)
        user.save(using=self._db)
        return user
Пример #19
0
    def validate_email(self, value):
        email = BaseUserManager.normalize_email(value)

        if UserModel.objects.filter(email=email).exists():
            raise serializers.ValidationError(
                "A user with that email already exists.")

        return email
Пример #20
0
    def create_user(self, username, email, password=None):
        if not email:
            raise ValueError('Users must have an email address')

        user = self.model(email=BaseUserManager.normalize_email(email))
        user.set_password(password)
        user.save(using=self._db)
        return user
Пример #21
0
def register(request):
    user_model = get_user_model()

    try:
        email = BaseUserManager.normalize_email(request.data["email"])
        if not is_email_valid(email):
            raise ValueError

        if settings.OPEN_REGISTRATION:
            preexisting_user, _ = user_model.objects.get_or_create(email=email)
        else:
            preexisting_user = user_model.objects.get(email__iexact=email)

        preexisting_user.register_preexisting_user(request.data.get("name"))
        LOGGER.info(
            log_filter(
                request,
                "registration succeded; "
                "email: '" + str(email) + "'",
            ))
        return Response({}, status=status.HTTP_201_CREATED)
    except IntegrityError:
        LOGGER.error(
            log_filter(
                request,
                "Registration failed: IntegrityError; "
                "email: '" + str(email) + "'",
            ))
        return Response({}, status=status.HTTP_201_CREATED)
    except user_model.DoesNotExist:
        LOGGER.error(
            log_filter(
                request,
                "Registration failed: Email or Researcher Id not found; "
                "email: '" + str(email) + "'",
            ))
        return Response(
            {
                "error_msg": ("Registration is closed."
                              " Please contact an administrator.")
            },
            status=status.HTTP_403_FORBIDDEN)
    except KeyError:
        LOGGER.error(
            log_filter(request,
                       "Registration failed: KeyError; " + str(request.data)))
        return Response({}, status=status.HTTP_201_CREATED)
    except ValueError:
        LOGGER.error(
            log_filter(
                request,
                f"Registration failed: Invalid email; email: '{str(email)}'"))
        return Response(
            {
                "error_msg": ("Invalid email address entered."
                              " Please use a valid email address.")
            },
            status=status.HTTP_400_BAD_REQUEST)
Пример #22
0
    def create_user(self, email, is_admin=False):
        """Creates a new user based on the hash of the email address."""
        email = BaseUserManager.normalize_email()
        user_id = email_hash(email)
        user = self.model(user=user_id, is_admin=is_admin)

        user.password_notify(new=True)
        user.save(using=self._db)
        return user
Пример #23
0
    def normalize_email(cls, email):
        """ Whether to lowercase entire email based on 
        ACCOUNT_LOWER_EMAIL setting. """

        if app_settings.ACCOUNT_LOWER_EMAIL:
            email = email or ''  # follow BaseUserManager's behavior
            return email.lower()
        else:
            return BaseUserManager.normalize_email(email)
Пример #24
0
    def post(self, request, *args, **kwargs):
	email = request.POST.get("email", "0")
	firstname = request.POST.get("firstname", "0")
	lastname = request.POST.get("lastname", "0")
	site = request.POST.get("site","0")
        # see if it already exists
        user=User.objects.filter(email=BaseUserManager.normalize_email(email))
        if (user):
             user = user[0]
             if user.is_active:
                 # force a new email to be sent
                 user.is_registering=True
                 user.save()
                 return HttpResponse(json.dumps({"error": "already_approved"}), content_type='application/javascript')
             else:
                 return HttpResponse(json.dumps({"error": "already_pending"}), content_type='application/javascript')

        user=User.deleted_objects.filter(email=BaseUserManager.normalize_email(email))
        if (user):
            return HttpResponse(json.dumps({"error": "is_deleted"}), content_type='application/javascript')

	user = User(
            email=BaseUserManager.normalize_email(email),
            firstname=firstname,
            lastname=lastname,
	    is_active=False,
            is_admin=False,
            is_registering=True
        )
        user.save()
	user.site=Site.objects.get(name=site)
	user.save(update_fields=['site'])
	sitePriv = SitePrivilege.objects.filter(site=user.site)
	userId = user.id
	userUrl = "http://"+request.get_host()+"/admin/core/user/"+str(userId)
	for sp in sitePriv:
		subject, from_email, to = 'Authorize OpenCloud User Account', '*****@*****.**', str(sp.user)
		text_content = 'This is an important message.'
		html_content = """<p>Please authorize the following user on site """+site+""": <br><br>User: """+firstname+""" """+lastname+"""<br>Email: """+email+"""<br><br>
Check the checkbox next to Is Active property at <a href="""+userUrl+"""> this link</a> to authorize the user, and then click the Save button. If you do not recognize this individual, or otherwise do not want to approve this account, please ignore this email. If you do not approve this request in 48 hours, the account will automatically be deleted.</p>"""
		msg = EmailMultiAlternatives(subject,text_content, from_email, [to])
		msg.attach_alternative(html_content, "text/html")
		msg.send()
        return HttpResponse(serializers.serialize("json",[user,]), content_type='application/javascript')
Пример #25
0
    def create_account(self, email, password=None, **extra_fields):
        now = timezone.now()
        if not email:
            raise ValueError('The given email must be set')
        email = BaseUserManager.normalize_email(email)

        account = self.model(email=email, last_login=now, **extra_fields)
        account.set_password(password)
        account.save(using=self._db)
        return account
Пример #26
0
 def validate_email(self, value):
     user = usr.objects.filter(email=value)
     social_user = SocialDocs.objects.filter(email=value)
     if not user:
         raise serializers.ValidationError("Email is not registered")
     if social_user:
         raise serializers.ValidationError(
             "The with this email is reqistered via google so s/he cannot have a password to change"
         )
     return BaseUserManager.normalize_email(value)
Пример #27
0
        def create_user(self, username, email=None, password=None, **extra_fields):
            """
            Creates and saves a User with the given username, email and password.
            """
            email = BaseUserManager.normalize_email(email)
            user = self.model(username=username, email=email, is_staff=False, is_active=True, is_superuser=False)

            user.set_password(password)
            user.save(using=self._db)
            return user
Пример #28
0
	def _create_user(self, username, email, password, is_staff, is_superuser, **extra_fields):
		if not email:
			raise ValueError("El email es obligatorio")

		email = BaseUserManager.normalize_email(email)
		user  = self.model(username=username, email=email, is_active=True, is_staff=is_staff,is_superuser=is_superuser, **extra_fields)

		user.set_password(password)
		user.save(using=self._db)
		return user 
Пример #29
0
    def process_request(self, request):
        django_user = get_user(request)
        google_user = users.get_current_user()

        # Check to see if the user is authenticated with a different backend, if so, just set
        # request.user and bail
        if django_user.is_authenticated():
            backend_str = request.session.get(BACKEND_SESSION_KEY)
            if (not backend_str) or not isinstance(
                    load_backend(backend_str), BaseAppEngineUserAPIBackend):
                request.user = django_user
                return

        if django_user.is_anonymous() and google_user:
            # If there is a google user, but we are anonymous, log in!
            # Note that if DJANGAE_FORCE_USER_PRE_CREATION is True then this may not authenticate
            django_user = authenticate(
                google_user=google_user) or AnonymousUser()
            if django_user.is_authenticated():
                login(request, django_user)

        if django_user.is_authenticated():
            if not google_user:
                # If we are logged in with django, but not longer logged in with Google
                # then log out
                logout(request)
                django_user = AnonymousUser()
            elif django_user.username != google_user.user_id():
                # If the Google user changed, we need to log in with the new one
                logout(request)
                django_user = authenticate(
                    google_user=google_user) or AnonymousUser()
                if django_user.is_authenticated():
                    login(request, django_user)

        # Note that the logic above may have logged us out, hence new `if` statement
        if django_user.is_authenticated():
            # Now make sure we update is_superuser and is_staff appropriately
            is_superuser = users.is_current_user_admin()
            google_email = BaseUserManager.normalize_email(google_user.email())
            resave = False

            if is_superuser != django_user.is_superuser:
                django_user.is_superuser = django_user.is_staff = is_superuser
                resave = True

            # for users which already exist, we want to verify that their email is still correct
            if django_user.email != google_email:
                django_user.email = google_email
                resave = True

            if resave:
                django_user.save()

        request.user = django_user
Пример #30
0
    def validate_email(self, value):
        """Validate email

        Validate the user's email address to ensure that the email address
        doesn't already exist in the database. An error will be raise if the
        email exists within the database
        """
        user = UserProfile.objects.filter(email=value)
        if user:
            raise serializers.ValidationError('Email is already taken')
        return BaseUserManager.normalize_email(value)
Пример #31
0
 def authenticate(self, **kwargs):
     email = kwargs.get('username')
     password = kwargs.get('password')
     try:
         if email:
             user = MyUser.objects.get(
                 email=BaseUserManager.normalize_email(email))
             if user.check_password(password):
                 return user
     except MyUser.DoesNotExist:
         return None
Пример #32
0
 def update(self, instance, validated_data):
     get_user_model()
     if 'email' in validated_data:
         validated_data['email'] = BaseUserManager.normalize_email(validated_data['email'])
     if 'username' in validated_data:
         validated_data['username'] = AbstractUser.normalize_username(validated_data['username'])
     user = super(CreateUpdateUserSerializer, self).update(instance, validated_data)
     if 'password' in validated_data:
         user.set_password(validated_data['password'])
     user.save()
     return user
Пример #33
0
    def create_user(self, email, password=None, **extra_fields):
        now = timezone.now()
        if not email:
            raise ValueError('The given email must be set')
        email = BaseUserManager.normalize_email(email)
        validate_email(email)
        user = self.model(email=email, is_staff=False, is_active=True, is_superuser=False,
                          joined=now, updated=now, **extra_fields)

        user.set_password(password)
        user.save(using=self._db)
        return user
Пример #34
0
    def create_user(self, username, email, password=None):
        if not email:
            raise ValueError('Users must have an email address')

        user = self.model(
            username=username,
            email=BaseUserManager.normalize_email(email),
        )

        user.set_password(password)
        user.save()
        return user
Пример #35
0
 def validate(self, attrs):
     """token validation and authentication"""
     email = BaseUserManager.normalize_email(attrs.get('email'))
     user = authenticate(
         request=self.context.get('request'),
         username=email,  # email as username for custom user
         password=attrs.get('password'))
     if not user:
         msg = "Unable to authenticate user with provided credentials"
         raise serializers.ValidationError(msg, code='authentication')
     attrs['user'] = user
     return attrs
Пример #36
0
    def process_request(self, request):
        django_user = get_user(request)
        google_user = users.get_current_user()

        # Check to see if the user is authenticated with a different backend, if so, just set
        # request.user and bail
        if django_user.is_authenticated():
            backend_str = request.session.get(BACKEND_SESSION_KEY)
            if (not backend_str) or not isinstance(load_backend(backend_str), BaseAppEngineUserAPIBackend):
                request.user = django_user
                return

        if django_user.is_anonymous() and google_user:
            # If there is a google user, but we are anonymous, log in!
            # Note that if DJANGAE_FORCE_USER_PRE_CREATION is True then this may not authenticate
            django_user = authenticate(google_user=google_user) or AnonymousUser()
            if django_user.is_authenticated():
                login(request, django_user)

        if django_user.is_authenticated():
            if not google_user:
                # If we are logged in with django, but not longer logged in with Google
                # then log out
                logout(request)
                django_user = AnonymousUser()
            elif django_user.username != google_user.user_id():
                # If the Google user changed, we need to log in with the new one
                logout(request)
                django_user = authenticate(google_user=google_user) or AnonymousUser()
                if django_user.is_authenticated():
                    login(request, django_user)

        # Note that the logic above may have logged us out, hence new `if` statement
        if django_user.is_authenticated():
            # Now make sure we update is_superuser and is_staff appropriately
            is_superuser = users.is_current_user_admin()
            google_email = BaseUserManager.normalize_email(google_user.email())
            resave = False

            if is_superuser != django_user.is_superuser:
                django_user.is_superuser = django_user.is_staff = is_superuser
                resave = True

            # for users which already exist, we want to verify that their email is still correct
            if django_user.email != google_email:
                django_user.email = google_email
                resave = True

            if resave:
                django_user.save()

        request.user = django_user
Пример #37
0
 def clean_email(self):
     if self.cleaned_data.get('email'):
         email = self.cleaned_data['email']
         if app_settings.A2_REGISTRATION_EMAIL_IS_UNIQUE:
             User = get_user_model()
             try:
                 User.get(email__iexact=email)
             except User.DoesNotExist:
                 pass
             else:
                 raise ValidationError(_('This email address is already in '
                                         'use. Please supply a different email address.'))
         return BaseUserManager.normalize_email(email)
Пример #38
0
    def create_user(self, email, password=None, **extra_fields):
        """ Creates and saves a User with the given email and password. """
        now = timezone.now()
        if not email:
            raise ValueError('Users must have an email address')
        email = BaseUserManager.normalize_email(email)
        user = self.model(email=email,
                          is_staff=False, is_active=True, is_superuser=False,
                          last_login=now, date_joined=now, **extra_fields)

        user.set_password(password)
        user.save(using=self._db)
        return user
Пример #39
0
    def authenticate(self, **credentials):
        """
        Handles authentication of a user from the given credentials.
        Credentials must be a combination of 'request' and 'google_user'.
         If any other combination of credentials are given then we raise a TypeError, see authenticate() in django.contrib.auth.__init__.py.
        """

        User = get_user_model()

        if not issubclass(User, GaeAbstractBaseUser):
            raise ImproperlyConfigured(
                "djangae.contrib.auth.backends.AppEngineUserAPI requires AUTH_USER_MODEL to be a "
                " subclass of djangae.contrib.auth.models.GaeAbstractBaseUser."
            )

        if len(credentials) != 1:
            # Django expects a TypeError if this backend cannot handle the given credentials
            raise TypeError()

        google_user = credentials.get('google_user', None)

        if google_user:
            user_id = google_user.user_id()
            email = google_user.email().lower()
            try:
                user = User.objects.get(username=user_id)

            except User.DoesNotExist:
                if (getattr(settings, 'DJANGAE_ALLOW_USER_PRE_CREATION', False)
                        or
                        # Backwards compatibility, remove before 1.0
                        getattr(settings, 'ALLOW_USER_PRE_CREATION', False)):
                    # Check to see if a User object for this email address has been pre-created.
                    try:
                        # Convert the pre-created User object so that the user can now login via
                        # Google Accounts, and ONLY via Google Accounts.
                        user = User.objects.get(
                            email=BaseUserManager.normalize_email(email),
                            username=None)
                        user.username = user_id
                        user.last_login = timezone.now()
                        user.save()
                        return user
                    except User.DoesNotExist:
                        pass
                user = User.objects.create_user(user_id, email)

            return user
        else:
            raise TypeError(
            )  # Django expects to be able to pass in whatever credentials it has, and for you to raise a TypeError if they mean nothing to you
Пример #40
0
    def authenticate(self, **credentials):
        """
        Handles authentication of a user from the given credentials.
        Credentials must be a combination of 'request' and 'google_user'.
        If any other combination of credentials are given then we raise a TypeError, see
        authenticate() in django.contrib.auth.__init__.py.
        """

        User = get_user_model()

        if not issubclass(User, GaeAbstractBaseUser):
            raise ImproperlyConfigured(
                "djangae.contrib.auth.backends.AppEngineUserAPI requires AUTH_USER_MODEL to be a "
                " subclass of djangae.contrib.auth.base.GaeAbstractBaseUser."
            )

        if len(credentials) != 1:
            # Django expects a TypeError if this backend cannot handle the given credentials
            raise TypeError()

        google_user = credentials.get('google_user', None)

        if google_user:
            user_id = google_user.user_id()
            email = google_user.email().lower()
            try:
                user = User.objects.get(username=user_id)

            except User.DoesNotExist:
                if (
                    getattr(settings, 'DJANGAE_ALLOW_USER_PRE_CREATION', False) or
                    # Backwards compatibility, remove before 1.0
                    getattr(settings, 'ALLOW_USER_PRE_CREATION', False)
                ):
                    # Check to see if a User object for this email address has been pre-created.
                    try:
                        # Convert the pre-created User object so that the user can now login via
                        # Google Accounts, and ONLY via Google Accounts.
                        user = User.objects.get(email=BaseUserManager.normalize_email(email), username=None)
                        user.username = user_id
                        user.last_login = timezone.now()
                        user.save()
                        return user
                    except User.DoesNotExist:
                        pass
                user = User.objects.create_user(user_id, email)

            return user
        else:
            raise TypeError()  # Django expects to be able to pass in whatever credentials it has, and for you to raise a TypeError if they mean nothing to you
Пример #41
0
    def process_request(self, request):

        django_user = get_user(request)
        google_user = users.get_current_user()

        if django_user.is_anonymous() and google_user:
            # If there is a google user, but we are anonymous, log in!
            django_user = authenticate(google_user=google_user)
            if django_user:
                login(request, django_user)
        elif not django_user.is_anonymous() and not google_user:
            # If we are logged in with django, but not longer logged in with Google
            # then log out
            logout(request)
            django_user = None
        elif not django_user.is_anonymous(
        ) and django_user.username != google_user.user_id():
            # If the Google user changed, we need to log in with the new one
            logout(request)
            django_user = authenticate(google_user=google_user)
            if django_user:
                login(request, django_user)

        request.user = django_user or AnonymousUser()

        backend_str = request.session.get(BACKEND_SESSION_KEY)

        if backend_str and google_user:
            backend = load_backend(backend_str)

            # We only do this next bit if the user was authenticated with the AppEngineUserAPI
            # backend, or one of its subclasses
            if isinstance(backend, BaseAppEngineUserAPIBackend):
                # Now make sure we update is_superuser and is_staff appropriately
                is_superuser = users.is_current_user_admin()
                google_email = BaseUserManager.normalize_email(
                    google_user.email())
                resave = False

                if is_superuser != django_user.is_superuser:
                    django_user.is_superuser = django_user.is_staff = is_superuser
                    resave = True

                # for users which already exist, we want to verify that their email is still correct
                if django_user.email != google_email:
                    django_user.email = google_email
                    resave = True

                if resave:
                    django_user.save()
Пример #42
0
def create_admin(apps, schema_editor):
    Learner = apps.get_model('learners', 'Learner')
    email = BaseUserManager.normalize_email('admin@localhost')
    admin = Learner(email=email,
                    is_staff=True,
                    is_superuser=True,
                    name='Admin',
                    need_active_update=True,
                    minimum_delay=3,
                    new_count=5)
    admin.password = make_password('MCTDH')
    admin.save()
    stderr.write(
        '\n*********************************************************************\nA user with email "admin@localhost" and password "MCTDH" was created.\nYou should update the password!\n*********************************************************************\n'
    )
Пример #43
0
    def create_user(self, number, password, name="", email=None):
        if email is None:
            email = f"{number}@u-aizu.ac.jp"
        user = User(
            name=name,
            number=number,
            email=BaseUserManager.normalize_email(email),
            coin=0,
        )
        user.set_password(password)
        user.save(using=self._db)

        # Create Auth Token
        Token.objects.create(user=user)
        return user
Пример #44
0
    def process_request(self, request):

        django_user = get_user(request)
        google_user = users.get_current_user()

        if django_user.is_anonymous() and google_user:
            # If there is a google user, but we are anonymous, log in!
            django_user = authenticate(google_user=google_user)
            if django_user:
                login(request, django_user)
        elif not django_user.is_anonymous() and not google_user:
            # If we are logged in with django, but not longer logged in with Google
            # then log out
            logout(request)
            django_user = None
        elif not django_user.is_anonymous() and django_user.username != google_user.user_id():
            # If the Google user changed, we need to log in with the new one
            logout(request)
            django_user = authenticate(google_user=google_user)
            if django_user:
                login(request, django_user)

        request.user = django_user or AnonymousUser()

        backend_str = request.session.get(BACKEND_SESSION_KEY)

        if backend_str and google_user:
            backend = load_backend(backend_str)

            # We only do this next bit if the user was authenticated with the AppEngineUserAPI
            # backend, or one of its subclasses
            if isinstance(backend, AppEngineUserAPI):
                # Now make sure we update is_superuser and is_staff appropriately
                is_superuser = users.is_current_user_admin()
                google_email = BaseUserManager.normalize_email(google_user.email())
                resave = False

                if is_superuser != django_user.is_superuser:
                    django_user.is_superuser = django_user.is_staff = is_superuser
                    resave = True

                # for users which already exist, we want to verify that their email is still correct
                if django_user.email != google_email:
                    django_user.email = google_email
                    resave = True

                if resave:
                    django_user.save()
Пример #45
0
    def create_api_user(self, **extra_fields):
        """
        used in the api.
        """
        fields = copy.copy(extra_fields)
        # pop fields
        username = fields.pop('username', None)
        email = BaseUserManager.normalize_email(fields.pop('email', None))
        password = make_password(fields.pop('password', None))
        facebook_id = self._convert_int_or_none(fields.pop(
            'facebook_id', None))
        twitter_id = self._convert_int_or_none(fields.pop('twitter_id', None))
        instagram_id = self._convert_int_or_none(
            fields.pop('instagram_id', None))
        line_id = fields.pop('line_id', None)
        nickname = fields.pop('nickname', None)
        extra = fields.pop('extra', {'instagram_username': ''})
        activity_settings = fields.pop('activity_settings',
                                       {'comments_public': True})
        # validations
        if not username:
            raise AE104()
        if not any([facebook_id, twitter_id, instagram_id, line_id
                    ]) and not password:
            raise AE103()
        # remove None values from the fields to prevent error.
        for k, v in list(fields.items()):
            if v is None:
                del fields[k]

        user = self.model(username=username,
                          nickname=nickname or username,
                          facebook_id=facebook_id,
                          twitter_id=twitter_id,
                          instagram_id=instagram_id,
                          line_id=line_id,
                          email=email,
                          password=password,
                          is_active=True,
                          extra=extra,
                          activity_settings=activity_settings,
                          **fields)
        user.full_clean()
        user.save(using=self._db)
        # set temporal flag to let view know that the user is just created and return 201 response.
        user.is_new = True
        return user
Пример #46
0
    def save(self, *args, **kwargs):
        """
        Clean the data before saving to the database also generate api key if no key
        :param args:
        :param kwargs:
        :return:
        """
        self.username = self.normalize_username(self.username)
        self.work_email = BaseUserManager.normalize_email(self.work_email)

        if self.reporting_manager:
            try:
                _reporting_manager = Employee.get_employee_by_email(
                    self.reporting_manager)
            except err.NotFoundError:
                log.error(self.reporting_manager)
                raise err.ValidationError({
                    "reporting_manager":
                    "Given reporting manager not available"
                })
            if _reporting_manager.id == self.id:
                raise err.ValidationError({
                    "reporting_manager":
                    "You cannot assign yourself as reporting manager"
                })
            self.reporting_manager = _reporting_manager.id

        if not hasattr(self, "_api_key") or not getattr(self, "_api_key"):
            log.info("Creating a new api key")
            api_key, key = APIKey.objects.create_key(name=self.work_email)
            self._api_key = APIKey.objects.get_from_key(key)

        _fields = ("employee_id", )
        for _field in _fields:
            val = getattr(self, _field)
            if val:
                setattr(self, _field, val.lower().strip())

        if not self.graduated_year:
            self.graduated_year = None

        # TODO default array doesnt work - Hack
        if not getattr(self, "skills"):
            self.skills = list()

        return super(self.__class__, self).save(*args, **kwargs)
Пример #47
0
def custom_create_user(username, email=None, password=None, **extra_fields):
    """
    Creates and saves a User with the given username, email and password.
    """
    now = timezone.now()
    if not username:
        raise ValueError('The given username must be set')
    email = BaseUserManager.normalize_email(email)
    user_fields = dict(
        username=username, email=email, is_staff=False, is_active=True,
        is_superuser=False, date_joined=now,
    )
    user_fields.update(extra_fields)
    user = User(**user_fields)
    user.set_password(password)
    user.save()
    return user
Пример #48
0
    def create_user(self, username, email, password=None):
        """
        Creates and saves a User with the given email, date of
        birth and password.
        """
        print "HERE DETECTION"
        if not email:
            raise ValueError('Users must have an email address')

        user = self.model(
            username=username,
            email=BaseUserManager.normalize_email(email),
        )

        user.set_password(password)
        user.save(using=self._db)
        return user
Пример #49
0
    def create_user(self, email, first_name, password=None):
        """
        Creates and saves a User with the given email, first name and password.
        """
        now = timezone.now()
        if not email:
            raise ValueError('Email must be supplied.')
        if not first_name:
            raise ValueError('First name must be set.')
        email = BaseUserManager.normalize_email(email)

        user = self.model(email=email, first_name=first_name,
                          is_active=False, is_admin=False,
                          last_login=now, date_joined=now)

        user.set_password(password)
        user.save(using=self._db)
        return user
Пример #50
0
    def sync_user_data(self, django_user, google_user):
        # Now make sure we update is_superuser and is_staff appropriately
        changed_fields = []

        is_superuser = users.is_current_user_admin()

        if is_superuser != django_user.is_superuser:
            django_user.is_superuser = django_user.is_staff = is_superuser
            changed_fields += ['is_superuser', 'is_staff']

        email = BaseUserManager.normalize_email(google_user.email())  # Normalizes the domain only.

        if email != django_user.email:
            django_user.email = email
            changed_fields += ['email', 'email_lower']

        if changed_fields:
            django_user.save(update_fields=changed_fields)
Пример #51
0
    def create_user(self, email, name, password=None):
        # validación:
        if not email:
            raise ValueError('Users must have an email address')
        if not name:
            raise ValueError('Users must have a name')
        try:
            User.objects.get(email=email)
            raise forms.ValidationError(self.error_messages['duplicate_email'])
        except User.DoesNotExist:
            pass

        user = User()

        user.email_wtc = BaseUserManager.normalize_email(email),
        user.name = name
        if password is None:
            user.set_password(self.make_random_password())
        else:
            user.set_password(password)

        user.is_superuser = False
        user.save(using=self._db)
Пример #52
0
 def create_user(
         self, 
         email,
         first_name,
         last_name,
         organization = None,
         job_title    = None,
         bio          = None,
         password     = None
 ):
     """
     Creates a standard user with no administrative privledges
     """
     if not email:
         raise ValueError('Users must provide an email')
         
     if not first_name:
         raise ValueError('Users must provide a first name')
     
     if not last_name:
         raise ValueError('Users must provide a last name')
         
     if not organization:
         raise ValueError('Users must provide an email address')
         
     # Note: a biography and job_title are not required
     user = self.model(
         email=BaseUserManager.normalize_email(email),
         first_name=first_name,
         last_name=last_name,
         organization=organization,
         job_title=job_title,
         bio=bio
     )
     user.set_password(password)
     user.save(using=self._db)
     return user
Пример #53
0
    def process_request(self, request):

        django_user = get_user(request)
        google_user = users.get_current_user()

        if django_user.is_anonymous() and google_user:
            #If there is a google user, but we are anonymous, log in!
            django_user = authenticate(google_user=google_user)
            if django_user:
                login(request, django_user)
        elif not django_user.is_anonymous() and not google_user:
            #If we are logged in with django, but not longer logged in with Google
            #then log out
            logout(request)
            django_user = request.user

        request.user = django_user

        backend_str = request.session.get(BACKEND_SESSION_KEY)

        #Now make sure we update is_superuser and is_staff appropriately
        if backend_str == 'djangae.contrib.gauth.backends.AppEngineUserAPI':
            is_superuser = users.is_current_user_admin()
            google_email = BaseUserManager.normalize_email(users.get_current_user().email())
            resave = False

            if is_superuser != django_user.is_superuser:
                django_user.is_superuser = django_user.is_staff = is_superuser
                resave = True

            #for users which already exist, we want to verify that their email is still correct
            if django_user.email != google_email:
                django_user.email = google_email
                resave = True

            if resave:
                django_user.save()
Пример #54
0
    def authenticate(self, **credentials):
        """
        Handles authentication of a user from the given credentials.
        Credentials must be a combination of 'request' and 'google_user'.
        If any other combination of credentials are given then we raise a TypeError, see
        authenticate() in django.contrib.auth.__init__.py.
        """

        User = get_user_model()

        if not issubclass(User, GaeAbstractBaseUser):
            raise ImproperlyConfigured(
                "djangae.contrib.auth.backends.AppEngineUserAPI requires AUTH_USER_MODEL to be a "
                " subclass of djangae.contrib.auth.base.GaeAbstractBaseUser."
            )

        if len(credentials) != 1:
            # Django expects a TypeError if this backend cannot handle the given credentials
            raise TypeError()

        google_user = credentials.get("google_user", None)

        if google_user:
            user_id = google_user.user_id()
            email = google_user.email().lower()
            try:
                return User.objects.get(username=user_id)
            except User.DoesNotExist:
                try:
                    existing_user = User.objects.get(email=BaseUserManager.normalize_email(email))
                except User.DoesNotExist:
                    force_pre_creation = getattr(settings, "DJANGAE_FORCE_USER_PRE_CREATION", False)
                    user_is_admin = users.is_current_user_admin()
                    if force_pre_creation and not user_is_admin:
                        # Indicate to Django that this user is not allowed
                        return
                    return User.objects.create_user(user_id, email)

                # If the existing user was precreated, update and reuse it
                if existing_user.username is None:
                    if (
                        getattr(settings, "DJANGAE_ALLOW_USER_PRE_CREATION", False)
                        or
                        # Backwards compatibility, remove before 1.0
                        getattr(settings, "ALLOW_USER_PRE_CREATION", False)
                    ):
                        # Convert the pre-created User object so that the user can now login via
                        # Google Accounts, and ONLY via Google Accounts.
                        existing_user.username = user_id
                        existing_user.last_login = timezone.now()
                        existing_user.save()
                        return existing_user

                    # There's a precreated user but user precreation is disabled
                    # This will fail with an integrity error
                    from django.db import IntegrityError

                    raise IntegrityError(
                        "GAUTH: Found existing User with email=%s and username=None, "
                        "but user precreation is disabled." % email
                    )

                # There is an existing user with this email address, but it is tied to a different
                # Google user id.  As we treat the user id as the primary identifier, not the email
                # address, we leave the existing user in place and blank its email address (as the
                # email field is unique), then create a new user with the new user id.
                else:
                    logging.info(
                        "GAUTH: Creating a new user with an existing email address "
                        "(User(email=%s, pk=%s))" % (email, existing_user.pk)
                    )
                    with self.atomic(**self.atomic_kwargs):
                        existing_user = User.objects.get(pk=existing_user.pk)
                        existing_user.email = None
                        existing_user.save()
                        return User.objects.create_user(user_id, email)
        else:
            raise TypeError()  # Django expects to be able to pass in whatever credentials it has, and for you to raise a TypeError if they mean nothing to you
Пример #55
0
    def authenticate(self, google_user=None):
        """
        Handles authentication of a user from the given credentials.
        Credentials must be a 'google_user' as returned by the App Engine
        Users API.
        """
        if google_user is None:
            return None

        User = get_user_model()

        if not issubclass(User, GaeAbstractBaseUser):
            raise ImproperlyConfigured(
                "AppEngineUserAPIBackend requires AUTH_USER_MODEL to be a "
                " subclass of djangae.contrib.auth.base.GaeAbstractBaseUser."
            )

        user_id = google_user.user_id()
        email = BaseUserManager.normalize_email(google_user.email())

        try:
            # User exists and we can bail immediately.
            return User.objects.get(username=user_id)
        except User.DoesNotExist:
            pass

        auto_create = should_create_unknown_user()
        user_is_admin = users.is_current_user_admin()

        if not (auto_create or user_is_admin):
            # User doesn't exist and we aren't going to create one.
            return None

        # OK. We will grant access. We may need to update an existing user, or
        # create a new one, or both.

        # Those 3 scenarios are:
        # 1. A User object has been created for this user, but that they have not logged in yet.
        # In this case wefetch the User object by email, and then update it with the Google User ID
        # 2. A User object exists for this email address but belonging to a different Google account.
        # This generally only happens when the email address of a Google Apps account has been
        # signed up as a Google account and then the apps account itself has actually become a
        # Google account. This is possible but very unlikely.
        # 3. There is no User object realting to this user whatsoever.

        try:
            existing_user = User.objects.get(email=email)
        except User.DoesNotExist:
            existing_user = None

        if existing_user:
            if existing_user.username is None:
                # We can use the existing user for this new login.
                existing_user.username = user_id
                existing_user.email = email
                existing_user.last_login = timezone.now()
                existing_user.save()

                return existing_user
            else:
                # We need to update the existing user and create a new one.
                with self.atomic(**self.atomic_kwargs):
                    existing_user = User.objects.get(pk=existing_user.pk)
                    existing_user.email = None
                    existing_user.save()

                    return User.objects.create_user(user_id, email=email)
        else:
            return User.objects.create_user(user_id, email=email)
Пример #56
0
    def authenticate(self, google_user=None):
        """
        Handles authentication of a user from the given credentials.
        Credentials must be a 'google_user' as returned by the App Engine
        Users API.
        """

        User = get_user_model()

        if not issubclass(User, GaeAbstractBaseUser):
            raise ImproperlyConfigured(
                "AppEngineUserAPIBackend requires AUTH_USER_MODEL to be a "
                " subclass of djangae.contrib.auth.base.GaeAbstractBaseUser."
            )

        if google_user is None:
            # users.get_current_user() can return None.
            return None

        user_id = google_user.user_id()
        email = BaseUserManager.normalize_email(google_user.email())
        try:
            return User.objects.get(username=user_id)
        except User.DoesNotExist:
            try:
                existing_user = User.objects.get(email=BaseUserManager.normalize_email(email))
            except User.DoesNotExist:
                force_pre_creation = getattr(settings, 'DJANGAE_FORCE_USER_PRE_CREATION', False)
                user_is_admin = users.is_current_user_admin()
                if force_pre_creation and not user_is_admin:
                    # Indicate to Django that this user is not allowed
                    return
                return User.objects.create_user(user_id, email)

            # If the existing user was precreated, update and reuse it
            if existing_user.username is None:
                if (
                    getattr(settings, 'DJANGAE_ALLOW_USER_PRE_CREATION', False) or
                    # Backwards compatibility, remove before 1.0
                    getattr(settings, 'ALLOW_USER_PRE_CREATION', False)
                ):
                    # Convert the pre-created User object so that the user can now login via
                    # Google Accounts, and ONLY via Google Accounts.
                    existing_user.username = user_id
                    existing_user.last_login = timezone.now()
                    existing_user.save()
                    return existing_user

                # There's a precreated user but user precreation is disabled
                # This will fail with an integrity error
                from django.db import IntegrityError
                raise IntegrityError(
                    "GAUTH: Found existing User with email=%s and username=None, "
                    "but user precreation is disabled." % email
                )

            # There is an existing user with this email address, but it is tied to a different
            # Google user id.  As we treat the user id as the primary identifier, not the email
            # address, we leave the existing user in place and blank its email address (as the
            # email field is unique), then create a new user with the new user id.
            else:
                logging.info(
                    "GAUTH: Creating a new user with an existing email address "
                    "(User(email=%r, existing pk=%r))", email, existing_user.pk
                )
                with self.atomic(**self.atomic_kwargs):
                    existing_user = User.objects.get(pk=existing_user.pk)
                    existing_user.email = None
                    existing_user.save()
                    return User.objects.create_user(user_id, email)
Пример #57
0
    def authenticate(self, google_user=None):
        """
        Handles authentication of a user from the given credentials.
        Credentials must be a 'google_user' as returned by the App Engine
        Users API.
        """
        if google_user is None:
            return None

        User = get_user_model()

        if not issubclass(User, GaeAbstractBaseUser):
            raise ImproperlyConfigured(
                "AppEngineUserAPIBackend requires AUTH_USER_MODEL to be a "
                " subclass of djangae.contrib.auth.base.GaeAbstractBaseUser."
            )

        user_id = google_user.user_id()
        email = BaseUserManager.normalize_email(google_user.email())  # Normalizes the domain only.

        try:
            # User exists and we can bail immediately. With one caveat.
            user = User.objects.get(username=user_id)
            # Ensure that the user has got both the `email` and `email_lower` fields populated
            if not user.email_lower:
                # The user existed before the introduction of the `email_lower` field. Update it.
                user.email = email
                # The save will also update the email_lower field
                user.save(update_fields=['email', 'email_lower'])
            return user
        except User.DoesNotExist:
            pass

        auto_create = should_create_unknown_user()
        user_is_admin = users.is_current_user_admin()

        try:
            # Users that existed before the introduction of the `email_lower` field will not have
            # that field, but will mostly likely have a lower case email address because we used to
            # lower case the email field
            existing_user = User.objects.get(Q(email_lower=email.lower()) | Q(email=email.lower()))
        except User.DoesNotExist:
            if not (auto_create or user_is_admin):
                # User doesn't exist and we aren't going to create one.
                return None

            existing_user = None

        # OK. We will grant access. We may need to update an existing user, or
        # create a new one, or both.

        # Those 3 scenarios are:
        # 1. A User object has been created for this user, but that they have not logged in yet.
        # In this case we fetch the User object by email, and then update it with the Google User ID
        # 2. A User object exists for this email address but belonging to a different Google account.
        # This generally only happens when the email address of a Google Apps account has been
        # signed up as a Google account and then the apps account itself has actually become a
        # Google account. This is possible but very unlikely.
        # 3. There is no User object realting to this user whatsoever.

        if existing_user:
            if existing_user.username is None:
                # We can use the existing user for this new login.
                existing_user.username = user_id
                existing_user.email = email
                existing_user.last_login = timezone.now()
                existing_user.save()

                return existing_user
            else:
                # We need to update the existing user and create a new one.
                with self.atomic(**self.atomic_kwargs):
                    existing_user = User.objects.get(pk=existing_user.pk)
                    existing_user.email = ""
                    existing_user.save()

                    return User.objects.create_user(user_id, email=email)
        else:
            # Create a new user, but account for another thread having created it already in a race
            # condition scenario. Our logic cannot be in a transaction, so we have to just catch this.
            try:
                return User.objects.create_user(user_id, email=email)
            except IntegrityError:
                return User.objects.get(username=user_id)