def add_score(request):
if request.method != 'POST':
players = Player.gql("WHERE owner = :owner AND active = True ORDER BY name", owner=request.user)
return render_to_response(request, 'pingpong/addscore.html',
{ 'players': players, })
else:
mode = 'singles' # Used when we re-direct back to the main view
try:
# Find players. Save teams. Save game using a ranking system.
t1p1 = get_object(Player, request.POST['t1p1'])
t1p2 = get_object(Player, request.POST['t1p2'])
t2p1 = get_object(Player, request.POST['t2p1'])
t2p2 = get_object(Player, request.POST['t2p2'])
t1s = float(request.POST['t1s'])
t2s = float(request.POST['t2s'])
t1 = db_create(Team, player1=t1p1, player2=t1p2, points=t1s)
t2 = db_create(Team, player1=t2p1, player2=t2p2, points=t2s)
game = db_create(Game, team1=t1, team2=t2)
save_player_games(game, t1p1, t1p2, t2p1, t2p2, t1s, t2s)
doubles = (t1p1 != None and t1p2 != None and t2p1 != None and t2p2 != None)
if doubles:
mode = 'doubles'
ranking_system = DefaultRankingSystem()
ranking_system.save_game(t1p1=t1p1, t1p2=t1p2, t2p1=t2p1, t2p2=t2p2,
t1s=t1s, t2s=t2s, t1=t1, t2=t2, game=game, doubles=doubles)
response_dict = { 'status': True, 'message': 'Scores successfully saved.',
'mode': mode, 'game': str(game.key()) }
except:
logging.exception('There was a problem adding scores')
response_dict = { 'status': False, 'message' : 'Hmmm... There was a problem saving your scores - please have another go.', 'mode': mode }
return HttpResponse(simplejson.dumps(response_dict), mimetype='application/json')
def process_request(self, request):
# Ignore port if it's 80 or 443
if ':' in request.get_host():
domain, port = request.get_host().split(':')
if int(port) not in (80, 443):
domain = request.get_host()
else:
domain = request.get_host().split(':')[0]
# Try exact domain and fall back to with/without 'www.'
site = Site.all().filter('domain =', domain).get()
if not site:
if domain.startswith('www.'):
fallback_domain = domain[4:]
else:
fallback_domain = 'www.' + domain
site = Site.all().filter('domain =', fallback_domain).get()
# Add site if it doesn't exist
if not site and getattr(settings, 'CREATE_SITES_AUTOMATICALLY', True):
site = db_create(Site, domain=domain, name=domain)
site.put()
# Set SITE_ID for this thread/request
if site:
SITE_ID.value = str(site.key())
else:
SITE_ID.value = _default_site_id
def settings(request):
if request.method != 'POST':
players = Player.gql("WHERE owner = :owner AND active = True ORDER BY name", owner=request.user)
return render_to_response(request, 'pingpong/settings.html',
{ 'players': players, 'email': request.user.email })
else:
errors = {}
try:
# Save email address
email = request.POST['email']
if is_valid_email(email.strip()):
user = request.user
user.email = email.strip()
user.save()
else:
errors['email'] = 'Invalid email address'
# Add any new players
new_players = request.POST['newplayers']
if new_players:
players = new_players.splitlines()
for p in players:
if len(p.strip()) > 0:
db_create(Player, name=p.strip(), owner=request.user)
# Update player names based on posted values
for k, v in request.POST.items():
if str(k).endswith('_player'): # Expected key format: <key>_player
player = get_object(Player, str(k)[:-7])
if player:
if len(v.strip()) > 0:
player.name = v # Value is the updated player name
player.put()
else:
errors[str(k)[:-7]] = 'Invalid name'
if len(errors) == 0:
response_dict = { 'status': True, 'message': 'Settings successfully saved.' }
else:
response_dict = { 'status': False, 'message': 'Hmmm... There was a problem saving your settings - please have another go.',
'errors': errors }
return HttpResponse(simplejson.dumps(response_dict), mimetype='application/json')
except:
logging.exception('There was a problem saving settings')
response_dict = { 'status': False, 'message': 'Hmmm... There was a problem saving your settings - please have another go.',
'errors': errors }
return HttpResponse(simplejson.dumps(response_dict), mimetype='application/json')
def save_player_games(game, p1, p2, p3, p4, t1s, t2s):
if p1 != None:
db_create(PlayerGame, player=p1, game=game, date_played=game.date_played, won=game.won(p1),
t1p1=p1, t1p2=p2, t2p1=p3, t2p2=p4, team1_points=t1s, team2_points=t2s)
if p2 != None:
db_create(PlayerGame, player=p2, game=game, date_played=game.date_played, won=game.won(p2),
t1p1=p1, t1p2=p2, t2p1=p3, t2p2=p4, team1_points=t1s, team2_points=t2s)
if p3 != None:
db_create(PlayerGame, player=p3, game=game, date_played=game.date_played, won=game.won(p3),
t1p1=p1, t1p2=p2, t2p1=p3, t2p2=p4, team1_points=t1s, team2_points=t2s)
if p4 != None:
db_create(PlayerGame, player=p4, game=game, date_played=game.date_played, won=game.won(p4),
t1p1=p1, t1p2=p2, t2p1=p3, t2p2=p4, team1_points=t1s, team2_points=t2s)
def create_user(self, rpx_auth_info):
"""Creates user based on the RPX authentication info."""
username = rpx_auth_info.get_user_name()
user = dbutils.db_create(User, username=username, email=rpx_auth_info.get_email())
if not user:
raise Exception('Cannot create user (name = %s)' % username)
self.logger.debug("RpxBackend: Created user(%s) as %s\r\n" % (user.username, str(user)))
user.is_active = True
user.is_staff = False
user.is_superuser = False
user.set_unusable_password()
user.save()
rpxdata = RpxData(key_name=self.create_rpx_key(rpx_auth_info.get_rpx_id()), user=user)
rpxdata.save()
self.logger.debug("RpxBackend: RpxData created\r\n")
return user
def create_profile(request, form_class=None, success_url=None,
template_name='profiles/create_profile.html',
extra_context=None):
"""
Create a profile for the current user, if one doesn't already
exist.
If the user already has a profile, as determined by
``request.user.get_profile()``, a redirect will be issued to the
:view:`profiles.views.edit_profile` view. If no profile model has
been specified in the ``AUTH_PROFILE_MODULE`` setting,
``django.contrib.auth.models.SiteProfileNotAvailable`` will be
raised.
**Optional arguments:**
``extra_context``
A dictionary of variables to add to the template context. Any
callable object in this dictionary will be called to produce
the end result which appears in the context.
``form_class``
The form class to use for validating and creating the user
profile. This form class must define a method named
``save()``, implementing the same argument signature as the
``save()`` method of a standard Django ``ModelForm`` (this
view will call ``save(commit=False)`` to obtain the profile
object, and fill in the user before the final save). If the
profile object includes many-to-many relations, the convention
established by ``ModelForm`` of using a method named
``save_m2m()`` will be used, and so your form class should
also define this method.
If this argument is not supplied, this view will use a
``ModelForm`` automatically generated from the model specified
by ``AUTH_PROFILE_MODULE``.
``success_url``
The URL to redirect to after successful profile creation. If
this argument is not supplied, this will default to the URL of
:view:`profiles.views.profile_detail` for the newly-created
profile object.
``template_name``
The template to use when displaying the profile-creation
form. If not supplied, this will default to
:template:`profiles/create_profile.html`.
**Context:**
``form``
The profile-creation form.
**Template:**
``template_name`` keyword argument, or
:template:`profiles/create_profile.html`.
"""
try:
profile_obj = request.user.get_profile()
if profile_obj:
return HttpResponseRedirect(reverse('profiles_edit_profile'))
except ObjectDoesNotExist:
pass
#
# We set up success_url here, rather than as the default value for
# the argument. Trying to do it as the argument's default would
# mean evaluating the call to reverse() at the time this module is
# first imported, which introduces a circular dependency: to
# perform the reverse lookup we need access to profiles/urls.py,
# but profiles/urls.py in turn imports this module.
#
if success_url is None:
success_url = reverse('profiles_profile_detail',
kwargs={ 'username': request.user.username })
if form_class is None:
form_class = utils.get_profile_form()
if request.method == 'POST':
form = form_class(data=request.POST, files=request.FILES)
if form.is_valid():
profile_obj = db_create(Prayerprofile,
fname = form.cleaned_data['fname'],
nickname = form.cleaned_data['nickname'],
gender = form.cleaned_data['gender'],
bday = form.cleaned_data['bday'],
location = form.cleaned_data['location'],
avatar = form.cleaned_data['avatar'],
date_updated= form.cleaned_data['date_updated'],
date_joined = form.cleaned_data['date_joined'],
privacy = form.cleaned_data['privacy'],
latest_news = form.cleaned_data['latest_news'],
user = request.user
)
profile_obj.save()
if hasattr(form, 'save_m2m'):
form.save_m2m()
return HttpResponseRedirect(success_url)
else:
form = form_class()
if extra_context is None:
extra_context = {}
context = RequestContext(request)
for key, value in extra_context.items():
context[key] = callable(value) and value() or value
return render_to_response(template_name,
{ 'form': form },
context_instance=context)
p.singles_last_movement = 0.0
p.singles_ranking_points = 100.0
p.put()
# Creating new PlayerGame entities for extant data
from ragendja.dbutils import db_create
from pingpong.models import Player, Team, Game, PlayerGame
for p in Player.all():
# Find all teams where p is player1 (no gql OR operator)
teams = Team.gql("WHERE player1 = :player", player=p)
for t in teams:
# Delete all games in which t played
games = Game.gql("WHERE team1 = :team", team=t)
for g in games:
db_create(PlayerGame, player=p, game=g, date_played=g.date_played)
games = Game.gql("WHERE team2 = :team", team=t)
for g in games:
db_create(PlayerGame, player=p, game=g, date_played=g.date_played)
# Find all teams where p is player2 (no gql OR operator)
teams = Team.gql("WHERE player2 = :player", player=p)
for t in teams:
# Delete all games in which t played
games = Game.gql("WHERE team1 = :team", team=t)
for g in games:
db_create(PlayerGame, player=p, game=g, date_played=g.date_played)
games = Game.gql("WHERE team2 = :team", team=t)
for g in games:
db_create(PlayerGame, player=p, game=g, date_played=g.date_played)
# Populating extant PlayerGame entities with new won property
