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='admin',
            email='[email protected]', 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 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 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 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 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 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 == "[email protected]") :
    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 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 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 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 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 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 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 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 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 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')