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
