def addUser(request): form = UserForm(request.POST) if form.is_valid(): try: with transaction.atomic(): enterprise = Enterprise() enterprise.save() request.session['idEnterprise'] = enterprise.id; location= Location(enterprise=enterprise, lat=0, lng=0, name='Main Office') location.save() user = User(location = location, email=form.cleaned_data['email'], password=form.cleaned_data['password']) user.save() request.session['idUser'] = user.id; profile = Profile(user = user, role="Administrator") profile.save() return render(request, 'users/dashboard.html') except Exception as e: print(e) messages.error(request, 'Sorry, Internal Error') else: messages.error(request, 'Please fill the form') return HttpResponseRedirect('/signup')
def signup(request): if request.method == 'POST': username = request.POST['username'] password = request.POST['password'] password_confirmation = request.POST['password_confirmation'] #Check if the password is the same if password != password_confirmation: return render(request, 'users/signup.html', {'error': 'Password confirmation does not match'}) #Handle exception for username already taken try: user = User.objects.create_user(username=username, password=password) except IntegrityError: return render(request, 'users/signup.html', {'error': 'Username already exist'}) user.first_name = request.POST['first_name'] user.last_name = request.POST['last_name'] user.email = request.POST['email'] user.save() profile = Profile(user=user) profile.save() return redirect('login') return render(request, 'users/signup.html')
def signup_view(request): """Sign up view.""" if request.method == 'POST': username = request.POST['username'] passwd = request.POST['passwd'] passwd_confirmation = request.POST['passwd_confirmation'] if passwd != passwd_confirmation: return render(request, 'users/signup.html', {'error': 'Password confirmation does not match'}) try: user = User.objects.create_user(username=username, password=passwd) except IntegrityError: return render(request, 'users/signup.html', {'error': 'Username is already in user'}) user.first_name = request.POST['first_name'] user.last_name = request.POST['last_name'] user.email = request.POST['email'] user.save() profile = Profile(user=user) profile.save() return redirect('login') return render(request, 'users/signup.html')
def signup(request): if request.method == 'POST': username = request.POST['username'] passwd = request.POST['passwd'] passwd_confirmation = request.POST['passwd_confirmation'] if passwd != passwd_confirmation: return render(request, 'users/signup.html', {'error': "Passsword confirmation does not match"}) try: user = User.objects.create_user( username=username, password=passwd, ) except IntegrityError: return render(request, 'users/signup.html', {'error': "Username is already in use"}) user.first_name = request.POST['first_name'] user.last_name = request.POST['last_name'] user.email = request.POST['email'] user.save() profile = Profile(user=user) profile.biography = "Prueba BIO" profile.save() return render(request, 'users/signup.html')
def register(request): if request.method == 'POST' and not request.user.is_authenticated(): username = request.POST.get('username') email = request.POST.get('email') password = request.POST.get('password') confirm = request.POST.get('confirm') try: existing_user = User.objects.get(username=username) context = RequestContext(request, {'register_message': 'Username {} already exists.'.format(username)}) return render(request, 'home.html', context) except ObjectDoesNotExist: pass try: existing_user = User.objects.get(email=email) context = RequestContext(request, {'register_message': 'E-mail {} already exists.'.format(email)}) return render(request, 'home.html', context) except ObjectDoesNotExist: pass if password == confirm: new_user = User.objects.create_user(username, email=email, password=password) new_profile = Profile() new_profile.user = new_user new_profile.save() return redirect('home') else: context = RequestContext(request, {'register_message': 'Passwords do not match.'.format(email)}) return render(request, 'home.html', context) else: return redirect('home')
def save(self): """Create user and profile.""" data = self.cleaned_data user = User.objects.create_user(**data) profile = Profile(user=user) profile.save()
def change_friend(request, operation, username): new_friend = User.objects.get(username=username) if operation == 'add': Profile.add_friend(request.user, new_friend) elif operation == 'del': Profile.del_friend(request.user, new_friend) return redirect('/')
def handle(self, *args, **options): basepath = 'media/faces' faces = [] for entry in os.listdir(basepath): if os.path.isfile(os.path.join(basepath, entry)): faces.append(entry) fake = Faker(['es_ES']) for _ in range(10): user = { 'username': fake.user_name(), 'first_name': fake.first_name(), 'email': fake.email(), 'password': fake.paragraph(nb_sentences=2) } new_user = User.objects.create_user(**user) new_user.save() p = { 'user': new_user, 'website': fake.url(), 'biography': fake.paragraph(nb_sentences=5, variable_nb_sentences=False), 'phone_number': fake.phone_number(), } profile = Profile(**p) face = random.choice(faces) f = File(open(os.path.join('media/faces', face), 'rb')) profile.picture.save(f'{face}', f) profile.save() print(f'{new_user} : {profile}')
def handle(self, *args, **options): for user in User.objects.all(): if Profile.objects.filter(user=user).count() == 0: print "No profile for user: %s" % (user,) new_profile = Profile(user=user, activation_key=generate_activation_key(user.username)) new_profile.save() print "Created new profile for username: %s" % (user.username,)
def profile(request): title = request.user.username try: current_user = request.user projects = Project.objects.filter(poster=current_user).all() profile = Profile.get_profile(current_user) if request.method == 'POST': form = ProjectForm(request.POST, request.FILES) if form.is_valid(): project = form.save(commit=False) user_profile = Profile.get_profile(current_user) project.poster = current_user project.save() return redirect('profile') else: form = ProjectForm() except Exception as e: raise Http404() return render(request, "award/profile.html", { 'profile': profile, "title": title, "projects": projects, "form": form })
def save(self): """create user and profile.""" data = self.cleaned_data data.pop('password_confirmation') user = User.objects.create_user(**data) profile = Profile(user=user) profile.save()
def create_user(username, email_id="", password=None, first_name="", last_name=""): """ This function called for new user sign up on p. interface. Thus username should be a valid phone number.""" usr = None profile = None if not username: return usr, profile username = username.strip() is_type = "id" if is_valid_mobile(username): is_type = "mobile" try: usr = User(username=username, email="") if password is None or password == "": # use set_unusable_password to allow user to set his password in future usr.set_unusable_password() else: usr.set_password(password) if first_name: usr.first_name = first_name if last_name: usr.last_name = last_name usr.save() profile = Profile( user=usr, created_on=datetime.now(), primary_phone="", primary_email="", secondary_email="" ) if first_name and last_name: profile.full_name = "%s %s" % (first_name, last_name) profile.save() phone = Phone(user=profile, phone=username, type="primary") phone.is_verified = True phone.verified_on = datetime.now() phone.save() except Exception, e: log.exception("Error create_user username: %s Exception: %s" % (username, repr(e))) return None, None
def SignupView(request): if request.method == 'POST': username = request.POST['username'] passdw = request.POST['password'] passwd_co = request.POST['password_confirmation'] first_name = request.POST['first_name'] last_name = request.POST['last_name'] email = request.POST['email'] if passdw != passwd_co: return render(request, 'users/singup.html', {'error': 'Password confirmation does not mach'}) user = User.objects.create_user(username=username, password=passdw) user.first_name = first_name user.last_name = last_name user.email = email profile = Profile(user=user) profile.save() return redirect('users:login') return render(request, 'users/singup.html')
def safe(self): data = self.cleaned_data data.pop('password_conf') user = User.objects.create_user(**data) profile = Profile(user=user) profile.save()
def signup_view(request): """Handles user sign up""" if request.method == 'POST': username = request.POST['username'] password = request.POST['password'] password_confirmation = request.POST['password_confirmation'] if password != password_confirmation: return render(request, 'users/signup.html', {'error': 'Passwords doesn\'t match'}) try: user = User.objects.create_user(username=username, password=password) except IntegrityError: return render(request, 'users/signup.html', {'error': 'Username is already in use'}) user.first_name = request.POST['first_name'] user.last_name = request.POST['last_name'] user.email = request.POST['email'] user.save() profile = Profile(user=user) profile.save() messages.success(request, 'You\'ve registered successfully') return redirect('login') return render(request, 'users/signup.html')
def get_user_profile(user): """ Returns user profile. Creates one if needed """ if not (user and user.is_authenticated()): return None pr = cache.get("users_profile:auth_user=%s" % user.id, None) if pr: return pr pr = get_profile_by_email_or_phone(user.username) if not pr: pr = Profile.objects.filter(user=user).order_by("id")[:2] if len(pr) > 1: fb_log.info("Multiple profiles for user: %s" % user.username) if pr: pr = pr[0] if not pr: pr = Profile(user=user) pr.created_on = datetime.now() pr.save() if is_valid_email(user.username): try: email = Email(email=user.username, user=pr, type="primary") email.save() except: pass if is_valid_mobile(user.username): try: phone = Phone(phone - user.username, user=pr, type="primary") phone.save() except: pass cache.set("users_profile:auth_user=%s" % user.id, pr) return pr
def safe(): '''Create user and profile''' data = self.cleaned_data data.pop['password_confirmation'] user = User.objects.create_user(**data) profile = Profile(user = user) profile.save()
def save(self): """Create user and profile.""" data = self.cleaned_data data.pop('password_confirmation') #Elimina este campo ya que no se usa user = User.objects.create_user(**data) #desdobla el formulario en el modelo profile = Profile(user=user) profile.save()
def profile(user, **kwargs): """Return a saved profile for a given user.""" defaults = {'user': user} defaults.update(kwargs) p = Profile(**defaults) p.save() return p
def save(self): """Create user and profile""" data = self.cleaned_data data.pop('password_confirmation') # Vamos a sacar de cleaned_Data nuestro password_confirmation, por que no nos servira. user = User.objects.create_user(**data) profile = Profile(user=user) profile.save()
def _create_user(username, rolename, data=None): if data is None: data = {} role = Role.select().where(Role.name==rolename).get() Profile.create(username=username, email=username+'@srv.pl', role=role, description=data.get('description', 'User ' + username + ' description'), title=data.get('title', 'User ' + username + ' title'), location=data.get('location', 'User ' + username + ' location'))
def profile(user, **kwargs): """Return a saved profile for a given user.""" defaults = {"user": user} defaults.update(kwargs) p = Profile(**defaults) p.save() return p
def save(self): data = self.cleaned_data data.pop('password_confirmation') #**data is all the dictionary user = User.objects.create_user(**data) profile = Profile(user=user) profile.save()
def save(self): #guaraado de datos """create user and profile""" data = self.cleaned_data data.pop('password_confirmation') user = User.objects.create_user( **data) # aca s envia todo el diccionario **data profile = Profile(user=user) profile.save()
def save(self): #CREATE USER AND PROFILE data = self.cleaned_data data.pop('password_confirmation') user = User.objects.create_user(**data) profile = Profile(user=user) profile.save()
def save(self): #create user and profile data = super().clean() data.pop('password_confirmation') user = User.objects.create_user(**data) profile = Profile(user=user) profile.save()
def init_profile(user): LoadTestData.init_foaf() profile = Profile(user=user, ) try: return Profile.objects.get(user=user) except ObjectDoesNotExist: profile.save() return profile
def save(self): """Create user and profile.""" data = self.cleaned_data data.pop('password_confirmation') # investigar que llega aqui user = User.objects.create_user(**data) profile = Profile(user=user) profile.save()
def signup(request): from auth.models import User from auth import load_backend, login from users.models import Profile, EmailVerify from market_buy.forms import BuyerForm form = BuyerForm(request.POST or None) if form.is_valid(): """ Generate Auth User """ user = User.objects.create_user(form.cleaned_data["username"], form.cleaned_data["email"], form.cleaned_data["password1"]) user.first_name = form.cleaned_data["first_name"] user.last_name = form.cleaned_data["last_name"] user.is_active = False user.save() """ Set profile """ profile = Profile(user=user) profile.save() """ Send mail to confirm account """ email_verify = EmailVerify(user=user, user_activation=True) code = email_verify.generate_code() email_verify.save() # TODO: remove this send_mail_account_confirmation(user, email_verify.code, request.marketplace) # return HttpResponseRedirect(reverse('confirmemail', args=[code])) # for backend in settings.AUTHENTICATION_BACKENDS: # if user == load_backend(backend).get_user(user.pk): # user.backend = backend # break # if hasattr(user, 'backend'): # login(request, user) if request.session.get('sell_signup', False): request.flash['message'] = _( "<h5>Please check your email and confirm your account to start selling...</h5>" ) request.flash['severity'] = "success" return HttpResponseRedirect(reverse('market_sell_signup')) else: request.flash['message'] = _( "<h5>Please check your email and confirm your account. Once confirmed you can Buy or Sell on GreatCoins.com</h5>" ) request.flash['severity'] = "success" return HttpResponseRedirect(reverse('market_home')) else: #request.method == GET if request.GET.has_key('sell_signup'): request.session['sell_signup'] = request.GET.get( 'sell_signup', '') == '1' return render_to_response( '%s/buy/register.html' % request.marketplace.template_prefix, {'form': form}, RequestContext(request))
def save(self): """Create user and profile. Como usamos los datos una vez que son validos""" data = self.cleaned_data data.pop('password_confirmation') user = User.objects.create_user(**data) profile = Profile(user=user) profile.save()
def save(self): """Create user and profile.""" data = self.cleaned_data data.pop('password_confirmation') user = User.objects.create_user(**data) profile.interests.add(*self.cleaned_data.get('interests')) profile = Profile(user=user) profile.save()
def save(self): """Creacion de usuario y perfil en la DataBase""" data = self.cleaned_data # Primero traemos los del form data.pop( 'password_confirmation' ) # quitamos el dato de password confirmations que nos sirve con el modelo. user = User.objects.create_user(**data) profile = Profile(user=user) profile.save()
def save(self): # Crear un usuario y profile data = self.cleaned_data # sacar atributo data.pop('password_confirmation') # con el arg ** le envio todo el diccionario como el rest operator de js user = User.objects.create_user(**data) profile = Profile(user=user) profile.save()
def test_profile(self): # creating a user with a profile u1 = User(username='******', password='******') u1.save() up1 = Profile(user_id=u1.id) # checks that up1 is an instance of Profile self.assertTrue(isinstance(up1, Profile)) # checks if up1 is equal to the user: u1.username + str('Profile') self.assertEqual(up1.__str__(), u1.username + ' Profile')
def save(self): """Create user and profile.""" data = self.cleaned_data data.pop('password_confirm' ) #pop saca los datos que no debemos enviar a la bd user = User.objects.create_user(**data) profile = Profile(user=user) profile.save()
def post(self, request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): serializer.save() profile = Profile(user = MainUser.objects.get(id=serializer.data['id']), bio=request.data['profile']['bio'], address=request.data['profile']['address']) profile.save() return Response(serializer.data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def form_valid(self, form): # profile 따로 저장해줌 # 꼼수인데 방법이 되네요 user = form.save() p = Profile() p.user = user p.save() messages.success(self.request, '계정이 생성되었습니다') return super(CreateUser, self).form_valid(form)
def post(self, request): user_form = CreateUserForm(request.POST) profile_form = CreateProfileForm(request.POST) print(user_form.errors) print(user_form.cleaned_data) if user_form.is_valid() and profile_form.is_valid(): user = User(**user_form.cleaned_data) user.save() print('User表OK,,,,') user_profile = Profile() user_profile.user = user user_profile.name = profile_form.cleaned_data['name'] user_profile.lnvalid_date = profile_form.cleaned_data[ 'lnvalid_date'] user_profile.phone = profile_form.cleaned_data['phone'] user_profile.weixin = profile_form.cleaned_data['weixin'] user_profile.info = request.POST.getlist('info', None)[0] user_profile.save() print('userprofile表OK,,,,') if request.POST.get('groups', None): user.groups.set(request.POST.getlist('groups')) register_email = RegisterEmail() register_email.user = user register_email.type_code = 0 register_email.code = random_str() register_email.save() contnet = """ <p>你好 %s: </p> <p>恭喜您,您的账号已经创建成功 </p> <p>用户名: %s </p> <p><a href='%s'>请点击这里设置密码</a> </p> """ % (user.username, user_profile.name, settings.HOST_URL + reverse('user_create_password') + '?code=' + str(register_email.code)) try: send_mail(settings.EMAIL_USER, settings.EMAIL_PASSWORD, user.email, settings.EMAIL_TITLE, contnet, settings.EMAIL_HOST, settings.EMAIL_PORT) print('邮件发送OK...') except Exception as e: print(e) print('邮件发送失败...') return redirect(reverse('user_list'))
def profile(user, **kwargs): """Return a saved profile for a given user.""" defaults = {'user': user, 'name': 'Test K. User', 'bio': 'Some bio.', 'website': 'http://support.mozilla.com', 'timezone': None, 'country': 'US', 'city': 'Mountain View'} defaults.update(kwargs) p = Profile(**defaults) p.save() return p
def signup(request): from auth.models import User from auth import load_backend, login from users.models import Profile, EmailVerify from market_buy.forms import BuyerForm form = BuyerForm(request.POST or None) if form.is_valid(): """ Generate Auth User """ user = User.objects.create_user(form.cleaned_data["username"], form.cleaned_data["email"], form.cleaned_data["password1"]) user.first_name = form.cleaned_data["first_name"] user.last_name = form.cleaned_data["last_name"] user.is_active = False user.save() """ Set profile """ profile = Profile(user=user) profile.save() """ Send mail to confirm account """ email_verify = EmailVerify(user=user, user_activation=True) code = email_verify.generate_code() email_verify.save() # TODO: remove this send_mail_account_confirmation(user, email_verify.code, request.marketplace) # return HttpResponseRedirect(reverse('confirmemail', args=[code])) # for backend in settings.AUTHENTICATION_BACKENDS: # if user == load_backend(backend).get_user(user.pk): # user.backend = backend # break # if hasattr(user, 'backend'): # login(request, user) if request.session.get('sell_signup',False): request.flash['message'] = _("<h5>Please check your email and confirm your account to start selling...</h5>") request.flash['severity'] = "success" return HttpResponseRedirect(reverse('market_sell_signup')) else: request.flash['message'] = _("<h5>Please check your email and confirm your account. Once confirmed you can Buy or Sell on GreatCoins.com</h5>") request.flash['severity'] = "success" return HttpResponseRedirect(reverse('market_home')) else: #request.method == GET if request.GET.has_key('sell_signup'): request.session['sell_signup'] = request.GET.get('sell_signup','') == '1' return render_to_response('%s/buy/register.html'% request.marketplace.template_prefix, {'form': form}, RequestContext(request))
def attach_fb(request): if request.method == "POST": data = request.POST facebookid = data["id"] email = data["email"] first_name = data["first_name"] last_name = data["last_name"] user, profile = None, None u_email = None try: u_email = UserEmail.objects.get(email=email) profile = u_email.user user = profile.user except UserEmail.DoesNotExist: try: user = User.objects.get(Q(email=email) | Q(username=email)) except User.DoesNotExist: user = User.objects.create_user(email, email, None) user.first_name = first_name user.last_name = last_name user.save() if not user.first_name: user.first_name = first_name user.save() if not user.last_name: user.last_name = last_name user.save() try: profile = Profile.objects.get(user=user) except Profile.DoesNotExist: profile = Profile(user=user, full_name="%s %s" % (first_name, last_name)) # if not profile.full_name: overwrite facebook name profile.full_name = "%s %s" % (first_name, last_name) profile.facebook = facebookid profile.save() if not u_email: u_email = UserEmail(email=email, user=profile, type="subscription") u_email.save() if request.user: auth.logout(request) request.session.flush() user = auth.authenticate(facebook_user=user, **dict(request=request)) request.session["logged_through_facebook"] = True if user: request.session["atg_username"] = user.username set_logged_in_user(request, user) log.info("FACEBOOK USER LOGGED IN: %s" % user) return HttpResponse("OK") else: return HttpResponse("OK") return HttpResponse("FAILED")
def create_tables(): database.connect() Category.drop_table(fail_silently=True) Thread.drop_table(fail_silently=True) Post.drop_table(fail_silently=True) Role.drop_table(fail_silently=True) Profile.drop_table(fail_silently=True) database.create_tables([Category, Thread, Post, Profile, Role]) database.close() if settings.DEBUG: setup_temp_data()
def home(request): if request.user.is_authenticated(): return render(request, 'dashboard.html') else: if request.method == 'POST': form = LoginForm(request.POST) if form.is_valid(): user = authenticate(username=request.POST["username"], password=request.POST["password"]) if user: auth.login(request, user) profile = Profile(user=user, last_login_source=request.META["REMOTE_ADDR"]) profile.save() return render(request, 'dashboard.html') return render(request, 'index.html')
def register(self, request, **cleaned_data): """Custom registration view. """ print('Starting registration') print(cleaned_data) u = User.objects.create_user( cleaned_data['username'], '', cleaned_data['password1']) p = Profile() p.user = u p.save() messages.success(self.request, 'Thank you for registering. Now you can login.')
def registrar_usuario(request): if request.POST: f=RegistrationForm(request.POST) if f.errors: messages.error(request, 'El formulario contiene errores') return render_to_response("registro_caja.html", {'form':f}, RequestContext(request)) else: data = f.cleaned_data user=User() user.username=data["username"] passwd=get_pronounceable_password(1,2) user.set_password(passwd) user.email = data['email'] user.first_name = data['first_name'] user.last_name = data['last_name'] user.save() profile = Profile() profile.user=user profile.telefono = data['phone_number'] profile.celular = data['cellphone'] profile.direccion = data['address'] profile.tipo = CLIENTE profile.save() messages.success(request, 'Usuario creado con exito') return render_to_response('mostrar_usuario.html', {'user':user,'passwd':passwd}, RequestContext(request)) else: f=RegistrationForm() return render_to_response("registro_caja.html", {'form':f}, RequestContext(request))
def profile(**kwargs): """Return a saved profile for a given user.""" defaults = {'name': 'Test K. User', 'bio': 'Some bio.', 'website': 'http://support.mozilla.com', 'timezone': None, 'country': 'US', 'city': 'Mountain View', 'locale': 'en-US'} if 'user' not in kwargs: u = user(save=True) defaults['user'] = u defaults.update(kwargs) p = Profile(**defaults) p.save() return p
def create_profile(sender, instance, created, using, *args, **kwargs): """ Crea el perfil de usuario cuando se crea un usuario. """ from users.models import Profile if created: try: sp_id = transaction.savepoint() profile = Profile(user=instance, username=instance.username) profile.save() transaction.savepoint_commit(sp_id) except Exception, e: logging.error('ERROR: %s ' % e) transaction.savepoint_rollback(sp_id)
def setUp(self): # create store owner user and profile self.owner = User.objects.create_user("test-owner", "*****@*****.**", "test-owner") owner_profile = Profile(user=self.owner) owner_profile.save() # create a marketplace self.marketplace = MarketPlace(name="greatcoins", title="greatcoins", slug="greatcoins", template_prefix="greatcoins", base_domain="greatcoins.com") self.marketplace.save() # create a shop self.shop = Shop(marketplace=self.marketplace, admin=self.owner, name="test_shop") self.shop.save() # create a Preference and SubscriptionPlan to shop Preference(shop=self.shop).save() self.shop.update() plan = SubscriptionPlan(plan_id=1, marketplace=self.marketplace, trial_period=True, total_store_revenue=1000, concurrent_store_items=1000) plan.save() Subscription(owner=owner_profile, plan=plan).save() # create marketplace categories and sub-categories self.category = MarketCategory(marketplace=self.marketplace, name="Category") self.category.save() self.subcategory = MarketSubCategory(marketplace=self.marketplace, parent=self.category, name="SubCategory") self.subcategory.save() # create a user, profile and shipping data self.user = User.objects.create_user("test-user", "*****@*****.**", "test-user") Profile(user=self.user).save() shippingdata = ShippingData(first_name='User', last_name='Buyer', street_address="Calle 54", city="La Plata", state="Buenos Aires", zip="1900", country="AR") shippingdata.save() # create a shopping cart self.cart = Cart(shop=self.shop, bidder=self.user) self.cart.shippingdata = shippingdata self.cart.save()
def createUser(request): print "** createUser DEBUG LOG**" form = NewUserForm(request.POST) print 'form set' if form.is_valid(): newUser = form.save() newUserProfile = Profile(user=newUser) newUserProfile.save() print "user '%s' created" % newUser.username print '**OK**' return HttpResponseRedirect(reverse('home')) else: form = NewUserForm() print 'form reset' print '**ERR FORM CREATION FAILED**' return render(request, 'signup.html', {'form':form})
def get_agent(self, agent_name): try: usr = User.objects.get(username=agent_name) p = usr.get_profile() return p except User.DoesNotExist: try: usr = User.objects.create_user(agent_name, '*****@*****.**' % agent_name) usr.save() p = Profile(user=usr, primary_phone=agent_name) p.created_on = datetime.datetime.now() p.save() return p except Exception, e: log.error('Error creating agent %s' % repr(e)) return None
def create_temp_posts(): with open('fixtures/posts.json') as f: posts = json.load(f) for p in posts: t = Thread.select().where(Thread.id==p['thread']).get() u = Profile.select().where(Profile.id==p['author']).get() Post.create(author=u, thread=t, body=p['body'], is_sticky=[['is_sticky']])
def add_agents(): from users.models import Profile from django.contrib.auth.models import User f = open('chaupaati') lines = f.readlines() for line in lines: print line line = line.strip() print line.split(',') password, name, loginid = line.split(',') name = name.strip() first_name = name.split(' ')[0] loginid = loginid.strip() password = password.strip() u = User.objects.create_user(loginid, '*****@*****.**', password) u.name = name u.save() agent = Profile() agent.user = u agent.full_name = '%s%s' % (name,password) agent.primary_phone = '%s%s' % (first_name,password) agent.is_agent = True agent.save()
def register(request): response = JSONResponse("success") if request.method != 'POST': response.add_error('Bad request.') else: print request.POST['birthday'] valid = True match = User.objects.filter(username = request.POST['username']) if len(match) > 0: response.add_error('Username is already in use.', 'register_error') valid = False match = User.objects.filter(email = request.POST['email']) if len(match) > 0: response.add_error('Email address is already registered.', 'register_error') valid = False if len(request.POST['password']) < 6: response.add_error('The entered password is less than 6 characters.', 'register_error') valid = False if len(request.POST['username']) < 3: response.add_error('The requested username is too short.', 'register_error') valid = False if len(request.POST['firstname']) == 0 or len(request.POST['lastname']) == 0: response.add_error('You must provide both first and last name.', 'register_error') global mail_re if mail_re == None: mail_re = re.compile('^[a-zA-Z0-9._%-]+@[a-zA-Z0-9._%-]+.[a-zA-Z]{2,6}$') if mail_re.match(request.POST['email']) is None: response.add_error('Invalid email address', 'register_error') valid = False if valid == True: user = User.objects.create_user(request.POST['username'], request.POST['email'], request.POST['password']) user.save() profile = Profile() profile.userLink = user profile.birthday = datetime.datetime.strptime(request.POST['birthday'], '%Y-%m-%d').date() profile.firstname = request.POST['firstname'] profile.lastname = request.POST['lastname'] profile.country = request.POST['country'] profile.biography = request.POST['bio'] profile.rights = 0 profile.save() user = authenticate(username=request.POST['username'], password=request.POST['password']) login(request, user) return response.respond()
def get_or_create_user(username, email_id="", password=None, first_name="", last_name=""): usr = None profile = None if not username: return usr, profile username = username.strip() is_type = "id" if is_valid_mobile(username): is_type = "mobile" try: phone = Phone.objects.get(phone=username) profile = phone.user usr = profile.user except Phone.DoesNotExist: try: usr = User.objects.get(username=username) except User.DoesNotExist: usr = User(username=username, email="") if password is None or password == "": # use set_unusable_password to allow user to set his password in future usr.set_unusable_password() else: usr.set_password(password) if first_name: usr.first_name = first_name if last_name: usr.last_name = last_name usr.save() try: profile = Profile.objects.get(user=usr) except Profile.DoesNotExist: profile = Profile( user=usr, created_on=datetime.now(), primary_phone="", primary_email="", secondary_email="" ) profile.full_name = "%s %s" % (first_name, last_name) if first_name and last_name: profile.full_name = "%s %s" % (first_name, last_name) profile.save() phone = Phone(user=profile, phone=username, type="primary") phone.save() except Exception, e: log.exception("Error get_or_create_user %s" % repr(e)) return None, None
def new(request): if request.user.is_authenticated(): return redirect('microposts.views.index') elif request.POST: signup_form = SignupForm(request.POST) if signup_form.is_valid(): username = request.POST['username'] email = request.POST['email'] password = request.POST['password'] password_confirmation = request.POST['password_confirmation'] new_user = User.objects.create_user(username=username, email=email, password=password) user_profile = Profile(user=new_user) user_profile.save() user = authenticate(username=username, password=password) login(request, user) return render(request, 'microposts/index.html', {'current_user' : request.user}) return render(request, 'users/index.html', {'signup_form_errors' : signup_form.errors}) else: return render(request, 'users/index.html')
def save(self): new_user = User.objects.create_user( username=self.cleaned_data['username'], email=self.cleaned_data['email'], password=self.cleaned_data['password1'] ) new_user.first_name = self.cleaned_data['first_name'] new_user.last_name = self.cleaned_data['last_name'] new_user.is_active = False salt = sha.new(str(random.random())).hexdigest()[:5] activation_key = sha.new(salt + new_user.username.encode('ascii', 'ignore')).hexdigest() new_profile = Profile( user=new_user, activation_key=activation_key, hide_real_name=self.cleaned_data['hide_real_name'], ) new_user.save() new_profile.save() return new_profile
def setUp(self): self.owner = User.objects.create_user("owner", "*****@*****.**", "testpw") owner_profile = Profile(user=self.owner) owner_profile.save() self.user = User.objects.create_user("test", "*****@*****.**", "testpw") self.user2 = User.objects.create_user("user2", "*****@*****.**", "user2") Profile(user=self.user).save() Profile(user=self.user2).save() self.marketplace = MarketPlace( name="greatsomething", title="Great Something", slug="great-something", template_prefix="default", base_domain="greatsomething.com", ) self.marketplace.save() self.shop = Shop(marketplace=self.marketplace, admin=self.owner, name="test_shop") self.shop.save() Preference(shop=self.shop).save() self.shop.update() plan = SubscriptionPlan( plan_id=1, marketplace=self.marketplace, trial_period=True, total_store_revenue=1000, concurrent_store_items=1000, ) plan.save() Subscription(owner=owner_profile, plan=plan).save() self.category = MarketCategory(marketplace=self.marketplace, name="Category1") self.category.save() self.subcategory = MarketSubCategory(marketplace=self.marketplace, parent=self.category, name="SubCategory1") self.subcategory.save() self.cart = Cart(shop=self.shop, bidder=self.user) self.cart.save() self.cart2 = Cart(shop=self.shop, bidder=self.user2) self.cart2.save()
def run(): cursor = connections["old"].cursor() # Delete existing profiles print "Removing existing profiles..." Profile.objects.all().delete() # Delete existing users print "Removing existing users..." User.objects.exclude(pk=1).delete() cursor.execute("SELECT id, login, encrypted_password, title, description, email, " "homepage, institution, institution_url, grade_levels, department, " "specializations, state, biography, why_interested, publish_portfolio, " "publish_profile, role FROM _principals") total_items = cursor.rowcount print "Creating users..." cnt = 0 for id, login, encrypted_password, title, description, email, \ homepage, institution, institution_url, grade_levels, department, \ specializations, state, biography, why_interested, publish_portfolio, \ publish_profile, role in cursor.fetchall(): cnt += 1 if role is None: role = u"" if specializations is None: specializations = [] if homepage is None: homepage = u"" if institution is None: institution = u"" if institution_url is None: institution_url = u"" if department is None: department = u"" if state is None: state = u"" if biography is None: biography = u"" if why_interested is None: why_interested = u"" if publish_portfolio is None: publish_portfolio = False if publish_profile is None: publish_profile = False if grade_levels is None: grade_levels = [] principal_id = "oer.member.%i" % id try: first_name, last_name = title.split(None, 1) except ValueError: first_name = title last_name = u"" if len(first_name) > 30: first_name = first_name[:30] if len(last_name) > 30: last_name = last_name[:30] password = BCRYPT_PREFIX + encrypted_password user = User(username=login, password=password, email=email, first_name=first_name, last_name=last_name ) user.save() profile = Profile(user=user, principal_id=principal_id, homepage=force_unicode(homepage), institution=force_unicode(institution), institution_url=force_unicode(institution_url), department=force_unicode(department), specializations=u"\n".join(force_unicode(specializations)), state=force_unicode(state), biography=force_unicode(biography), why_interested=force_unicode(why_interested), publish_portfolio=publish_portfolio, publish_profile=publish_profile, role=force_unicode(role)) try: profile.save() except DatabaseError: import pprint pprint.pprint(locals()) raise for l in grade_levels: l = slugify(l) try: grade_level = GradeLevel.objects.get(slug=l) except GradeLevel.DoesNotExist: print l profile.grade_level.add(grade_level) if cnt % 100 == 0: print "%i of %i" % (cnt, total_items) print "Done!"
usr = User.objects.get(username=username) except User.DoesNotExist: usr = User(username=username, email=username) if password is None or password == "": usr.set_unusable_password() else: usr.set_password(password) if first_name: usr.first_name = first_name if last_name: usr.last_name = last_name usr.save() try: profile = Profile.objects.get(user=usr) except Profile.DoesNotExist: profile = Profile(user=usr, created_on=datetime.now()) profile.full_name = "%s %s" % (first_name, last_name) if first_name and last_name: profile.full_name = "%s %s" % (first_name, last_name) profile.save() email = Email(user=profile, email=username, type="primary", cleaned_email=clean_username) email.save() except Exception, e: log.exception("Error get_or_create_user %s" % repr(e)) return None, None log.info("get_or_create_user is_type is %s" % is_type) return usr, profile def formatMoney(value): try:
def add_user(doc): if doc['mobile'] in sellers: return u = User() try: u = User.objects.get(username=doc['mobile']) except User.DoesNotExist: pass u.username = doc['mobile'] if 'timestamp' in doc: u.timestamp = doc['timestamp'].strftime('%Y-%m-%d %H:%M:%S') else: if 'modificationTime' in doc: u.timestamp = doc['modificationTime'].strftime('%Y-%m-%d %H:%M:%S') u.save() p = Profile() try: p = Profile.objects.get(primary_phone=doc['mobile']) if p.id != doc['id']: record_duplicate(p.id, doc['id']) return except Profile.DoesNotExist: pass p.id = doc['id'] p.user = u p.full_name = doc.get('name','') p.gender = doc.get('gender','').lower() if len(p.gender) > 1: p.gender = p.gender[0] if doc.get('dateOfBirth',None): p.date_of_birth = doc['dateOfBirth'].strftime('%Y-%m-%d') p.primary_phone = doc['mobile'] p.secondary_phone = doc.get('mobile2','') p.primary_email = doc.get('email','').split(',')[0] p.secondary_email = doc.get('email2','').split(',')[0] p.buyer_or_seller = 'buyer' p.type = doc.get('type','individual') p.marketing_alerts = doc.get('dealAlerts','neutral') p.salt = doc.get('salt','') p.passcode = doc.get('passcode','') p.created_on = u.timestamp p.save()