def get_update_user(username, fields): try: user = User.objects.get(username=username) except User.DoesNotExist: # Generate random password (we won't be using it anyway) pw = base64.b64encode(os.urandom(20)) user = User(username=username, password=pw) # Get firstname, last name names = fields[REALNAME].split(" ") user.first_name = "" user.last_name = "" if len(names) == 1: user.first_name = names[0] elif len(names) > 1: user.first_name = " ".join(names[0:-1]) user.last_name = names[-1] user.email = fields[EMAIL] user.is_active = True user.is_staff = True user.save() return user
def get_or_create_user(first_name=None, last_name=None, always_new=True): if always_new == False: # if it's false, we will randomly decide whether we want to make a new case or not. if random.random() > CREATE_NEW_PERCENTAGE: # let's do a 25/75 create/existing split print "Returning existing user" return User.objects.all()[random.randrange(0, User.objects.all().count())] else: print "Creating new user" user = User() if first_name == None: user.first_name = uuid.uuid1().hex[0:20] else: user.first_name = first_name if last_name == None: user.last_name = uuid.uuid1().hex[0:20] else: user.last_name = last_name username = "******" % (user.first_name.replace("'", ""), user.last_name.replace("'", "")) user.username = username[0:30].lower() try: exists = User.objects.get(username=user.username) return exists except: user.save() return user
def save(self, commit=True): if not self.edit: persona = super(PersonaForm, self).save(commit=False) nUsuario = User() nUsuario.username = persona.identificacion nUsuario.first_name = persona.nombre nUsuario.last_name = persona.apellido nUsuario.email = persona.email contrase = Util.contrasena_aleatoria() nUsuario.set_password(contrase) nUsuario.save() persona.usuario = nUsuario persona.edad = Util.getEdad(persona.fechaNacimiento) self.personaServicio.insert(persona) correoUtil=CorreoUtil() correoUtil.correoCreacionEmpleado(persona.identificacion, contrase, persona) else: persona = super(PersonaForm, self).save(commit=False) persona.edad = Util.getEdad(persona.fechaNacimiento) nUsuario = persona.usuario nUsuario.first_name = persona.nombre nUsuario.last_name = persona.apellido nUsuario.email = persona.email self.personaServicio.update(persona)
def test_normalusage(self): """ Tests that ldaplib works correctly or not. """ user=User() user.username="******" user.first_name="first" user.last_name="last" user.email="*****@*****.**" user.is_active=True ldaplib.save(user) ld=ldaplib.init_bind() result=ldaplib.search(user.username,ld) self.assertEqual(1,len(result)) self.assertEqual(False,ldaplib.searchDenylist(user.username,ld)) ld.unbind() password="******" ldaplib.changePassword(user,password) user.last_name="lastmod" user.email="*****@*****.**" ldaplib.save(user) user.is_active=False ldaplib.save(user) ld=ldaplib.init_bind() #result=ldaplib.search(user.username,ld) #print(result) self.assertEqual(True,ldaplib.searchDenylist(user.username,ld)) ld.unbind() ldaplib.delete(user)
def run(): from django.contrib.sites.models import Site django_site_1 = Site.objects.all()[0] django_site_1.domain = u'localhost:8000' django_site_1.name = u'localhost:8000' django_site_1.save() from corehq.apps.domain.models import Domain domain_domain_1 = Domain() domain_domain_1.name = u'test' domain_domain_1.is_active = True domain_domain_1.save() from django.contrib.auth.models import User auth_user_1 = User() auth_user_1.username = u'admin' auth_user_1.first_name = u'' auth_user_1.last_name = u'' auth_user_1.email = u'*****@*****.**' auth_user_1.password = u'sha1$f8d4b$b6d2f6431c423687c227ad261caa46faaf16917d' auth_user_1.is_staff = True auth_user_1.is_active = True auth_user_1.is_superuser = True auth_user_1.last_login = datetime.datetime(2010, 9, 10, 14, 40, 30, 501416) auth_user_1.date_joined = datetime.datetime(2010, 9, 10, 14, 37, 22, 677987) auth_user_1.save() auth_user_2 = User() auth_user_2.username = u'test' auth_user_2.first_name = u'test' auth_user_2.last_name = u'test' auth_user_2.email = u'*****@*****.**' auth_user_2.password = u'sha1$f09cf$551ac80804020ad3e1d9943a583ee1ea52284797' auth_user_2.is_staff = False auth_user_2.is_active = True auth_user_2.is_superuser = False auth_user_2.last_login = datetime.datetime(2010, 9, 10, 14, 40, 53, 818764) auth_user_2.date_joined = datetime.datetime(2010, 9, 10, 19, 40, 6, 159442) auth_user_2.save() couch_user = auth_user_2.get_profile().get_couch_user() couch_user.add_domain_membership(domain_domain_1.name) couch_user.save() from corehq.apps.domain.models import RegistrationRequest domain_registration_request_1 = RegistrationRequest() domain_registration_request_1.tos_confirmed = True domain_registration_request_1.request_time = datetime.datetime(2010, 9, 10, 19, 40, 6, 159442) domain_registration_request_1.request_ip = '127.0.0.1' domain_registration_request_1.activation_guid = u'368ce6b8bd1311df932c5cff350164a3' domain_registration_request_1.confirm_time = datetime.datetime(2010, 9, 10, 14, 40, 25, 219783) domain_registration_request_1.confirm_ip = '127.0.0.1' domain_registration_request_1.domain = domain_domain_1 domain_registration_request_1.new_user = auth_user_2 domain_registration_request_1.requesting_user = None domain_registration_request_1.save()
def run(): from django.contrib.auth.models import User auth_user_1 = User() auth_user_1.username = u"dmsadmin" auth_user_1.first_name = u"" auth_user_1.last_name = u"" auth_user_1.email = u"" auth_user_1.set_password("dmsadmin") auth_user_1.is_staff = True auth_user_1.is_active = True auth_user_1.is_superuser = True auth_user_1.date_joined = datetime.datetime.now() auth_user_1.save() auth_user_2 = User() auth_user_2.username = u"dmsuser" auth_user_2.first_name = u"" auth_user_2.last_name = u"" auth_user_2.email = u"" auth_user_1.set_password("dmsuser") auth_user_2.is_staff = False auth_user_2.is_active = True auth_user_2.is_superuser = False auth_user_2.date_joined = datetime.datetime.now() auth_user_2.save() from django.contrib.sites.models import Site django_site_1 = Site() django_site_1.domain = u"localhost:8000" django_site_1.name = u"Development Server" django_site_1.save()
def callback_view(request): if request.GET.has_key('bounceback'): request.session['bounceback'] = request.GET['bounceback'] if request.GET.has_key("code"): code = request.GET.get('code') api = TroveAPI(TROVE['ID'], TROVE['SECRET'], TROVE['CALLBACK_URL']) oauth_token = api.get_access_token(code) else: # this might be a /add callback response (instead of a loginwith) if request.user.is_authenticated(): return __bounceback__(request) else: return redirect('trove-login') try: at = TroveAccessToken.objects.get(oauth_token_as_string=oauth_token) except TroveAccessToken.DoesNotExist: # we have to create one! -- although this does run into issues with users having different access tokens user_info = api.get_user_info() try: u = User.objects.get(username=user_info['trove_internal_id']) except User.DoesNotExist: u = User() u.username = user_info['trove_internal_id'] try: if user_info['first_name'] is not None: u.first_name = to_unicode_or_bust(user_info['first_name']) else: u.first_name = " " except: u.first_name = " " try: if user_info['last_name'] is not None: u.last_name = to_unicode_or_bust(user_info['last_name']) else: u.last_name = "" except: u.last_name = "" u.set_unusable_password() u.email = "" u.is_active = True u.save() at = TroveAccessToken() at.user = u at.oauth_token_as_string = oauth_token at.save() user = authenticate(access_token=oauth_token) if user is not None: if user.is_active: login(request, user) return __bounceback__(request) else: return redirect('trove-login') else: return redirect('trove-login')
def students(): '''sets up students''' filepath=os.path.join(os.getcwd(),SETUP_SUPPORT_FOLDER,'student_photos','college_studentlist') if os.path.exists(os.path.join(filepath,'student_list_clean')): f=file(os.path.join(filepath,'student_list_clean'),'r') import pickle data=pickle.load(f) f.close() #default picture picpath=os.path.join(filepath,'default.jpg') f=file(picpath) #add students for course in data.keys(): name=course.strip().strip('III') name=name.strip('II').strip('I').replace('YEAR','') name=name.replace('-SEC A','').replace('-SEC B','') crs=office.models.course.objects.get(name=name) for sem in data[course].keys(): for stu in data[course][sem]: if 'Student Name' in stu: continue u=User() u.username=str(stu).lower().replace(' ','') u.first_name=str(stu.split(' ')[0]).lower() u.last_name=str(stu.split(' ')[-1]).lower() if u.last_name==u.first_name: u.last_name='' u.set_password('asd') try: u.save() except Exception as e: print '----------' print e print '----------' print u.username uname=random.sample(u.username,len(u.username)) u.username=''.join(uname) print u.username u.save() print '----------' a=office.models.student() a.user=u a.picture=File(f) a.nickname=random_fill(stu.replace(' ',''),10) #a.course=office.models.course.objects.first() a.course=crs a.current_semester=(2*sem)-1 a.save() f.close()#close picture file else: import student_scraper as stsc stsc.scrape() students()
def run(): from django.contrib.auth.models import User auth_user_1 = User() auth_user_1.username = u'alice' auth_user_1.first_name = u'' auth_user_1.last_name = u'' auth_user_1.email = u'' auth_user_1.password = u'sha1$9235f$5e8d6d4d61224eec4020f9ff627f41de2dab0d1b' auth_user_1.is_staff = False auth_user_1.is_active = True auth_user_1.is_superuser = False auth_user_1.last_login = datetime.datetime(2012, 11, 7, 18, 11, 56, 627668) auth_user_1.date_joined = datetime.datetime(2012, 10, 19, 4, 33, 45, 501602) try: auth_user_1.save() except: pass auth_user_2 = User() auth_user_2.username = u'admin' auth_user_2.first_name = u'' auth_user_2.last_name = u'' auth_user_2.email = u'*****@*****.**' auth_user_2.password = u'sha1$509de$45ec22f10561e8d3a3e2a89c71b6ec19f472bec8' auth_user_2.is_staff = True auth_user_2.is_active = True auth_user_2.is_superuser = True auth_user_2.last_login = datetime.datetime(2012, 11, 7, 20, 24, 35, 821631) auth_user_2.date_joined = datetime.datetime(2011, 7, 30, 12, 14, 49) try: auth_user_2.save() except: pass auth_user_3 = User() auth_user_3.username = u'steph' auth_user_3.first_name = u'' auth_user_3.last_name = u'' auth_user_3.email = u'' auth_user_3.password = u'sha1$457c2$d1ca65eae410788ab8839166f08153cb89f6366d' auth_user_3.is_staff = False auth_user_3.is_active = True auth_user_3.is_superuser = False auth_user_3.last_login = datetime.datetime(2012, 11, 7, 20, 25, 23, 952727) auth_user_3.date_joined = datetime.datetime(2012, 10, 19, 2, 49, 44, 681549) try: auth_user_3.save() except: pass
def handle(self, *args, **options): self.stdout.write('Creating user\n') user = User() username = raw_input("Username (default: %s): " % getuser()) if options["username"] is None else options["username"] if not username: username = getuser() user.username = username password = getpass("Password (default: 'test'): ") if options["password"] is None else options["password"] if not password: password = '******' first_name = raw_input("Firstname (default: John): ") if options["first_name"] is None else options["first_name"] if not first_name: first_name = "John" last_name = raw_input("Lastname (default: Smith): ") if options["last_name"] is None else options["last_name"] if not last_name: last_name = "Smith" user.first_name = first_name user.last_name = last_name user.set_password(password) user.save() profile = user.get_profile() profile.name = first_name + " " + last_name profile.email = '*****@*****.**' profile.photo = '/static/images/gaston.gif' profile.save() #Second user for tests user2 = User() user2.username="******" user2.first_name="Bertrand" user2.last_name="Labévue" user2.set_password(password) user2.save() profile2 = user2.get_profile() profile2.name = user2.first_name + " " + user2.last_name profile2.email = '*****@*****.**' profile2.photo = '/static/images/labevue.gif' profile2.save() self.stdout.write("Second user {} with password {} created\n".format( user2.username, password )) tree = json.load(open('parsing/tree.json')) self.courseList = json.load(open('parsing/cours.json')) self.USER = profile Root = Category.objects.create(name='P402', description='Bring back real student cooperation !') self.walk(tree, Root) self.stdout.write("\n")
def save(self): data = self.cleaned_data password = data.get('password1') u = User() u.username = data.get('username') u.password = make_password(password) u.email = data.get('email') u.first_name = data.get('first_name') u.last_name = data.get('last_name') u.is_active = True u.is_superuser = False u.save() up = Profile() up.user = u up.info = data.get('info') if data.get('avatar') is None: image_url = 'http://api.adorable.io/avatars/100/%s.png' % u.username content = urllib.urlretrieve(image_url) up.avatar.save('%s.png' % u.username, File(open(content[0])), save=True) else: avatar = data.get('avatar') up.avatar.save('%s_%s' % (u.username, avatar.name), avatar, save=True) up.save() return authenticate(username=u.username, password=password)
def signup(request): context = {} context['title'] = _('Register') user = User() if request.user.is_authenticated(): return redirect('accounts_accounts') userProfile = UserProfile() if request.method == 'POST': userForm = UserForm(request.POST, instance=user) userProfileForm = UserProfileForm(request.POST, instance=userProfile) if userForm.is_valid() and userProfileForm.is_valid(): userData = userForm.cleaned_data user.username = userData['username'] user.first_name = userData['first_name'] user.last_name = userData['last_name'] user.email = userData['email'] user.set_password(userData['password']) user.save() userProfile = user.get_profile() userProfileData = userProfileForm.cleaned_data userProfile.gender = userProfileData['gender'] userProfile.birthday = userProfileData['birthday'] userProfile.save() user = authenticate(username=userData['username'], password=userData['password']) login(request, user) return redirect('accounts_accounts') else: userForm = UserForm(instance=user) userProfileForm = UserProfileForm(instance=userProfile) context['userForm'] = userForm context['userProfileForm'] = userProfileForm return render_to_response('accounts/register.html', context, context_instance=RequestContext(request))
def add_user(request): if not request.user.has_perm("auth.add_user"): return HttpResponseForbidden("You do not have permission to maintain users") if request.method == "POST": form = AddUserForm(request.POST) if request.POST.get("cancel"): return redirect("maintain_users") if form.is_valid(): data = form.cleaned_data user = User() user.username = data["username"] user.first_name = data["first_name"] user.last_name = data["last_name"] user.email = data["email"] user.is_active = bool(data.get("is_active")) if data["mode_password"] == EditUserForm.PASSWD_MANUAL_RESET: user.set_password(data["password1"]) user.save() for grp in data["groups"]: user.groups.add(grp) return redirect("maintain_users") else: form = AddUserForm() return render(request, "users/add_user.html", { 'form': form, })
def create_user(): user = User() user.first_name = 'Ciccio' user.last_name = 'Panda' user.username = '******' user.password = make_password('ciccio') return user
def admin_reader_add(request): if request.method == 'POST': # Handle form submission. form = ReaderForm(request.POST) # Initialize form with data. if form.is_valid(): # First create a new User object. user = User() # Process the data in form.cleaned_data user.email = form.cleaned_data['email'] user.first_name = form.cleaned_data['first_name'] user.last_name = form.cleaned_data['last_name'] user.username = form.cleaned_data['username'] user.password = make_password(form.cleaned_data['password']) user.save() # New create a reader object. reader = Reader() reader.user = user reader.address = form.cleaned_data['address'] reader.phone_number = form.cleaned_data['phone_number'] reader.save() return HttpResponseRedirect(reverse('admin_reader')) # Redirect after POST else: form = ReaderForm() # An unbound form return render(request, 'library/admin_reader_add.html', { 'form': form, })
def newaccount_view(request): if request.method == 'POST': form = NewAccountForm(request.POST) info = "Inicializando" if form.is_valid(): first_name = form.cleaned_data['first_name'] last_name = form.cleaned_data['last_name'] email = form.cleaned_data['email'] username = form.cleaned_data['username'] password = form.cleaned_data['password'] n = User() n.first_name = first_name; n.last_name = last_name; n.email = email; n.username = username; n.set_password(password); n.save(); info = "new account :)" form = NewAccountForm() ctx = {'form': form, 'info': info} return render_to_response('home/newaccount.html', ctx, context_instance=RequestContext(request)) else: info = ":( no save... grown data" form = NewAccountForm() ctx = {'form': form, 'info': info} return render_to_response('home/newaccount.html', ctx, context_instance=RequestContext(request)) else: form = NewAccountForm() ctx = {'form': form} return render_to_response('home/newaccount.html', ctx, context_instance=RequestContext(request))
def createsuperuser(): team = Team() team.name = "CSGO_Admin" team.university = "UQUAM" team.token = "ADMINTOKEN" team.score = 0 team.hidden = True team.save() univ_mail = "uqam.qc.ca" user = User() user.email = "player@" + univ_mail user.username = "******" user.first_name = "The" user.last_name = "Spear" user.is_staff = True user.is_superuser = True user.set_password("12qwaszx") user.save() player = Player() user.player = player player.last_name = "Spear" player.first_name = "The" player.display_name = "Klammydia" player.team = team player.save()
def getOrCreateUser(cls, username, email, first_name, last_name, picture): """ find user associated with username and updates its data or create a user :param username: :param email: :param first_name: :param last_name: :param picture: :return: User """ try: user = User.objects.get(username=username) profile = user.userprofile credential = profile.credential except ObjectDoesNotExist: user = User() user.email = email user.username = username profile = UserProfile() credential = profile.generate_credential() user.first_name = first_name user.last_name = last_name user.save() profile.credential = credential profile.picture = picture profile.user = user profile.save() return user
def create_user(self, request=None, random_password=False): """ Given a validated form, return a new User. Takes care of referrals too (if an HttpRequest object is passed). """ cd = self.cleaned_data # Create user user = User() user.username = cd['username'] user.first_name = cd['first_name'] user.last_name = cd['last_name'] user.email = cd['email'] user.save() if random_password: user.random_password = "".join(random.sample(string.lowercase, 8)) user.set_password(user.random_password) else: user.set_password(cd['password']) user.save() if request is not None: # If we have a referral code, set the profile's 'referral' field to it. # Note: there *should* be a profile here, as a signal will have created it automatically. name = request.session.get('referral', '').strip() if name: referral, _ = enginemodels.Referral.objects.get_or_create(name__iexact=name) profile = user.get_profile() profile.referral = referral profile.save() return user
def authenticate(self, username=None, password=None): t_user = services.t_login(username, password) #We are using the colections data to set group permissions... somehow if t_user: try: user = User.objects.get(username=t_user['userName']) except User.DoesNotExist: # Create a new user. password is not chekced so we don't store it here # user = User(username=t_user['userName'], password="******") user = User(username=t_user['userName']) #Transkribus has authority here so update the user data each time... user.email = t_user['email'] user.first_name = t_user['firstname'] user.last_name = t_user['lastname'] if t_user['isAdmin'] == 'true': user.is_superuser = True user.save() #Extend the user object with some extra data from transkribus try: tsdata = TSData.objects.get(user=user) except TSData.DoesNotExist: tsdata = TSData.objects.create(user=user) tsdata.gender=t_user['gender'] tsdata.affiliation=t_user['affiliation'] tsdata.save() #services.t_collections() return user return None
def register_service(user_info, unique_id=None, access_token=None, impersonate=None): # FIXME: massive race condition potential here unique_id = unique_id or user_info['id'] try: service = models.LinkedInService.objects.get(unique_id=unique_id) except models.LinkedInService.DoesNotExist: user = User(password=hashlib.md5(str(random.random())).hexdigest()) service = models.LinkedInService() else: user = service.user screen_name = ''.join((user_info['firstName'], user_info['lastName'])) if not user.username: user.username = get_unique_username(screen_name) if not user.first_name: user.first_name = user_info['firstName'] if not user.last_name: user.last_name = user_info['lastName'] user.save() # update service service.user = user service.unique_id = unique_id service.screen_name = screen_name[:20] service.impersonated_unique_id = impersonate or '' service.access_token = access_token service.save() post_register_service.send(sender=models.LinkedInService, instance=service, user_info=user_info) return service
def authenticate(self, username=None, password=None): if pam.authenticate(username, password, settings.PAM_SERVICE): try: user = User.objects.get(username=username) user.set_password(password) user.save() except User.DoesNotExist: user = User(username=username, password=password) user.save() if settings.USE_LDAP: import ldap l = ldap.initialize(settings.LDAP_HOST) l.set_option(ldap.OPT_REFERRALS, 0) l.set_option(ldap.OPT_PROTOCOL_VERSION, 3) l.simple_bind_s(settings.LDAP_BIND_DN, settings.LDAP_BIND_PASS) r = l.search(settings.LDAP_SEARCH_PATH, ldap.SCOPE_ONELEVEL, "(uid=%s)" % username, [settings.LDAP_FIRST_NAME, settings.LDAP_LAST_NAME, settings.LDAP_EMAIL, settings.LDAP_DATE_JOINED]) r = l.result(r) user.first_name = r[1][0][1][settings.LDAP_FIRST_NAME][0] user.last_name = r[1][0][1][settings.LDAP_LAST_NAME][0] user.email = r[1][0][1][settings.LDAP_EMAIL][0] date_joined = r[1][0][1][settings.LDAP_DATE_JOINED][0] user.date_joined = datetime.strptime(date_joined[:-1], '%Y%m%d%H%M%S') user.save() return user return None
def ldap_create_user_default(user_info, request): """takes the result returned by the :func:`ldap_authenticate` and returns a :class:`UserAssociation` object """ # create new user in local db user = User() user.username = user_info.get('django_username', user_info['ldap_username']) user.set_unusable_password() user.first_name = user_info['first_name'] user.last_name = user_info['last_name'] user.email = user_info['email'] user.is_staff = False user.is_superuser = False user.is_active = True user.save() user_registered.send(None, user=user, request=request) LOG.info('Created New User : [{0}]'.format(user_info['ldap_username'])) assoc = UserAssociation() assoc.user = user assoc.openid_url = user_info['ldap_username'] + '@ldap' assoc.provider_name = 'ldap' assoc.save() return assoc
def authenticate(self,username=None,password=None): logger.info("AD auth backend for %s" % username) aduser = ADUser(username) if not aduser.connect(password): return None user = None try: user = User.objects.get(username=username) except User.DoesNotExist: user = User(username=username, is_staff = False, is_superuser = False) if not aduser.get_data(): logger.warning("AD auth backend failed when reading data for %s. User detail data won't be updated in User model." % username) else: # NOTE: update user data exchange to User model assert user.username==aduser.username user.first_name=aduser.first_name user.last_name=aduser.last_name user.email=aduser.email #user.set_password(password) logger.warning("AD auth backend overwriting auth.User data with data from ldap for %s." % username) user.save() logger.info("AD auth backend check passed for %s" % username) return user
def handle(self, *args, **options): csv_filepathname = args[0] sys.path.append(PROJECT_ROOT) dataReader = csv.reader(open(csv_filepathname), delimiter=';', quotechar='"') i = 0 index = {} for row in dataReader: if i==0: index = self.comprovaCamps(row) else: usuari = User() name = row[index.get('Name')] surname = row[index.get('Surname')] email = row[index.get('E-mail')] username = self.comprovaUser(name, surname, email, usuari) if(username!=False): usuari.email = row[index.get('E-mail')] usuari.username = username usuari.first_name = row[index.get('Name')] usuari.last_name = row[index.get('Surname')] usuari.groups.add("teachers") usuari.save() usuari.fsuser.classroom = row[index.get('Classroom')] i += 1
def adduser_createpw_sendmail(email, group, firstname, lastname, group_id, is_groupsuperuser=False): if email == '': return False elif len(User.objects.filter(email=email)) != 0: return False new_user = User() new_user.username = email.split('@')[0] new_user.email = email new_user.first_name = firstname new_user.last_name = lastname new_user.set_password('dummy_password') new_user.save() new_user_detail = UserDetail() new_user_detail.user = new_user new_user_detail.full_name = lastname+firstname new_user_detail.save() new_user.userdetail = new_user_detail new_user.username = str(new_user.id) new_user.save() new_user_group_info = UserGroupInfo() new_user_group_info.user = new_user new_user_group_info.group = group new_user_group_info.is_groupsuperuser = is_groupsuperuser new_user_group_info.user_id_of_group = group_id new_user_group_info.save() if not createpassword_sendmail(email): return False return True
def handle(self, *args, **options): fake = Factory.create() fakeru = Factory.create('ru_RU') number = int(options['number']) for i in range(0, number): profile = fake.simple_profile() u = User() u.username = profile['username'] u.first_name = fakeru.first_name() u.last_name = fakeru.last_name() u.email = profile['mail'] u.password = make_password('tp2015') u.is_active = True u.is_superuser = False u.save() up = Profile() up.user = u up.info = '%s [%s]' % (fakeru.company(), fakeru.catch_phrase()) image_url = 'http://api.adorable.io/avatars/100/%s.png' % u.username content = urllib.urlretrieve(image_url) up.avatar.save('%s.png' % u.username, File(open(content[0])), save=True) up.save() self.stdout.write('[%d] added user %s' % (u.id, u.username))
def user_signup(request): context = RequestContext(request) registered = False user = User(username = '') next_link = "" if request.GET: next_link = request.GET['next'] if request.method == 'POST': next_link = request.POST['signup_next'] user.first_name = request.POST['user[full_name]'] user.last_name = request.POST['user[sur_name]'] user.username = request.POST['user[email]'] user.email = request.POST['user[email]'] user.password = request.POST['user[password]'] user.set_password(user.password) user.save() patron = Patron(user = user) account = PatronAccount(balance = 0, frozen = False, valid = True ) account.save() patron.account = account patron.save() user = authenticate(username = request.POST['user[email]'], password = request.POST['user[password]']) if user is not None: if user.is_active: login(request, user) if next_link == "": return HttpResponseRedirect('/giftcards') else: return HttpResponseRedirect(next_link) else: return render_to_response('login.html', {'next':next_link}, context) return
def save(self): """ Save registration forms data into User and Staff. If any save operation fails, the others will be rolled back. @return: User instance """ data = self.cleaned_data try: user = User(username=data["username"]) user.email = data["email"] user.set_password(data["password"]) user.first_name = data["firstname"] user.last_name = data["lastname"] user.is_active = True user.save() if data["team"]: try: g = get_object_or_404(Group, pk=data["team"]) user.groups.add(g) except: pass try: staff = Staff(user=user) staff.gender = data["gender"] staff.role = data["role"] staff.save() return user except Exception, e: logger.error("RegisterForm.save():%s" % e) user.delete() raise e except Exception, e: logger.error("RegisterForm.save():%s" % e) raise e
def test_real_name(self): """Tests that users with names have display names including them""" user = User(username='******', password='******') user.first_name = 'Chuck' user.last_name = 'Bartowski' user.save() self.assertEqual('Chuck Bartowski', user.get_profile().get_display_name())
def create(cls, person_data): user = User() user.username = person_data.get('email') user.email = person_data.get('email') user.first_name = person_data.get('first_name') user.last_name = person_data.get('last_name') user.set_password(person_data.get('password')) user.save() return cls(user=user, phone=person_data.get('phone'), cpf=person_data.get('cpf'))
def clean_password(self): data = self.cleaned_data['password'] user = User() if self.cleaned_data.get('first_name'): user.first_name = self.cleaned_data['first_name'] if self.cleaned_data.get('last_name'): user.last_name = self.cleaned_data['last_name'] if self.cleaned_data.get('email'): user.email = self.cleaned_data['email'] password_validation.validate_password(password=data, user=user) return data
def create(self, validated_data): user = User() user.username = validated_data.get('username', user.username) user.first_name = validated_data.get('first_name', user.first_name) user.last_name = validated_data.get('last_name', user.last_name) user.set_password(validated_data.get('password', user.password)) user.email = validated_data.get('email', user.email) user.save() return user
def userSignup(self, userInfo): print("INSIDE CONTROLLER") user = User() user.first_name = userInfo['fname'] user.last_name = userInfo['lname'] user.email = userInfo['email'] user.username = userInfo['email'] user.set_password(userInfo.get('pass')) user.is_active = False user.save() return user
def testTeacherToStringInputteacherReturnteacher(self): uid = "teacher" teacher = Teacher() user = User() name = uid user.username = name user.first_name = name user.last_name = name user.email = "*****@*****.**" user.password = "******" teacher.user = user self.assertEqual(str(teacher), uid)
def save(self): data = self.cleaned_data user = User() user.username = data['username'] user.set_password(data['password']) user.email = data['email'] user.first_name = data['first_name'] user.last_name = data['last_name'] user.is_active = True user.is_superuser = False user.save() return user
def setUp(self): user = User() name = "test" user.username = name user.first_name = name user.last_name = name user.email = "*****@*****.**" user.password = "******" user.is_staff = 1 user.is_active = 1 user.is_superuser = 0 user.save()
def create_user(self, lti, username): # create the user if necessary user = User(username=username, password='******') user.set_unusable_password() user.email = lti.user_email() name = HumanName(lti.user_fullname()) user.first_name = name.first[:30] user.last_name = name.last[:30] user.save() return user
def add_sample_user_and_user_profile(user_sample_data): user = User() user.username = user_sample_data['username'] user.set_password(user_sample_data['password']) user.first_name = user_sample_data['first_name'] user.last_name = user_sample_data['last_name'] user.email = user_sample_data['email'] user.save() user_profile = UserProfile() user_profile.user = user user_profile.save() return user
def test_user_fields(self): ''' Test the existence of the user in database.''' user = User() user.username = "******" user.last_name = "Last name test" user.first_name = "First name test" user.email = "*****@*****.**" user.password = "******" user.save() response = User.objects.get(email=user.email) self.assertEqual(response, user)
def create_jrs_user(sp_user): try: user = User(username=sp_user.username) user.email = sp_user.email user.first_name = sp_user.first_name user.last_name = sp_user.last_name user.is_active = True user.save() except Exception as e: print(e) return None return user
def create_user_(self): user = User( username = self.username, email = self.details['email'] ) if 'first_name' in self.data: user.first_name = self.data['first_name'] if 'last_name' in self.data: user.last_name = self.data['last_name'] user.set_password(random_password()) user.save() self.user = user
def create(self, validated_data): username = validated_data['username'] password = validated_data['password'] new_user = User(username=username) new_user.set_password(password) new_user.first_name = validated_data['first_name'] new_user.last_name = validated_data['last_name'] new_user.email = validated_data['email'] new_user.save() Profile.objects.create(user=new_user) Order.objects.create(user=new_user) return validated_data
def save(self): print("IN SAVE USER METHOD") print(self.validated_data) err_codes = [] email = self.validated_data.get("email") first_name = self.validated_data.get("first_name") last_name = self.validated_data.get("last_name") username = "******".format(first_name, last_name) is_email_unique = self.email_is_unique(email=email) if not is_email_unique: err_codes.append(4) is_username_unique = self.username_is_unique(username=username) new_username = None if not is_username_unique: new_username = self.create_username_from_existing(username) if not new_username: err_codes.append(8) password = self.validated_data.get("password") password_confirm = self.validated_data.get("password_confirm") is_password_match = self.passwords_are_matching( password1=password, password2=password_confirm) if not is_password_match: err_codes.append(15) if err_codes: return {"success": False, "err_codes": err_codes} try: user = User() user.first_name = first_name user.last_name = last_name user.email = email if not new_username: user.username = username else: user.username = new_username user.password = password user.is_active = False print("USER BEFORE SAVE") print(user.__dict__) user.set_password(password) user.save() except Exception: user = None exc_type, exc_value, exc_traceback = sys.exc_info() traceback.print_exception(exc_type, exc_value, exc_traceback) if user: result = {"success": True, "data": user} else: result = {"success": False, "err_codes": [7]} return result
def create(self, validated_data): intance = User() intance.first_name = validated_data.get('first_name') intance.last_name = validated_data.get('last_name') intance.username = validated_data.get('username') intance.email = validated_data.get('email') intance.set_password(validated_data.get('password')) intance.save()
def user_register(request): context = {} if request.method == "POST": user = User() user.first_name = request.POST.get('firstname') user.last_name = request.POST.get('lastname') user.username = request.POST.get('username') user.email = request.POST.get('email') user.set_password(request.POST.get('password')) user.save() context['user_saved_successfully'] = True return render(request, 'useraccounts/register.html', context)
def signup(self, request, user: User): p, _ = Profile.objects.get_or_create(user=user) user.first_name = self.cleaned_data['first_name'] user.last_name = self.cleaned_data['last_name'] p.preferred_name = self.cleaned_data['preferred_name'] p.phone_number = self.cleaned_data['phone_number'] p.perm_address = self.cleaned_data['perm_address'] p.full_clean() p.save() user.profile = p user.save() return user
def save(self): logger.debug('Saving employer') logger.debug('self.instance.pk=' + str(self.instance.pk)) if self.instance.pk: user = User.objects.get(pk=self.instance.pk) else: user = User() user.is_active = False user.first_name = self.cleaned_data["first_name"] user.last_name = self.cleaned_data["last_name"] user.username = (self.cleaned_data["email"]) user.email = self.cleaned_data["email"] user.set_password(self.cleaned_data["password1"]) user.save() site = self.cleaned_data["website"] description = self.cleaned_data["description"] company_name = self.cleaned_data["company_name"] oncampus = self.cleaned_data["oncampus"] address1 = self.cleaned_data["address1"] address2 = self.cleaned_data["address2"] city = self.cleaned_data["city"] state = self.cleaned_data["state"] zipcode = self.cleaned_data["zipcode"] phone = self.cleaned_data["phone"] if len(site) > 2 and not site.startswith( "http://") and not site.startswith("https://"): site = "http://" + site newEmployer = Employer(website=site, company_name=company_name, oncampus=oncampus, description=description, address1=address1, address2=address2, city=city, state=state, zipcode=zipcode, phone=phone) newEmployer.userprofile = user.userprofile newEmployer.save() user.userprofile.employer = newEmployer user.userprofile.save() employergroup = Group.objects.get_or_create(name=employergroupname) user.groups.add(employergroup[0]) user.save() return user
def frespoUser(): user = get_or_none(User, username='******') if (user): return user else: user = User() user.username = '******' user.email = '*****@*****.**' user.first_name = 'Freedom' user.last_name = 'Sponsors' user.save() return user
def addUser(self, username, password, email, first_name, last_name): user = User() user.username = username user.password = password user.email = email user.first_name = first_name user.last_name = last_name try: user.save() return True except IntegrityError: return False
def create(self, validated_data): # user userprofile_data = validated_data.pop('userprofile') user = User() user.username = validated_data.get('username') user.email = validated_data.get('email') user.first_name = validated_data.get('first_name') user.last_name = validated_data.get('last_name') user.set_password(validated_data.get('password')) user.save() userprofile = UserProfile.objects.create(user=user, **userprofile_data) return user
def _update_local_user(self, user, username, first_name, last_name, email, in_groups=None): if in_groups is None: in_groups = [] # Because the username field on model User is capped to 30 # characters we need to assign a butchered username here. # It's not a problem because the user can be found by email # anyway. # 30 is the default max length of the username field for # django.contrib.auth.models.User if not user: django_username = username if email_re.match(django_username): if isinstance(username, unicode): # md5 chokes on non-ascii characters django_username = username.encode('ascii', 'ignore') django_username = ( md5_constructor(django_username).hexdigest()[:30]) user = User(username=django_username, first_name=first_name, last_name=last_name, email=email) user.set_unusable_password() user.save() else: changed = False if user.first_name != first_name: user.first_name = first_name changed = True if user.last_name != last_name: user.last_name = last_name changed = True if user.email != email: user.email = email changed = True if changed: user.save() for django_name, ldap_names in GROUP_MAPPINGS.items(): ldap_names = set(flatten_group_names(ldap_names)) if ldap_names & set(in_groups): # make sure the user is in this django group if not user.groups.filter(name=django_name).exists(): user.groups.add(Group.objects.get(name=django_name)) else: user.groups.remove(Group.objects.get(name=django_name)) return user
def update(self, instance: User, validated_data: dict): instance.username = validated_data.get('username', instance.username) password = validated_data.get('password', None) if password is not None: instance.set_password(password) instance.email = validated_data.get('email', instance.email) instance.first_name = validated_data.get('first_name', instance.first_name) instance.last_name = validated_data.get('last_name', instance.last_name) instance.is_staff = validated_data.get('is_staff', instance.is_staff) instance.is_superuser = validated_data.get('is_superuser', instance.is_superuser) instance.save() return instance
def clean_password(self): """clean password field""" data = self.cleaned_data["password"] user = User() if self.cleaned_data.get("first_name"): user.first_name = self.cleaned_data["first_name"] if self.cleaned_data.get("last_name"): user.last_name = self.cleaned_data["last_name"] if self.cleaned_data.get("email"): user.email = self.cleaned_data["email"] password_validation.validate_password(password=data, user=user) return data
def create(self, validated_data): """ create a user an validate the data """ instance = User() instance.first_name = validated_data.get('first_name') instance.last_name = validated_data.get('last_name') instance.username = validated_data.get('username') instance.email = validated_data.get('email') instance.set_password(validated_data.get('password')) instance.save() return instance
def restore_object(self, attrs, instance=None): restored = super(ExtendedUserSerializerBase, self).restore_object(attrs, instance=instance) user = User() user.username = attrs['user.username'] user.first_name = attrs['user.first_name'] user.last_name = attrs['user.last_name'] user.email = attrs['user.email'] user.set_password(attrs['user.password']) user.save() restored.user = user return restored
def save(self): user = User() data = self.cleaned_data user.username = data.get('username') user.password = make_password(data.get('password')) user.email = data.get('email') user.first_name = data.get('first_name') user.last_name = data.get('last_name') user.is_active = True user.is_superuser = False user.save() return authenticate(username=user.username, password=user.password)
def import_users(data_file, reject_file, save=False): json_file = open(data_file) user_data = json.load(json_file) json_file.close() reject_file = open(reject_file, "w") reject_file.write("[") users = 0 matches = 0 for u in user_data: users = users + 1 username = u['fields']['username'] user = User.objects.filter(username=username).first() if user: matches = matches + 1 print "Match (%d) on username %s = %s" % (matches, username, user.get_full_name()) reject_file.write(json.dumps(u)) else: email = u['fields']['email'] user = User.objects.filter(email=email).first() if user: matches = matches + 1 print "Match (%d) on email %s = %s" % (matches, email, user.get_full_name()) reject_file.write(json.dumps(u)) else: #{"pk": 100, "model": "auth.user", "fields": {"username": "******", "first_name": "Conni", #"last_name": "Biesalski", "is_active": true, "is_superuser": false, "is_staff": false, #"last_login": "******", "groups": [], "user_permissions": [], #"password": "******", #"email": "*****@*****.**", "date_joined": "2014-07-01T20:30:41.137Z"}} new_user = User(username=username, email=email) new_user.first_name = u['fields']['first_name'] new_user.last_name = u['fields']['last_name'] new_user.is_active = u['fields']['is_active'] new_user.is_superuser = u['fields']['is_superuser'] new_user.is_staff = u['fields']['is_staff'] new_user.last_login = u['fields']['last_login'] new_user.date_joined = u['fields']['date_joined'] new_user.password = u['fields']['password'] new_user.save() for g in u['fields']['groups']: group = Group.objects.get(name=g[0]) new_user.groups.add(group) new_user.save() reject_file.write("]") reject_file.close() print "Users: %d, Matches: %d" % (users, matches)
def post(self, request): #check username #try: uname = request.data['uid'] pwd = request.data['pwd'] email = request.data['email'] new_user = User(username=uname, email=email) # new_user.is_active = False new_user.set_password(pwd) #check first name new_user.first_name = request.data['fname'] #check last name new_user.last_name = request.data['lname'] new_user.save() u = User.objects.get(username=uname) h = SHA256.new() h.update(uname.encode('utf-8')) #print(uname) code = h.hexdigest() c = CertiList(name=u, code=str(code)) c.save() #print(u) # create user info queryset = UserInfo(root=new_user) queryset.save() v_user = authenticate(username=uname, password=pwd) if v_user is not None: login(request, v_user) #check live user moedls #cookie login expiry set #86400sec / 1day request.session.set_expiry(86400 * 5) data = {} data['uid'] = uname # send email body = HOSTNAME + "/checkmail/" + code + "/" """ send_mail( 'mail check', str(body), '*****@*****.**', [str(email)], fail_silently=False, ) """ return Response(data=data, status=status.HTTP_200_OK)
def guardarOperario(request): if request.method == 'POST': if User.objects.filter(pk=request.user.id, groups__name=GRUPO1).exists(): usu = User() usu.username = request.POST['nombres'] + time.strftime("%H:%M:%S") usu.first_name = request.POST['nombres'] usu.last_name = request.POST['apellidos'] usu.email = request.POST['email'] usu.password = make_password("icbf2017") usu.is_active = True perfil = Group.objects.get(id=2) usu.save() usu.groups.add(perfil) operario = Operario() operario.id_id = usu.id operario.uds_id = request.POST['uds'] operario.genero = request.POST['genero'] operario.intentos = 5 operario.estado = "A" if request.POST['bandera_foto'] == "CAMBIO": operario.foto = request.FILES['archivo'] else: operario.foto = "media/operarios/no_photo.png" operario.direccion = request.POST['direccion'] operario.telefono = request.POST['telefono'] operario.celular = request.POST['celular'] operario.save() e = Eventos() e.uds = operario.uds e.detalle = "CREACIÓN DEL OPERARIO " + usu.first_name + " " + usu.last_name e.f_inicio = '1997-02-21' e.f_fin = '2017-02-21' e.tipo = "TAREAS" e.allday = True e.estado = "REALIZADA" e.save() registrarLogs( request.user.first_name + " " + request.user.last_name, 'GUARDAR', 'Operarios', 'Operario Creado Exitosamente', usu.first_name + " " + usu.last_name) messages.success(request, 'Creado') return HttpResponseRedirect('/operarios') else: return HttpResponseRedirect('/') else: return HttpResponseRedirect("/")