def authorize(request): if request.method == 'POST': form = RegisterForm(request.POST) if form.is_valid(): saved_row = form.save() profile = Profile(first_name=form.cleaned_data.get('first_name'), last_name=form.cleaned_data.get('last_name'), email=form.cleaned_data.get('email'), phone=form.cleaned_data.get('phone'), gender=form.cleaned_data.get('gender'), is_veg='N', is_smoke='N', is_alcohol='N', university='Dalhousie', branch='CSE') values = profile.save() username = form.cleaned_data.get('username') raw_password = form.cleaned_data.get('password1') user = authenticate(username=username, password=raw_password) login(request, user) print(profile.user_id) return render_to_response('home.html', {'profile_user_id': profile.user_id}, locals()) else: return render(request, 'signup.html', {'form': form}) else: form = RegisterForm() return render(request, 'signup.html', {'form': form})
def create(self, request, *args, **kwargs): nickname = request.data['nickname'] if False else ' ' sex= request.data['sex'] if False else 1 phone = request.data['phone'] if False else ' ' data = { 'email':request.data['email'], 'username':request.data['username'], 'password':request.data['password'], 'nickname':nickname, 'sex':sex, 'phone':phone, } # 这里还要添加验证模型的东西 user = User(email = data['email'],username = data['username'],password = data['password'],is_active = 0) try: user.save() profile = Profile(nickname=data['nickname'], sex=data['sex'], phone=data['phone'], user=user,user_id=user.id) profile.save() signals.user_registered.send(sender=self.__class__, user=user, request=self.request) if 1: self.send_activation_email(user) elif settings.get('SEND_CONFIRMATION_EMAIL'): self.send_confirmation_email(user) return Response({'status': 'User created success'}, status=status.HTTP_201_CREATED) except: return Response({'status': 'error'}, status=status.HTTP_400_BAD_REQUEST)
def overview(request): try: profile = request.user.get_profile() except: profile = Profile() profile.user = request.user profile.save() return 'overview.html', {'profile': profile, 'groups': profile.get_groups()}
def replace(profile: Profile, target: str, replaces: Dict[Any, Any]) -> None: """Apply all replace operations on profile payload.""" matches = profile.find_payload(target, lambda x: x.value in replaces) for match in matches: new_value = replaces[match.value] # do replace operation without committing to database profile.update_payload(match.full_path, new_value, commit=False) if matches: # finally commit changes to database profile.save()
async def prepare_db_request(self, data: dict) -> dict: """ Prepare request to db. Replace Profile.user_id to int32 value from db. Args: data: dict with user data for Profile object. Returns: dict with user profile. """ profile = Profile(**data) profile.user_id = await get_next_sequence_value( self.request.app['db'], "user_id") return profile.to_dict()
def calculate_over_40(self): from profile.models import Profile try: ## try to get the user's DOB from their profile, if no profile # is made, assume they are over 40 dob = Profile.get_for_user(self.user).dob except AttributeError, Profile.DoesNotExist: dob = datetime.date(1915, 7, 21)
def _check_and_save_user_atomic(fb_user): try: #FIXME: This can be improved to be checked after uid in the facebook cookie user = User.objects.get(email=fb_user['email']) return (user, None, False) except User.DoesNotExist: # Save it to our db username = _get_username_from_fb_user(fb_user) user = User.objects.create(username=username, email=fb_user['email'], first_name=fb_user['first_name'].title(), last_name = fb_user['last_name'].title()) profile = Profile() profile.user = user profile.save(force_insert=True) return (user, profile, True)
def calculate_over_40(self): from profile.models import Profile try: ## try to get the user's DOB from their profile, if no profile # is made, assume they are over 40 dob = Profile.get_for_user(self.user).dob except AttributeError, Profile.DoesNotExist: dob = datetime.date(1915,7,21)
def create_user(request): if request.method == "POST": form = ProfileCreationForm(request.POST) if form.is_valid(): data = form.cleaned_data if request.user.is_authenticated(): user = request.user user.backend = "django.contrib.auth.backends.ModelBackend" else: user = form.save() profile = Profile() profile.user = user user.email = data["email"] profile.dob = data["dob"] profile.gender = data["gender"] profile.phone = data["phone"] profile.save() user.save() user = authenticate(username=request.POST["username"], password=request.POST["password1"]) login(request, user) return HttpResponseRedirect(reverse("home")) else: if request.user: user = request.user context = {} context["username"] = user.username context["first_name"] = user.first_name context["last_name"] = user.last_name context["email"] = user.email form = ProfileCreationForm(context) return render(request, "profile_registration.html", {"form": form})
def new_user(sender, instance, **kwargs): if not Profile.objects.filter(user=instance).count(): profile = Profile(user=instance) profile.save() else: profile = Profile.objects.get(user=instance) avatars = os.path.join(_settings.AVATARS_DIR, profile.slug) if not os.path.exists(avatars): os.makedirs(avatars) # FIXME: # FIXME: Lanzar señal que atrape la app core y cree sus directorios. wallpapers = os.path.join(django_settings.UPLOAD_DIR, profile.slug) if not os.path.exists(wallpapers): os.makedirs(wallpapers) return True
def bargraph_image(request, column, func, agg): import bargraph as g if agg == "person": Graph = g.PersonBarGraph elif agg == "student": Graph = g.StudentBarGraph elif agg == "captain": Graph = g.CaptainBarGraph elif agg == "first_officer": Graph = g.FOBarGraph elif agg == "instructor": Graph = g.InstructorBarGraph elif agg == "type": Graph = g.PlaneTypeBarGraph elif agg == "tailnumber": Graph = g.TailnumberBarGraph elif agg == "manufacturer": Graph = g.ManufacturerBarGraph elif agg == "category_class": Graph = g.CatClassBarGraph elif agg == "model": Graph = g.ModelBarGraph elif agg == "year": Graph = g.YearBarGraph elif agg == "month": Graph = g.MonthBarGraph elif agg == "day_of_the_week": Graph = g.DOWBarGraph elif agg == "month_year": Graph = g.MonthYearBarGraph else: assert False, "Agg not added to generator view" graph = Graph(request.display_user, column, agg, func) from profile.models import Profile graph.color_profile = Profile.get_for_user(request.display_user).style return graph.as_png()
def create(self, validated_data): """ Create and return a new User instance, given the validated data. """ profile_data = validated_data.pop('profile') user = super(UserSerializer, self).create(validated_data) user.date_joined = datetime.today() user.set_password(validated_data['password']) user.save() profile = Profile( user=user, cba_username=profile_data.get('cba_username').strip(), cba_user_token=profile_data.get('cba_user_token').strip()) profile.save() return user
def save(self, location, language): data = self.cleaned_data user = super(RegistrationForm, self).save(commit=False) user.last_login = timezone.now() user.email = data['email'] user.first_name = data['first_name'] # user.last_name = data['last_name'] user.save() profile = Profile(user=user, name=data.get('name', data['username'])) if not location.id: location.save() profile.location = location # profile.name = data['first_name'] + ' ' + data['last_name'] profile.save() profile.settings.email = data['email'] profile.settings.language = language profile.settings.feed_radius = -1 profile.settings.save() return profile
def create_profile(): data = request.get_json() new_profile = Profile(name=data['name'], address=data['address'], phone_number=data['phone_number']) db.session.add(new_profile) db.session.commit() return jsonify({'message': 'New profile created!'})
def bargraph_image(request, column, func, agg): import bargraph as g if agg == 'person': Graph = g.PersonBarGraph elif agg == 'student': Graph = g.StudentBarGraph elif agg == 'captain': Graph = g.CaptainBarGraph elif agg == 'first_officer': Graph = g.FOBarGraph elif agg == 'instructor': Graph = g.InstructorBarGraph elif agg == 'type': Graph = g.PlaneTypeBarGraph elif agg == 'tailnumber': Graph = g.TailnumberBarGraph elif agg == 'manufacturer': Graph = g.ManufacturerBarGraph elif agg == 'category_class': Graph = g.CatClassBarGraph elif agg == 'model': Graph = g.ModelBarGraph elif agg == 'year': Graph = g.YearBarGraph elif agg == 'month': Graph = g.MonthBarGraph elif agg == 'day_of_the_week': Graph = g.DOWBarGraph elif agg == 'month_year': Graph = g.MonthYearBarGraph else: assert False, "Agg not added to generator view" graph = Graph(request.display_user, column, agg, func) from profile.models import Profile graph.color_profile = Profile.get_for_user(request.display_user).style return graph.as_png()
def create_profile_data(strategy, user, response, details, is_new=False, *args, **kwargs): if is_new: if 'fullname' in details: full_name = details['fullname'] else: full_name = user.username new_profile = Profile(user=user, name=full_name) new_profile.user_id = user.id new_profile.name = user.username new_profile.user.email = details[ 'email'] if 'email' in details else None url = 'https://graph.facebook.com/{0}/picture'.format(response['id']) try: img_content = request('GET', url, params={'type': 'large'}) file_path = os.path.join( os.path.dirname(os.path.dirname(os.path.dirname(__file__))), 'uploads', 'facebook', '{0}__social.jpg'.format(user.id)) with open(file_path, 'wb+') as destination: img_file = ContentFile(img_content.content) for chunk in img_file.chunks(): destination.write(chunk) new_profile.photo = 'facebook/{0}__social.jpg'.format(user.id) new_profile.save() profile_settings = Settings.objects.get(profile_id=new_profile.id) profile_settings.email = details[ 'email'] if 'email' in details else None profile_settings.feed_radius = -1 profile_settings.save() return except Exception as e: raise e elif user.date_joined >= (datetime.datetime.now(tz=pytz.utc) - datetime.timedelta(hours=1)): existing_profile = Profile.objects.get(user_id=user.id) url = 'https://graph.facebook.com/{0}/picture'.format(response['id']) try: img_content = request('GET', url, params={'type': 'large'}) file_path = os.path.join( os.path.dirname(os.path.dirname(os.path.dirname(__file__))), 'uploads', 'facebook', '{0}__social.jpg'.format(user.id)) with open(file_path, 'wb+') as destination: img_file = ContentFile(img_content.content) for chunk in img_file.chunks(): destination.write(chunk) existing_profile.photo = 'facebook/{0}__social.jpg'.format(user.id) existing_profile.save() except Exception as e: raise e
def create_fingr_user(email, password, **kwargs): """ This function takes clean data to create a fingr user, please do not create one yourself """ # the django create_user method automatically saves it in the database for us django_user = User.objects.create_user(username=email, email=email, password=password) initial_location = UserLocation(latitude=UNSW_LATITUDE, longitude=UNSW_LONGITUDE) initial_location.save() profile = Profile() profile.save() fingr_user = FingrUser( django_user=django_user, username=email, email=email, my_location=initial_location, profile=profile, **kwargs ) fingr_user.save() return fingr_user
async def post(self) -> Union[web.json_response, web.HTTPException]: """ Take user credentials and check if user exist. If exist - return his profile in JSON. Else -> HTTPException Returns: User profile or Exception """ request_data = await self.request.json() result = await self.find_user(request_data) if not result: raise web.HTTPNotFound(text="User not found") profile = Profile(**clean_data(result)) if profile.check_password(request_data['password']): await profile.fetch_contacts(self.request.app['db']) return web.json_response(profile.to_dict(), status=200) raise web.HTTPNotAcceptable(text="Wrong password")
def complete_registration(request): if request.user.is_authenticated(): return http.HttpResponseForbidden(u'Вы попали сюда по ошибке') try: identity_id = request.session.get('users_complete_reg_id', None) user_map = models.UserMap.objects.get(identity__id=identity_id) except models.UserMap.DoesNotExist: return http.HttpResponseForbidden(u'Вы попали сюда по ошибке') if not user_map.user.username: user_map.user.username = user_map.user.email.split('@')[0] user_map.user.save() profile = Profile(user=user_map.user, summa=0) profile.save() user_map.verified = True user_map.save() user = auth.authenticate(user_map=user_map) auth.login(request, user) messages.info(request, u'Добро пожаловать!') del request.session['users_complete_reg_id'] return redirect('/')
def insert_mock_data(self): import csv from profile.models import Profile from audioanalysis.models import Audio from django.db import connection # from django.contrib.auth.models import User from profile import definitions import random import pycountry from faker import Faker from datetime import datetime from users.models import CustomUser as User #self.delete_all_users_except_admins() fake = Faker(['en_US']) for i in range(0, 1000): first_name = fake.first_name() last_name = fake.last_name() # get first character of first name, full last name, 4 random numbers nums = ''.join([str(random.randint(0,9)) for p in range(0,4)]) email = first_name[0][:1].lower()+last_name+nums+random.choice(self.email_prefix) # 1994-12-21 birth_date = fake.date_of_birth(tzinfo=None, minimum_age=0, maximum_age=115).strftime('%Y-%m-%d') country = random.choice(list(pycountry.countries)).name # Create a user that will go in auth_user table user_one_to_one = self.create_random_user(email_from_profile_object=email) profile = Profile(user=user_one_to_one, first_name=first_name, last_name=last_name, email=email, birth_date=birth_date, country=country) #print(profile) profile.save() # connect audio file to user audio_file = Audio(user=user_one_to_one, name=self.s3_urls[0].split("/")[-1], s3_url=self.s3_urls[0]) audio_file.save() audio_file = Audio(user=user_one_to_one, name=self.s3_urls[1].split("/")[-1], s3_url=self.s3_urls[1]) audio_file.save() print("Created user " + str(i)) # Create admin users user = User.objects.create_superuser('lmp004', '*****@*****.**', 'password') profile = Profile(user=user, first_name='Logan', last_name="Phillips", email='*****@*****.**', birth_date='1996-04-24', country='America') # profile = Profile(user=user, first_name='Logan', last_name=None, email='*****@*****.**', birth_date=None, country=None) profile.save()
def save_and_login(self, request): 'Create this user in the database, log that user in, and return the Profile' first_name = self.cleaned_data['first_name'] last_name = self.cleaned_data['last_name'] #username = defaultfilters.slugify(self.cleaned_data['email'])[:30] username = Profile.objects.unique_username(first_name, last_name) email = self.cleaned_data['email'] password = self.cleaned_data['password'] new_user = User.objects.create_user(username, email, password) new_user.first_name = first_name new_user.last_name = last_name new_user.save() geuser = Profile(user = new_user, timezone=self.cleaned_data['timezone']) referer = None referer_id = None if 'f' in request.GET: referer_id = request.GET['f'] elif 'f' in request.COOKIES: referer_id = request.COOKIES['f'] if referer_id: try: referer = Profile.objects.get(pk = long(referer_id)) referer.add_participation_points(points=5) referer.save() geuser.referer = referer except (Profile.DoesNotExist, ValueError): pass geuser.save() if self.cleaned_data['picture']: relative_pic_name = save_picture(geuser, self.cleaned_data['picture']) geuser.avatar = relative_pic_name #else: # relative_pic_name = save_gravatar(geuser) geuser.save() if self.cleaned_data['group']: group_id = self.cleaned_data['group'] group = Group.objects.get(pk = group_id) geuser.groups.add(group) user = authenticate(username=new_user.username, password=password) login(request, user) return geuser
def proper_ad(request): u = getattr(request, "display_user", None) or request.user style = Profile.get_for_user(u).style if True: #random.choice([True] * 20 + [False]): ad_text = GOOGLE_ADS[style] else: ad_text = WIKI_ADS[style] ####### import os CSS_URL = os.path.join(settings.MEDIA_URL, "css", "style-%s" % style) return {"proper_ad": ad_text, 'CSS_URL': CSS_URL}
def users_search(request, key): blocked_users = set() for e in request.user.profile.blocking.filter( user_id=request.user.profile).select_related('blocking_user_id'): blocked_users.add(e.blocking_user_id) try: users = Profile.filter(username__icontains=key).exclude(blocked_users) except Profile.DoesNotExist: users = None context = { 'title': 'Search | ClickTime', 'users': users, } return render(request, 'home/users_search.html', context=context)
def css_path(request): """ Return the path to the CSS directory based on the display user's profile. if no display user, it falls back to request.user """ return {} u = getattr(request, "display_user", None) or request.user from profile.models import Profile style = Profile.get_for_user(u).style import os CSS_URL = os.path.join(settings.MEDIA_URL, "css", "style-%s" % style) return {"CSS_URL": CSS_URL}
def sync_users(self, xml, company): for person in xml.findall('person'): email = person.find('email-address').text first_name = person.find('first-name').text last_name = person.find('last-name').text basecamp_id = person.find('id').text created = False try: user = User.objects.get(profile__basecamp_id=basecamp_id) user.email = email self.stdout.write("User %s already exist." % user) except User.DoesNotExist: try: user = User.objects.get(email=email) created = True self.stdout.write("User %s already exist." % user) except User.DoesNotExist: username = email.split('@')[0] try: User.objects.get(username__iexact=username) while True: username = sha_constructor(str(random.random()).encode('utf-8')).hexdigest()[:5] try: User.objects.get(username__iexact=username) except User.DoesNotExist: break except User.DoesNotExist: pass user = UserenaSignup.objects.create_user(username, email, username+username, not userena_settings.USERENA_ACTIVATION_REQUIRED, userena_settings.USERENA_ACTIVATION_REQUIRED) created = True self.stdout.write("User %s creates." % user) if first_name: user.first_name = first_name if last_name: user.last_name = last_name user.save() company.add_user(user) try: account = Profile.objects.get(user=user) except Profile.DoesNotExist: account = Profile(user=user) account.save() if created: account.basecamp_id = basecamp_id account.save()
def edit(request): try: profile = request.user.get_profile() except Profile.DoesNotExist: profile = Profile(user=request.user) if request.method == 'POST': form = ProfileForm(request.POST, instance=profile) if form.is_valid(): form.save() return HttpResponseRedirect(reverse(edit) + '?saved') else: form = ProfileForm(instance=profile) return render_to_response('profile/edit.html', {'form': form, 'saved': True if 'saved' in request.GET\ else False}, context_instance = RequestContext(request))
def create_players(self, team, name, coach, height, score=score): team_name = Team.objects.filter(name=team).first() player = Players.objects.filter(name=name, team=team_name).first() if not player: player = Players() player.team = team_name player.name = name player.score = score player.coach = coach player.height = height if coach is True: coach_exists = Players.objects.filter(team=team_name, is_coach=True).first() if coach_exists is not None: raise ValueError("Cannot have more than 1 coach in a team.") else: player.is_coach = coach player.save() Profile().add_user(player=player)
def determine(self, view, field, request, *args, **kwargs): if not getattr(request, 'shared'): ## if it's not shared, then do nothing (user is viewing their ## own account) return view(request, *args, **kwargs) user = request.display_user from profile.models import Profile profile = Profile.get_for_user(user) if not field == 'NEVER': from django.conf import settings if getattr(user, "id", 0) == settings.DEMO_USER_ID: ## demo user, let them go hog wild return view(request, *args, **kwargs) go_ahead = getattr(profile, "%s_share" % field) ## can not view page because the user doesn't want it shared, ## either redirect to a page that can be shared, or redirect ## to the root page if field == 'NEVER' or not go_ahead: from django.http import HttpResponseRedirect from django.core.urlresolvers import reverse if getattr(profile, "logbook_share"): url = reverse('logbook', kwargs={"username": user.username}) elif getattr(profile, "other_share"): url = reverse('linegraphs', kwargs={"username": user.username}) else: url = "/" return HttpResponseRedirect(url) # passes validation, render the view return view(request, *args, **kwargs)
def fb_registration_callback(request): """ This view only gets hit by the facebook callback when a user registers. """ signed_request = request.POST['signed_request'] response = parse_signed_request(signed_request, settings.FACEBOOK_SECRET) data = response['registration'] u = User( username=data['username'], email=data['email'], first_name=data['first_name'], last_name=data['last_name'], ) d, m, y = data['birthday'].split('/') dob = datetime.datetime(year=y, month=m, date=d) p = Profile( user=u, dob=dob, ) print response
def login_on_activation(sender, user, request, **kwargs): profile = Profile(user=user, summa=0) profile.save() user.backend='django.contrib.auth.backends.ModelBackend' login(request,user)
def login_on_activation(sender, user, request, **kwargs): profile = Profile(user=user, summa=0) profile.save() user.backend = 'django.contrib.auth.backends.ModelBackend' login(request, user)
def edit_about(userId): """ Profile post method to edit about """ edit_about_form = EditAbout() if edit_about_form.validate_on_submit(): birthday = edit_about_form.birthday.data political_spectrum = edit_about_form.political_spectrum.data political_party = edit_about_form.political_party.data favourite_news_websites = edit_about_form.favourite_news_websites.data allow_location_detection = edit_about_form.allow_location_detection.data profile = Profile.query.filter_by(user_id=userId).first() if profile: # update profile if profile.birthday != birthday: profile.birthday = birthday db.session.flush() if profile.political_spectrum != political_spectrum: profile.political_spectrum = political_spectrum db.session.flush() if profile.political_party != political_party: profile.political_party = political_party db.session.flush() if profile.favourite_news_websites != ",".join( favourite_news_websites): profile.favourite_news_websites = ",".join( favourite_news_websites) db.session.flush() if profile.allow_location_detection == True and allow_location_detection == 'no' or profile.allow_location_detection == False and allow_location_detection == 'yes': if allow_location_detection == 'yes': profile.allow_location_detection = True else: profile.allow_location_detection = False db.session.flush() else: # create new profile # convert allow_location_detection to bool allow_bool = None if allow_location_detection == 'yes': allow_bool = True else: allow_bool = False profile = Profile(userId, birthday, political_spectrum, political_party, favourite_news_websites, allow_bool, None, None, None) db.session.add(profile) db.session.flush() # if allow_location_detection, get location if profile.allow_location_detection == True: g = geocoder.ip('me') if profile.location != g.city + ", " + g.country or profile.lat != g.latlng[ 0] or profile.lon != g.latlng[1]: # add location profile.lat = g.latlng[0] profile.lon = g.latlng[1] profile.location = g.city + ", " + g.country db.session.flush() db.session.commit() return redirect(url_for('about'))
def before_request(): # Begin transaction g.db = SQLA_session() g.user = profile_model.query_db().get(session["user_id"])