def create_user(form, avatar): if not form.is_valid(): return json.dumps({ 'profile': None, 'message': 'Some of the data is invalid, try again.' }) data = form.cleaned_data try: user = User.objects.get(email=data['email']) except User.DoesNotExist: if not avatar: avatar = create_gravatar(data['email']) #Creando usuario: user = User.objects.create_user(data['email'], data['email'], data['password']) user.first_name = data['name'] user.last_name = data['last_name'] user.save() location = create_location(data['address'], data['postal_code'], data['city'], data['country']) profile = Profile(user=user, location=location, phone=data['phone'], social_avatar=avatar) profile.save() return json.dumps({ 'profile': serializers.serialize('json', [ profile, ]), 'message': 'OK.' }) return json.dumps({ 'profile': None, 'message': 'This email already exists, try again.' })
def test_password_encryption(): profile = Profile() password = '******' profile.password = password assert profile.password.hash is not None, 'Password should be encrypted' assert (profile.password == "Wrong pass") is False, 'Passwords should not match' assert profile.password == password, 'Passwords should match'
def free_profile(): """Unregistered in system profile""" raw_password = '******' p = Profile(name='Bob', email='*****@*****.**', birth_date=datetime(1990, 10, 20).date(), password=raw_password) p.id = 0 p.raw_password = raw_password return p
def process_request(self, request): user = users.get_current_user() request.user = None request.profile = None if user: request.user = user try: request.profile = Profile.all().filter('user =', user)[0] except IndexError, e: p = Profile(user=user) p.name = user.nickname() p.put() request.profile = p
def user_profile(request, username): profile = User.objects.get(username=username) try: profile_info = Profile.get_profile(profile.id) except: profile_info = Profile.filter_by_id(profile.id) businesses = Business.get_profile_businesses(profile.id) title = f'@{profile.username}' return render( request, 'profile.html', { 'title': title, 'profile': profile, 'profile_info': profile_info, 'businesses': businesses })
def new(request): user = request.user existing_profile = Profile.filter('user ='******'profile_edit', profile=existing_profile.uid)) return render('profile/new.html', {'user': user})
def create_user(form, avatar): if not form.is_valid(): return json.dumps({'profile': None, 'message':'Some of the data is invalid, try again.'}) data = form.cleaned_data try: user = User.objects.get(email=data['email']) except User.DoesNotExist: if not avatar: avatar = create_gravatar(data['email']) #Creando usuario: user = User.objects.create_user(data['email'], data['email'], data['password']) user.first_name = data['name'] user.last_name = data['last_name'] user.save() location = create_location(data['address'], data['postal_code'], data['city'], data['country']) profile = Profile(user=user, location=location, phone=data['phone'], social_avatar=avatar) profile.save() return json.dumps({'profile': serializers.serialize('json', [ profile, ]), 'message': 'OK.'}) return json.dumps({'profile': None, 'message': 'This email already exists, try again.'})
def show(request, profile_id): profile = Profile.all().filter('uid =', profile_id).get() #bd_end_user = EndUser(end_user_login=profile.uid) eul = "profile:%s" % profile.uid c = Client(settings.BDM_SECRET, settings.BDM_KEY) try: bd_end_user = c.get('end_user/%s' % eul)[0] except ValueError, e: payload = dict(end_user_login=eul) bd_end_user = c.post('end_user', payload=payload)[0]
def test_successful_registration(register, free_profile, session): res = register(email=free_profile.email, password=free_profile.raw_password, confirm=free_profile.raw_password, name=free_profile.name, birth_date=free_profile.birth_date) assert res.status_code == status_codes.REDIRECT, res.data.decode('utf-8') profile = Profile.get_by_email(free_profile.email) assert profile.name == free_profile.name assert profile.birth_date == free_profile.birth_date
def profile(session): """Registered but not authenticated in system Profile""" raw_password = '******' p = Profile(email='*****@*****.**', password=raw_password, name='John') session.add(p) session.commit() profile = Profile.get_by_email(p.email) profile.raw_password = raw_password return profile
def current_user(session, client, login): """Registered and authenticated profile""" email = '*****@*****.**' password = '******' birth_date = datetime.today() - timedelta(days=1) session.add(Profile(email=email, password=password, name='current_user', birth_date=birth_date.date())) session.commit() login(email, password=password) current_user = Profile.get_by_email(email) current_user.raw_password = password return current_user
def batch_delete(self): status = False try: ids = request.args['ids'].split(',') except ValueError: return self.response_bad_request() query = Profile.delete().where(Profile.id << ids) status = bool(query.execute()) return self.operationresponse(status=status)
def create(request): user = request.user existing_profile = Profile.filter('user ='******'name', None) if not name: raise Exception, 'do something smart here' raise NotImplementedError, 'may not be used'
def post(self, request): access_token_url = 'https://graph.facebook.com/v2.3/oauth/access_token' graph_api_url = 'https://graph.facebook.com/v2.3/me' params = { 'client_id': request.data['clientId'], 'redirect_uri': request.data['redirectUri'], 'client_secret': settings.FACEBOOK_SECRET, 'code': request.data['code'], } r = requests.post(access_token_url, params) access_token = json.loads(r.text) # GET => https://graph.facebook.com/v2.3/me # to get user profile (email, first_name, last_name, gender, id) r = requests.get(graph_api_url, params=access_token) profile = json.loads(r.text) # Check if email exists user = User.objects.filter(email=profile['email']).first() if not user: # User doesn't exists, Create user model name = profile['first_name'].replace(' ', '').lower() user = User.objects.create_user(profile['email'], password=None, first_name=profile['first_name'], last_name=profile['last_name'], provider="Facebook") user_profile = Profile(owner=user, facebook_id=profile['id'], facebook_token=access_token['access_token']) user_profile.save() else: # User Exists user_connected = Profile.objects.filter(facebook_id=profile['id']).first() if not user_connected: # create profile with facebook_token user_profile = Profile(owner=user, facebook_id=profile['id'], facebook_token=access_token['access_token']) user_profile.save() user.first_name = profile['first_name'] user.last_name = profile['last_name'] user.save() # Create token for user token, created = Token.objects.get_or_create(user=user) data = { 'token': token.key, } return Response(data)
def profile_with_best_friend(session, profile): """Registered profiles with best friend""" raw_password = '******' email = '*****@*****.**' p = Profile(email=email, password=raw_password, name='Profile with best friend') p.send_request(profile) profile.confirm_request(p) p.set_best_friend(profile) session.commit() p = Profile.get_by_email(email) p.raw_password = raw_password return p
def generate_profile(strategy, details, user, is_new=True, *args, **kwargs): """ generate a Trinity Force Network profile from the social information, if available """ if not is_new: return else: profile = Profile.create(user.username) for name, value in details.items(): if not hasattr(profile, name): continue current_value = getattr(profile, name, None) if not current_value or name not in protected: setattr(profile, name, value) try: profile.save() except: return redirect("profile", incomplete=True) else: return { 'profile': profile } #end generate_profile
def get(self, request): if request.user.is_authenticated() : data = request.query_params #return Response(data) #user_id = request.user.id balance_id=data.get('balance_id') month = data.get('month') year = data.get('year') if balance_id=='undefined': balance_id=None elif int(balance_id) <= 0: balance_id=None ##btype = type(balance_id) profiles = Profile.objects.filter(user=request.user) profile=None if profiles is not None and profiles.count() > 0: profile = profiles[0] else: profile=Profile(user=request.user,address='address') profile.save() ##return Response({'user_id':user_id, 'btype':btype}) balances = Balance.objects.all() balances=balances.filter(user=profile) earliestBalance=None latestBalance=None if(len(balances)>0): earliestBalance=balances[0] latestBalance=balances.order_by('-created')[0] if balance_id is not None : self.debug('balance_id:'+balance_id) balances=balances.filter(id=balance_id) ### filter by year, monht if len(balances) > 0: balances=balances.filter(month=month,year=year) if len(balances) > 0: balances=balances.order_by('created') return self._resBlance(balances[0],earliestBalance,latestBalance) """ serializer = self.serializer_class(balances[0]) res=serializer.data if(earliestBalance is not None): res['earliestdate']="1-%s-%s" % (earliestBalance.month,earliestBalance.year,) if(latestBalance is not None): res['latestdate']="1-%s-%s" % (latestBalance.month,latestBalance.year,) return Response(res) """ else: return self._resBlance(latestBalance,earliestBalance,latestBalance) else: return self._resBlance(latestBalance,earliestBalance,latestBalance) else: return self._resBlance() return unautorized_response()
def votes(request, game_id, round_id, thread_id): thread = Thread.get_by_uid(thread_id) game = Game.get_by_uid(game_id) if thread is None: raise Http404 if not thread.profile_can_view(request.profile): return HttpResponse('Unauthorized', status=401) if request.method == 'GET': since = request.GET.get('since', None) return json(Vote.get_activities(request.user, thread, since=since)) if request.method == 'POST': if not thread.profile_can_create(request.profile): return HttpResponse('Unauthorized', status=401) # find the target target_id = request.POST.get('target_id', None) if target_id is None: raise Exception('No target') target_profile = Profile.get_by_uid(target_id) target = Role.all().filter('player', target_profile) target = target.filter('game', game) target = target.fetch(1)[0] # find the last vote this user made (if any) game = Game.get_by_uid(game_id) actor = Role.get_by_profile(game, request.profile) last_vote = Vote.all().filter("thread", thread) last_vote = last_vote.filter("actor", actor) last_vote = last_vote.order("-created") try: last_vote = last_vote.fetch(1)[0] except IndexError, e: last_vote = None # if we found a vote, decrement that vote's counter if last_vote is not None: last_vote.decrement() # create the new vote vote = Vote(actor=actor, target=target, thread=thread) vote.put() # increment the counter vote.increment() if thread.name == role_vanillager: vote_count = Vote.all().filter('thread', thread).count() if not vote_count: # First vote in round c = Client(settings.BDM_SECRET, settings.BDM_KEY) eul = "profile:%s" % request.profile.uid c.post("named_transaction_group/613301/execute/%s" % eul) if thread.round.number == 1: # First vote in game c.post("named_transaction_group/613302/execute/%s" % eul) return json(vote)
def other_profile(free_profile, session): session.add(free_profile) session.commit() return Profile.get_by_email(free_profile.email)
def test_get_by_email_none_for_empty_value(session): assert Profile.get_by_email(None) is None assert Profile.get_by_email('') is None
def test_get_by_email(session): email = '*****@*****.**' session.add(Profile(email=email, password='******')) session.commit() assert Profile.get_by_email(email) is not None