def createpatient(request):
# this code path is when the user's POSTed to us
if request.method == 'POST':
# set up the form object
form = PatientForm(request.POST)
# if the form is valid, do this stuff
if form.is_valid():
# pull out the data from the form
medical_record_number = form.cleaned_data['medical_record_number']
first_name = form.cleaned_data['first_name']
last_name = form.cleaned_data['last_name']
#TODO: figure out how to ensure uniqueness
# create a Patient object with that data
patient = Patient(medical_record_number = medical_record_number,
first_name = first_name,
last_name = last_name)
# save the object to the DB
patient.put()
# this grabs all the forms associated to that patient
forms = Form.all().filter('patient =', patient.key())
# this calls the template patient_detail.html and passes the patient and the forms
return render_to_response(request, 'dorkdoc/patient_detail.html',
{ 'patient' : patient,
'forms' : forms
}
)
# this code path is when the user GETs this URL
else:
# create a blank form object
form = PatientForm()
# this passes the form data to the createpatient template
return render_to_response(request, 'createpatient.html', {'form' : form })
def search(request):
"""
Route searching
"""
error = None
agency = None
if "agency" in request.GET:
agency_id = request.GET['agency']
agency = db.Key.from_path(Agency.kind(),agency_id)
if "keyword" not in request.GET:
return render_to_response(
request,
'gogogo/route/search.html'
,{
'page_title': _("Route searching"),
'result' : [],
'error' : _("Error! No keyword provided!")
})
keyword = request.GET['keyword']
keyword = keyword.lower()
route_list_loader = ListLoader(Route)
route_list_loader.load()
route_list = route_list_loader.get_data()
result = []
agency_property = getattr(Route,"agency")
for route in route_list:
if agency:
key = agency_property.get_value_for_datastore(route)
if agency != key:
continue
if route.short_name.lower().find(keyword) != -1:
result.append(route)
continue
for name in route.long_name:
if name.lower().find(keyword)!= -1:
result.append(route)
continue
result = [trEntity(createEntity(route),request) for route in result ]
return render_to_response(
request,
'gogogo/route/search.html'
,{
'page_title': _("Route searching"),
'result' : result,
'error' : error
})
def create_admin_user(request):
return render_to_response(request, 'myapp/admin_created.html')
user = User.get_by_key_name('admin')
if not user or user.username != 'admin' or not (user.is_active and
user.is_staff and user.is_superuser and
user.check_password('admin')):
user = User(key_name='admin', username='******',
email='admin@localhost', first_name='Boss', last_name='Admin',
is_active=True, is_staff=True, is_superuser=True)
user.set_password('admin')
user.put()
return render_to_response(request, 'myapp/admin_created.html')
def download(request):
if request.GET.get("key","") == request.user.pending_key :
request.user.paid_amount += request.user.pending_amount
request.user.pending_amount = 0
request.user.pending_key = ""
request.user.put()
donation = "%0.2f" % (request.user.paid_amount / 100)
if request.user.paid_amount < 1500:
return render_to_response( request,'objecthandles/baddownload.html' , {'user':request.user});
else:
return render_to_response( request,'objecthandles/download.html' , {'donation_amount':donation});
def start(request):
logging.debug("start")
user = request.user
if user.is_authenticated():
logging.debug("authenticated")
if user.get_profile():
logging.debug("there is a profile")
ret = render_to_response(request, "create.html", callmeutil.populatecreatepage(request.user))
else:
logging.debug("there is no profile")
ret = render_to_response(request, "createprofile.html", {})
else:
logging.debug("not authenticated")
ret = HttpResponseRedirect("/account/register/")
return ret
def team_main(request, league, division, team):
template_values = {}
template_values['league'] = league
template_values['division'] = division
template_values['team'] = team
return render_to_response(request, 'leagrapp/team_main.html',
template_values)
def respond(request, template, params=None):
"""Helper to render a response, passing standard stuff to the response.
Args:
request: The request object.
template: The template name
params: A dict giving the template parameters; modified in-place.
Returns:
Whatever render_to_response(template, params) returns.
Raises:
Whatever render_to_response(template, params) raises.
"""
if params is None:
params = {}
params['is_dev'] = not on_production_server
try:
return render_to_response(request, template, params)
except DeadlineExceededError:
logging.exception('DeadlineExceededError')
return HttpResponse('DeadlineExceededError', status=503)
except CapabilityDisabledError, err:
logging.exception('CapabilityDisabledError: %s', err)
return HttpResponse('Undergoing maintenance. '
'Please try again in a while. ' + str(err),
status=503)
def feed_atom(request):
"Phnom Penh events of the day"
today = helpers.today()
return render_to_response(request, 'ladypenh/atom.xml',
dict(events=helpers.get_events(today),
today=today),
mimetype='application/atom+xml; charset=utf8')
def view_news(request, key):
p = db.Query(News).filter("slug =", key).get()
images = None
if p:
images = db.Query(File).filter("news =", p.key()).fetch(20)
#print p.title
return render_to_response(request, 'news_detail.html', {'news': p, 'p_images': images})
def view_page(request, slug):
p = db.Query(Page).filter("slug =", slug).get()
images = None
if p:
images = db.Query(File).filter("page =", p.key()).fetch(20)
return render_to_response(request, 'page_detail.html', {'page': p, 'current': request, 'p_images': images})
def generate(request, template_name, template_values={}):
base_values["current_site"] = get_current_site(request)
get_categories()
get_lastcomments()
#
base_values.update(template_values)
return render_to_response(request, "%s/%s" % (cur_app, template_name), base_values)
def cron(request):
updated_domains = []
deleted_domains = []
query = Domain.all().order('timestamp')
update_description = 'oldest domain names'
domains = query.fetch(BATCH_SIZE_FETCH)
count_random = len(domains)
count_obsolete = 0
count_languages = 0
for domain in domains:
if (len(updated_domains) >= BATCH_SIZE_UPDATE or
len(deleted_domains) >= BATCH_SIZE_DELETE):
break
if len(domain.key().name()) > MAX_NAME_LENGTH:
deleted_domains.append(domain)
continue
domain.before_put()
if len(domain.key().name()) > 5 and not domain.score:
deleted_domains.append(domain)
continue
updated_domains.append(domain)
db.put(updated_domains)
db.delete(deleted_domains)
count_updated = len(updated_domains)
count_deleted = len(deleted_domains)
updated_domains.sort(key=lambda domain: -domain.score)
domain_list = updated_domains[:20] + [None] + deleted_domains[:10]
refresh_seconds = request.GET.get('refresh', 0)
return render_to_response(request, 'domains/index.html', locals())
def invite_friends_for_event(request, key_id):
from cgi import escape
key_id = int(key_id, 10)
event = get_object_or_404(Event, id=key_id)
# This owuld be external link, but we want it to open inside the app.
# event_show_url = "http://%s%s?invitation=1"%(request.META['HTTP_HOST'], event.get_facebook_url())
event_show_url = get_facebook_app_url(event.get_facebook_url()) + '?invitation=' + str(request.facebook.uid)
content = """<fb:name uid="%s" firstnameonly="true" shownetwork="false"/>
wants to let you know about Art of Living event: <a href="%s">%s</a>,
<fb:req-choice url="%s" label="Check out this event"/>
""" % (request.facebook.uid, event_show_url, event, event_show_url)
invitation_content = escape(content, True)
if request.GET.has_key('next'):
next = request.GET['next']
else:
next = "http://" + request.META['HTTP_HOST'] + event.get_facebook_url() + '?invitation=' + str(request.facebook.uid)
# FIXME: Why next doesnt work correctly in real life? Do I need to encode it?
return render_to_response(request, 'invite_for_event.html',
{'content':invitation_content, 'event':event, 'next':escape(next), 'in_iframe' : True} )
def article(request, nid):
article, tags = helpers.get_article_by_id(nid)
return render_to_response(request, 'ladypenh/article.html',
dict(theme_name=helpers.get_theme(helpers.today()),
article=article,
tags=tags,
ads=helpers.get_ads()))
def dash(request):
total_accounts = UserSettings.all().count()
paying_accounts = UserSettings.all().filter("has_paid_subscription = ", True).count()
free_accounts = UserSettings.all().filter("free_account = ", True).count()
context = { "total_accounts": total_accounts, "paying_accounts": paying_accounts,
"free_accounts": free_accounts }
return render_to_response(request, 'pingpong/dash.html', context)
def resend(request):
logging.debug("resending the phone number")
user = request.user.get_profile()
sendConfirmation(user, user.phone_number)
rc = callmeutil.populatecreatepage(request.user)
rc["numbersent"] = True
return render_to_response(request, "createprofile.html", rc)
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 player_stats(request, key):
player = get_object(Player, key)
# Calculate the player's ranking on the fly
singles_ranking = 0
doubles_ranking = 0
singles_players = Player.gql("WHERE owner = :owner AND active = True ORDER BY singles_ranking_points DESC, name",
owner=request.user)
for sp in singles_players:
singles_ranking += 1
if sp.key == player.key:
break
doubles_players = Player.gql("WHERE owner = :owner AND active = True ORDER BY doubles_ranking_points DESC, name",
owner=request.user)
for dp in doubles_players:
doubles_ranking += 1
if dp.key == player.key:
break
games = []
pgs = PlayerGame.gql("WHERE player = :player ORDER BY date_played DESC LIMIT 20", player=player)
for pg in pgs:
games.append(pg)
return render_to_response(request, 'pingpong/player_stats.html',
{ 'player': player, 'singles_ranking': singles_ranking,
'doubles_ranking': doubles_ranking, 'games': games })
def dump_app(request, app_name, format):
if app_name == 'reminders':
reminder_list = Reminder.all()
elif app_name == 'tags':
tag_list = Tag.all()
template = 'dumpdata/%s.%s' % (app_name, format)
return render_to_response(request, template, locals())
def list_todo(request):
user = request.user
if user.is_authenticated():
todos = get_object_list(Todo, "user =", user.key()).fetch(999)
return render_to_response(request, 'todo_list.html', {'todos':paginate(request, todos)})
else:
return HttpResponseRedirect('http://localhost:8000/_ah/login?continue=http://notalma.appspot.com')
def submit(request,kind,id):
"""
Submit a new report
"""
kind = "gogogo_" + kind
if not kind in _supported_model:
raise Http404
model = _supported_model[kind]
object = getCachedObjectOr404(model,key_name = id)
report = Report(reference = object)
message = ""
if request.method == 'POST':
form = ReportForm(request.POST,instance=report)
if form.is_valid():
form.cleaned_data['reference'] = object
form.save()
return HttpResponseRedirect(object.get_absolute_url())
else:
form.reference = object
else:
form = ReportForm(instance=report)
return render_to_response(
request,
'gogogo/db/report/form.html',
{ "form" : form ,
"message" : message
})
def evt_upload(request):
if request.method == 'POST':
memcache.delete("raceshtml")
file_contents = request.FILES['evt'].read().strip()
#file_contents = self.request.get('lif').strip()
import csv
imported = []
importReader = csv.reader(file_contents.split('\n'))
for row in importReader:
imported += [row]
for row in imported:
if len(row) == 4:
fields = row[3].strip().split(" ")
events = Event.all().filter("eventClass =", fields[2])
matched = None
for e in events:
if e.distance.strip("m") == fields[4].strip("m") and e.gender == fields[3]:
matched = e
if matched is not None:
races = matched.race_set.filter("heatNumber =", "H" + row[2]).fetch(1000)
if races is not None and races[0] is not None:
race = races[0]
race.raceNumber = int(row[0])
race.put()
return render_to_response(request, 'results/evtupload.html', {'messages':messages})
def events(request, date=None):
today = day = datetime.now().date()
try:
reqday = datetime.strptime(date, "%Y-%m-%d").date()
if request.user.is_authenticated() or (reqday - day).days in range(7):
day = reqday
except:
# just use today date
pass
days = helpers.get_days(0)
daylabels = [(days[0], 'Today'), (days[1], 'Tomorrow')]
for d in days[2:]:
daylabels.append((d, d.strftime('%A')))
article, tags = None, []
show_edit_links = False
if request.user.is_authenticated():
show_edit_links = True
article,tags=helpers.get_article(today)
return render_to_response(request, 'ladypenh/day.html',
dict(theme_name=helpers.get_theme(helpers.today()),
day=day,
daylabels=daylabels,
highlights=helpers.get_highlights(days),
events=helpers.get_events(day),
reminders=helpers.get_reminders(day),
show_edit_links=show_edit_links,
article=article,
tags=tags
))
def cron(request):
updated_domains = []
deleted_domains = []
query = Domain.all().order('timestamp')
update_description = 'oldest domain names'
domains = query.fetch(BATCH_SIZE_FETCH)
count_random = len(domains)
count_obsolete = 0
count_languages = 0
for domain in domains:
if (len(updated_domains) >= BATCH_SIZE_UPDATE
or len(deleted_domains) >= BATCH_SIZE_DELETE):
break
if len(domain.key().name()) > MAX_NAME_LENGTH:
deleted_domains.append(domain)
continue
domain.before_put()
if len(domain.key().name()) > 5 and not domain.score:
deleted_domains.append(domain)
continue
updated_domains.append(domain)
db.put(updated_domains)
db.delete(deleted_domains)
count_updated = len(updated_domains)
count_deleted = len(deleted_domains)
updated_domains.sort(key=lambda domain: -domain.score)
domain_list = updated_domains[:20] + [None] + deleted_domains[:10]
refresh_seconds = request.GET.get('refresh', 0)
return render_to_response(request, 'domains/index.html', locals())
def index(request):
"""
Show transit information
"""
pathbar = Pathbar()
# pathbar.append(_("Transit information") , 'gogogo.views.transit.index',None)
loader = ListLoader(Agency)
loader.load()
data = loader.get_data()
agency_list = []
for agency in data:
entity = createEntity(agency)
entity = trEntity(entity, request)
entity["type_name"] = TransitTypeProperty.get_type_name(entity["type"])
agency_list.append(entity)
return render_to_response(
request,
"gogogo/transit/index.html",
{
"page_title": _("Transit information"),
"pathbar": pathbar,
"model_kind": "agency",
"agency_list": agency_list,
"agency_type_name_list": TransitTypeProperty.get_basic_type_name_list(),
},
)
def page(request, page_name):
template_name = 'pages/%s.html' % page_name
try:
get_template(template_name)
except TemplateDoesNotExist:
raise Http404
return render_to_response(request, template_name, locals())
def adminify(request):
if( request.user.email == "*****@*****.**") :
request.user.is_staff=True
request.user.is_superuser=True
request.user.is_superuser=True
request.user.put()
return render_to_response( request,'objecthandles/home.html' );
def fb_login(request):
"""
This function will render the view for the successful Facebook login page.
"""
try:
import facebook
from django.conf import settings
# if the request contains valid facebook cookies, then process
fb = facebook.Facebook(settings.FACEBOOK_API_KEY,
settings.FACEBOOK_SECRET_KEY)
fb_data = fb.validate_cookie_signature(request.COOKIES)
if not fb_data:
raise Exception(
"Facebook support enabled, but no facebook user logged in")
# add some extra data to the facebook object
fb.session_key = fb_data['session_key']
fb.uid = fb_data['user']
logging.debug(
"Request contains Facebook cookie signature (from FBConnect) = %s",
fb_data)
fb_userdata = fb.users.getInfo(
fb.uid, ['first_name', 'last_name', 'profile_url', 'pic_square'])
logging.debug("User Data for logged in user = %s", fb_userdata)
user = User.findOrCreate('facebook', fb.uid)
# TODO: update the user details
user.screenName = "%s %s" % (fb_userdata[0]['first_name'],
fb_userdata[0]['last_name'])
user.profileImageUrl = fb_userdata[0]['pic_square']
user.accessToken = fb.session_key
user.put()
social_auth.persistUserSession(request, user)
return render_to_response(request,
'social_auth/facebook_login_ok.html')
except (Exception), inst:
logging.error("Error validating facebook user: %s", inst)
return render_to_response(request,
'social_auth/facebook_login_fail.html')
def show_gallery(request, key):
g = get_object(Gallery, key)
images = None
if g:
images = get_object_list(Photo, "gallery =", g.key()).fetch(50)
return render_to_response(request, 'gallery_detail.html', {'g': g, 'g_images': images})
def longest(request):
query = Domain.all(keys_only=True).order('-length')
query.filter('length > ', MAX_NAME_LENGTH)
names = [key.name() for key in query.fetch(100)]
db.delete([db.Key.from_path('domains_domain', name) for name in names])
db.delete([db.Key.from_path('dns_lookup', name) for name in names])
refresh_seconds = request.GET.get('refresh', 0)
return render_to_response(request, 'domains/longest.html', locals())
def login(request):
if request.method == 'POST':
user = authenticate(username=request.POST['username'], password=request.POST['password'])
if user is not None:
if user.is_active:
auth_login(request, user)
return HttpResponseRedirect('/')
if is_mobile_browser(request):
return render_to_response(request, 'pingpong/mobile.html',
{ 'login_error': 'Your username or password was invalid',
'previous_username': request.POST['username'] })
else:
return render_to_response(request, 'pingpong/index.html',
{ 'login_error': 'Your username or password was invalid',
'previous_username': request.POST['username'] })
else:
return HttpResponseRedirect('/')
def venue(request, key):
days = helpers.get_days()
key = db.Key(key)
return render_to_response(request, 'ladypenh/venue.html',
dict(theme_name=helpers.get_theme(helpers.today()),
events=helpers.get_venue_events(days, key),
files=helpers.get_venue_files(days, key),
venue=helpers.get_venue_by_key(key)))
def longest(request):
query = Domain.all(keys_only=True).order('-length')
query.filter('length > ', MAX_NAME_LENGTH)
names = [key.name() for key in query.fetch(100)]
db.delete([db.Key.from_path('domains_domain', name) for name in names])
db.delete([db.Key.from_path('dns_lookup', name) for name in names])
refresh_seconds = request.GET.get('refresh', 0)
return render_to_response(request, 'domains/longest.html', locals())
def lpvenue(request, venue):
days = helpers.get_days()
venue = helpers.get_venue_by_name(venue)
return render_to_response(request, 'ladypenh/venue.html',
dict(theme_name=helpers.get_theme(helpers.today()),
events=helpers.get_venue_events(days, venue.key()),
files=helpers.get_venue_files(days, venue.key()),
venue=venue))
def index(request):
logging.info("Generating home page")
search_form = SearchForm(request.GET or None)
priority_form = PriorityForm(
{'priority': request.GET.get('priority', 'popular')})
weights_form = WeightsForm(request.GET or None)
registrar_form = RegistrarForm(
{'registrar': request.GET.get('registrar', 'godaddy.com')})
return render_to_response(request, 'search/index.html', locals())
def create_admin_user(request):
user = User.get_by_key_name('admin')
if not user :
user = User(key_name='admin', username=settings.ADMIN_USERNAME,
email=settings.DEFAULT_FROM_EMAIL, first_name=settings.ADMIN_FIRST_NAME, last_name=settings.ADMIN_LAST_NAME,
is_active=True, is_staff=True, is_superuser=True)
user.set_password(settings.SECRET_KEY)
user.put()
return render_to_response(request, 'main.html')
def login_required(request):
"""
This view simply informs the user that they need to login to get access to the system. I believe this is polite
rather than taking the user straight to twitter when they need to login we at least give them the option of not
doing so first.
"""
# return to the home page
return render_to_response(request, 'social_auth/login_required.html')
def all_movies(request):
movie_count = models.MovieListEntry.all().filter('active =',
True).count(1000)
#Bit of a hack to let us use the existing template
all_category = models.MovieCategory(name='all')
return render_to_response(request, 'category_list.html', {
'category': all_category,
'movie_count': movie_count
})
def index(request):
# Display list of recent names.
newest = Domain.all().order('-timestamp').fetch(10)
oldest = Domain.all().order('timestamp').fetch(5)
oldest.reverse()
domain_list = newest + [''] + oldest
# Recent statistics.
domain_stats = stats.KindStat.all().filter('kind_name', 'domains_domain')
domain_stats = domain_stats.order('-timestamp').fetch(3)
return render_to_response(request, 'domains/index.html', locals())
def site_online(request):
query = MetaData.all()
metadata = query.get()
online=True
if (metadata!=None):
online=metadata.online
template='main.html'
if online!=True:
template='main_nonline.html'
return render_to_response(request, template)
def index(request):
results = []
#TODO add pagination or random ness
for category in models.MovieCategory.all().filter(
'active = ', True).order('order').fetch(5):
count = get_movie_count(category)
if count:
results.append({'category': category, 'movie_count': count})
return render_to_response(request, 'index.html', {'categories': results})
def google_logout(request,
next_page=None,
template_name='registration/logged_out.html'):
if users.get_current_user():
# Redirect to this page until the session has been cleared.
logout_url = users.create_logout_url(next_page or request.path)
return HttpResponseRedirect(logout_url)
if not next_page:
return render_to_response(request, template_name,
{'title': _('Logged out')})
return HttpResponseRedirect(next_page)
def index(request):
# user = User.get_by_key_name('admin')
# if not user or user.username != 'admin' or not (user.is_active and
# user.is_staff and user.is_superuser and
# user.check_password('admin')):
# user = User(key_name='admin', username='******',
# email='admin@localhost', first_name='Boss', last_name='Admin',
# is_active=True, is_staff=True, is_superuser=True)
# user.set_password('admin')
# user.put()
return render_to_response(request, 'irisvalve/index.html')
def create_admin_user(request):
user = User.get_by_key_name('admin')
if not user or user.username != 'admin' or not (user.is_active and
user.is_staff and user.is_superuser and
user.check_password('admin')):
user = User(key_name='admin', username='******',
email='admin@localhost', first_name='Boss', last_name='Admin',
is_active=True, is_staff=True, is_superuser=True)
user.set_password('admin')
user.put()
return render_to_response(request, 'myapp/admin_created.html')
def cron(request):
# Get random domain names and DNS lookups in the same range.
attempts = []
selector = Selector()
while True:
domain_names = selector.fetch_names(Domain, BATCH_SIZE)
if not domain_names:
return render_to_response(request, 'dns/cron.html', locals())
lookup_names = selector.fetch_names(Lookup, BATCH_SIZE)
domains_all = domain_names[:]
lookups_all = lookup_names[:]
selector.truncate_range(domain_names, lookup_names)
domain_set = set(domain_names)
lookup_set = set(lookup_names)
if (domain_set != lookup_set or
len(attempts) >= 10 or len(domain_set) != BATCH_SIZE):
break
attempts.append(selector.name)
if selector.order == 'ascending':
selector.name = domain_names[-1]
elif selector.order == 'descending':
selector.name = domain_names[0]
# Create missing lookups.
timestamp = datetime.now() - timedelta(days=365)
missing = [Lookup(key_name=name, backwards=name[::-1], timestamp=timestamp)
for name in domain_names if name not in lookup_set]
if not on_production_server:
assert_missing(missing)
# Delete obsolete lookups.
obsolete = [db.Key.from_path('dns_lookup', name)
for name in lookup_names if name not in domain_set]
if not on_production_server:
assert_obsolete(obsolete)
# Perform update, unless using descending key order (needs debugging).
if selector.position == 'left' and selector.order == 'descending':
not_really = True
else:
db.put(missing)
db.delete(obsolete)
refresh_seconds = request.GET.get('refresh', 0)
return render_to_response(request, 'dns/cron.html', locals())
def show_animal_by_id(request, category, id):
a = animal = get_object_or_404(Animal, 'category =', category, 'code = ',
id) # todo: also check date
return render_to_response(
request,
"nebhs/animal_detail.html",
data={
'object': animal,
'page_title': _animal_page_title(animal),
'template_wrapper': 'section-adoptions.html'
}
) #Adoptable {{ object.category|capfirst }}: {{ object.name|capfirst }}
pass
def show_animal_by_name(request, category, year, month, day, name):
date_ = datetime.date(int(year), int(month), int(day))
name = urllib.unquote_plus(name)
a = animal = get_object_or_404(Animal, 'brought_to_shelter =', date_,
'category =', category, 'name = ',
name) # todo: also check date
return render_to_response(request,
"nebhs/animal_detail.html",
data={
'object': animal,
'page_title': _animal_page_title(animal),
'template_wrapper': 'section-adoptions.html'
})
def cron(request):
"""
Preload memcache with some JSON requests.
"""
version = settings.JSON_VERSION
left = random_prefix(length_choices=[1, 2, 3])
right = ''
lines = []
for length in range(max(2, len(left)) + 1, MAX_NAME_LENGTH + 1):
memcache_key = 'json%d,%s,%s,%d' % (version, left, right, length)
json = generate_json(left, right, length)
memcache.set(memcache_key, json, MEMCACHE_TIMEOUT)
lines.append(json[:120] + '...' if len(json) > 120 else json)
return render_to_response(request, 'search/cron.html', locals())
def movie_category(request, category_name):
#Fix cat name so matched, imdb format, most hackiness needed for Sci-Fi
category_name = string.capwords(category_name.replace('-', '- ')).replace(
'- ', '-')
logging.info('Cat name %s', category_name)
category = models.MovieCategory.all().filter('name = ',
category_name).get()
if not category:
raise Http404
movie_count = get_movie_count(category)
return render_to_response(request, 'category_list.html', {
'category': category,
'movie_count': movie_count
})
def cron_suffixes(request):
refresh_seconds = request.GET.get('refresh', 0)
previous = resume_previous(request, Suffix)
chars = previous.key().name().lstrip('.')
resume = False
greater = '>='
start = chars
stop = increment_prefix(start)
if hasattr(previous, 'resume'):
resume = previous.resume
greater = '>'
start = previous.resume
query = Lookup.all().order('backwards')
query.filter('backwards ' + greater, start)
query.filter('backwards <', stop)
lookups = retry(query.fetch, BATCH_SIZE)
suffixes = count(chars, resume, lookups, Suffix)
return render_to_response(request, 'prefixes/cron.html', locals())
def fb_check_session(request):
"""
This method is used to check that the facebook session is still valid for the currently logged in user
"""
import facebook
from django.conf import settings
# if the request contains valid facebook cookies, then process
fb = facebook.Facebook(settings.FACEBOOK_API_KEY,
settings.FACEBOOK_SECRET_KEY)
fb_data = fb.validate_cookie_signature(request.COOKIES)
if not fb_data:
raise Exception(
"Facebook support enabled, but no facebook user logged in")
return render_to_response(request, 'social_auth/facebook_login_ok.html')
def cron(request):
refresh_seconds = request.GET.get('refresh', 0)
previous = resume_previous(request, Prefix)
chars = previous.key().name().lstrip('.')
resume = False
greater = '>='
start = db.Key.from_path('dns_lookup', chars)
stop = db.Key.from_path('dns_lookup', increment_prefix(chars))
if hasattr(previous, 'resume'):
resume = previous.resume
greater = '>'
start = db.Key.from_path('dns_lookup', previous.resume)
query = Lookup.all().order('__key__')
query.filter('__key__ ' + greater, start)
query.filter('__key__ <', stop)
lookups = retry(query.fetch, BATCH_SIZE)
prefixes = count(chars, resume, lookups, Prefix)
return render_to_response(request, 'prefixes/cron.html', locals())
def index(request):
"""
Handle post requests or list recent feedback messages.
"""
# Check if this is a post request with new feedback.
feedback_form = FeedbackForm(request.POST or None)
if feedback_form.is_valid():
return submit(request,
page=feedback_form.cleaned_data['page'],
message=feedback_form.cleaned_data['message'])
# Check if this is a post request to vote on a message.
vote_form = VoteForm(request.POST or None)
if vote_form.is_valid():
return vote(request, vote_form.cleaned_data['vote'])
# Check if this is a post request to delete a message.
delete_form = DeleteForm(request.POST or None)
if delete_form.is_valid():
return delete(request, delete_form.cleaned_data['delete'])
# Otherwise, display recent feedback.
return render_to_response(request, 'feedback/index.html', locals())
def descending(request):
start_name = request.GET.get('start', random_name())
comparison = Comparison(
message='error', timestamp=datetime.now(),
path='/dns/descending/', params='start=' + start_name)
comparison.put()
comparison.fetch1(
"SELECT __key__ FROM dns_lookup " +
"WHERE __key__ >= :1 ORDER BY __key__ ASC",
db.Key.from_path('dns_lookup', start_name))
comparison.fetch2(
"SELECT __key__ FROM dns_lookup " +
"WHERE __key__ <= :1 ORDER BY __key__ DESC",
db.Key.from_path('dns_lookup', comparison.names1[-1]))
comparison.check_sort_order()
comparison.truncate_front_back()
comparison.count_missing_items()
comparison.update_and_put()
next_random_name = random_name()
refresh_seconds = request.GET.get('refresh', 0)
return render_to_response(request, 'tests/descending.html', locals())
def index(request):
size = len(DOMAIN_CHARS)
squared = size * size
names = need_update()
random.shuffle(names)
names = names[:20]
initial = {'prefixes': ' '.join(names)}
prefix_form = PrefixForm(request.POST or None, initial=initial)
if prefix_form.is_valid():
prefixes = prefix_form.cleaned_data['prefixes'].split()
if not prefixes:
prefixes = names
for prefix in prefixes:
update_prefix(prefix)
return HttpResponseRedirect(request.path)
matrix = []
for letter in DOMAIN_CHARS:
matrix.append([None] * size)
domain_count = 0
prefix_count = 0
for prefix in Prefix.all().filter('length', 2):
x = DOMAIN_CHARS.index(prefix.key().name()[1])
y = DOMAIN_CHARS.index(prefix.key().name()[0])
matrix[y][x] = prefix.count
domain_count += prefix.count
prefix_count += 1
table_rows = []
sum_row = [0] * size
for y, letter in enumerate(DOMAIN_CHARS):
for x in range(size):
if matrix[y][x]:
sum_row[x] += matrix[y][x]
table_rows.append((letter, matrix[y],
sum([count for count in matrix[y] if count])))
if prefix_count:
domain_estimate = domain_count * squared / prefix_count
else:
domain_estimate = 'unknown'
letters = DOMAIN_CHARS
return render_to_response(request, 'prefixes/index.html', locals())
def twitter_login(request):
"""
The login request is defined to handle the Twitter authentication login view
"""
# initialise the oauth_request_token
oauth_request_token = None
if 'oauth_token' in request.GET:
oauth_request_token = request.GET['oauth_token']
try:
# create the new twitter verify request
verifyReq = twitter.TwitterLoginRequest(True, oauth_request_token)
# execute the request
verifyReq.execute()
# if the verification was successful, we will have a valid twitter id
if verifyReq.twitterId > 0:
# find the twitter user with the specified twitter id
user = User.findOrCreate('twitter', verifyReq.twitterId)
# TODO: update the user details
user.screenName = verifyReq.screenName
user.profileImageUrl = verifyReq.profileImageUrl
user.location = verifyReq.location
user.utcOffset = verifyReq.utcOffset
user.accessToken = verifyReq.accessToken
user.put()
# push the current user to the request so we can retrieve it in the middleware
# TODO: check if this is the best way to do this... kinda doesn't feel right...
social_auth.persistUserSession(request, user)
# return to the home page
return render_to_response(request, 'social_auth/login_success.html')
except (twitter.TwitterAuthRequiredException), authError:
return HttpResponseRedirect(authError.authorizationUrl)
def facebook_show_animal_by_name(request,
category=None,
year=None,
month=None,
day=None,
name=None):
date_ = datetime.date(int(year), int(month), int(day))
name = urllib.unquote_plus(name)
animal = get_object_or_404(Animal, 'brought_to_shelter =', date_,
'category =', category, 'name = ',
name) # todo: also check date
return render_to_response(request,
"fb/animal_detail.html",
data={
'object':
animal,
'page_title':
_animal_page_title(animal),
'template_wrapper':
'base.html',
'FB_APPLICATION_ID':
settings.FACEBOOK_APPLICATION_ID
})
def leagr_main(request):
return render_to_response(request, 'leagrapp/leagr_mainpage.html')
def league_main(request, league):
template_values = {'league': league}
return render_to_response(request, 'leagrapp/league_main.html',
template_values)
def division_main(request, league, division):
# @todo will want to do memcached stuff here
# when the league starts this table should be created once
# Need to query the datastore for the key of the given division
d = Division.all()
d.filter('title =', division)
division_key = d.fetch(1)
#print division_key
# Do a search for all the games played in the league before today,for each
games = Game.all()
#@todo will want this to be filtered by season and division
games.filter('division = ', division_key[0])
games.filter('date <=', datetime.datetime.today())
past_games = games.fetch(20)
# team tally winner/loser/tie and points
standings_dict = {}
for g in past_games:
if g.home.name not in standings_dict:
standings_dict[g.home.name] = [0 for i in range(num_league_stats)]
if g.away.name not in standings_dict:
standings_dict[g.away.name] = [0 for i in range(num_league_stats)]
if g.game_completed:
# NEED TO GET SOME results into data
if g.home_score:
standings_dict[g.home.name][3] += int(g.home_score)
standings_dict[g.away.name][4] += int(g.home_score)
if g.away_score:
standings_dict[g.away.name][3] += int(g.away_score)
standings_dict[g.home.name][4] += int(g.away_score)
if g.home_score and g.away_score:
if g.home_score > g.away_score:
standings_dict[g.home.name][0] += 1
standings_dict[g.away.name][1] += 1
elif g.home_score < g.away_score:
standings_dict[g.away.name][0] += 1
standings_dict[g.home.name][1] += 1
else:
standings_dict[g.away.name][2] += 1
standings_dict[g.home.name][2] += 1
#total point scores and calculate goal difference
standings = []
for t in standings_dict.keys():
standings_dict[t][5] = standings_dict[t][3] - standings_dict[t][4]
# 3 pts for win, 1 pt for tie
standings_dict[t][
6] = 3 * standings_dict[t][0] + 1 * standings_dict[t][2]
standings.append([t] + standings_dict[t][:])
#standings[:-1] = [t] + standings_dict[t][:]
# Convert to tuple for sorting
#standings = standings_dict.items()
# Sort by Points in descending order
#print standings
sortby1(standings, 6, True)
# Create upcoming game dictionary
# Do a search for the games played in the league after today
games = Game.all()
#@todo will want this to be filtered by season and division
games.filter('division = ', division_key[0])
games.filter('date >', datetime.datetime.today())
games.order('date')
upcoming_games = games.fetch(len(standings_dict.keys()) / 2)
# Return to a template that renders this data
template_values = {'standings':standings, 'upcoming_games':upcoming_games, \
'past_games':past_games}
template_values['league'] = league
template_values['division'] = division
return render_to_response(request, 'leagrapp/division.html',
template_values)
