"""Ein Objekt wurde nicht in der Datenbank gefunden.

Attributes:

msg -- explanation of the error

"""

def __init__(self, msg):

"""Gibt alle Informationen, die auf jeder Seite benötigt werden.

'logintext': 'Abmelden' oder 'Anmelden',

'loginurl': URL zum ein- oder ausloggen,

'isadmin': ...,

'isauthorized': ...

"""

if isauthorized():

res = {'logintext': 'Abmelden',

'loginurl': logouturl,

'isadmin': users.is_current_user_admin(),

'isauthorized': True,

}

else:

res = {'logintext': 'Anmelden',

'loginurl': loginurl,

'isadmin': False,

}

user = users.get_current_user()

if user:

res['username'] = user.nickname()

"""Liefert aus der Datenbank ein Rezept und die Anzahl der vorhandenen

Versionen

Parameter:

id des Rezepts - obligat,

version - Default ist 1

"""

try:

version = int(version)

except ValueError:

raise NotFoundError(u"Rezept %s mit Version %s nicht gefunden." % (rezept_id, version))

rezepte = models.Rezept.all().filter("id =",rezept_id).filter('version =', version)

rezept = rezepte.get()

if rezept is None:

raise NotFoundError(u"Rezept %s nicht gefunden." % rezept_id)

return (rezept,

def post(self, *param):

if len(param)>0:

zutat = db.get(db.Key(param[0]))

else:

zutat = models.Zutat()

zutat.name = self.request.get('name')

zutat.einheit = self.request.get('einheit')

preis = self.request.get('preis')

if preis:

preis = preis.replace(',', '.')

zutat.preis_pro_einheit = int(round(100*float(preis)))

# TODO: Fehlerbehandlung für Fehleingaben

menge = self.request.get('menge')

if menge:

zutat.menge_pro_einheit = int(menge)

zutat.masseinheit = self.request.get('masseinheit')

zutat.kategorie = self.request.get('kategorie')

zutat.put()

if len(param)>0:

zutat.updateRezeptpreise()

self.redirect('/zutaten')

def get(self, *param):

template_values = standard_template_values()

template_values.update({

'masseinheiten': models.MASSEINHEITEN,

'kategorien': models.ZUTATENKATEGORIEN,

})

if len(param)>0 and self.isauthorized():

zutat = db.get(db.Key(param[0]))

template_values['zutat'] = zutat

template_values['rezepte'] = [r for r in zutat.verwendung]

htmlfile = 'zutat-bearbeiten.html'

else:

htmlfile = 'zutaten.html'

zutaten = db.GqlQuery("SELECT * FROM Zutat ORDER BY kategorie, name")

template_values['zutaten'] = zutaten

def get(self, zutatkey):

if self.authorize():

zutat = db.get(db.Key(zutatkey))

if zutat:

zutat.delete()

def get(self):

if self.authorize():

zutaten = defaultdict(list)

for z in models.Zutat.all().order("name").fetch(1000):

zutaten[z.kategorie or u'keine Kategorie'].append(z)

template_values = standard_template_values()

template_values.update({

'zutaten': zutaten,

'gaenge': GAENGE,

'kategorien': REZEPTKATEGORIEN,

})

self.write_out_template('rezept-eingeben.html', template_values)

def post(self):

rezept = models.makeRezeptFromRequest(self.request)

rezept.put()

zutaten = self.request.get('zutatensammlung')

if len(zutaten)>1:

#logging.debug('zutaten = ' + zutaten)

zutaten = zutaten[:-1].split(u'|')

#logging.debug('zutaten[0] = ' + zutaten[0])

nr = 1

for z in zutaten:

#logging.debug('z = %s, nr = %d' % (z, nr))

z = z.split(u'§')

name = z[0]

key = z[1]

menge = z[2]

menge_qual = z[3]

zutat = db.Key(key)

if menge_qual:

menge = None

else:

menge = float(menge)

menge_qual = None

rz = models.RezeptZutat()

rz.init(rezept.key(), zutat, menge, menge_qual, nr)

rz.put()

nr += 1

def get(self, mitPreis = False):

class Kategorie():

pass

kategorien = {}

namen = list(REZEPTKATEGORIEN) + [

u'keine Kategorie', u'Vorspeise', u'Nachtisch']

for kategorie in namen:

k = Kategorie()

k.kategorie = kategorie

k.rezepte = []

kategorien[kategorie] = k

rezepte = models.Rezept.all().order('titel')

rezepte = rezepte.fetch(1000)

for r in rezepte:

if not r.typ or u'Hauptgang' in r.typ:

kategorien[r.kategorie or u'keine Kategorie'].rezepte.append(r)

for g in (u'Vorspeise', u'Nachtisch'):

if g in r.typ:

kategorien[g].rezepte.append(r)

for k in kategorien.values():

k.anzahl = len(k.rezepte)

hauptspeisen = [kategorien[n] for n in namen[:-2] if kategorien[n].anzahl]

vornachspeisen = [kategorien[n] for n in namen[-2:] if kategorien[n].anzahl]

template_values = standard_template_values()

template_values.update({

'hauptspeisen': hauptspeisen,

'vornachspeisen': vornachspeisen,

'allerezepte': rezepte,

})

if mitPreis:

self.write_out_template('rezepte-anzeigen-mit-preis.html', template_values)

else:

def get(self, *param):

try:

rezept, anzahlversionen = getRezept(*param)

except NotFoundError, e:

self.response.out.write(e.msg)

self.response.set_status(404)

return

template_values = standard_template_values()

template_values.update({

'rezept': rezept,

'kinder': rezept.personen[0],

'erwachsene': rezept.personen[1],

'zutaten': [(zutat.toStr(), zutat.preisToStr()) \

for zutat in rezept.zutaten],

'preis': rezept.preis(),

'gang': ', '.join(rezept.typ),

'anzahlversionen': anzahlversionen,

})

def get(self, *param):

if self.authorize():

try:

rezept, anzahlversionen = getRezept(*param)

except NotFoundError, e:

self.response.out.write(e.msg)

self.response.set_status(404)

return

zutaten = db.GqlQuery("SELECT * FROM Zutat ORDER BY kategorie, name")

zutatennachkategorien = dict([(k or u'keine Kategorie',

[z for z in zutaten if z.kategorie == k])

for k in set([z.kategorie for z in zutaten])])

template_values = standard_template_values()

template_values.update({

'rezept': rezept,

'kinder': rezept.personen[0],

'erwachsene': rezept.personen[1],

'zutaten': zutatennachkategorien,

'zutatkategorien': models.ZUTATENKATEGORIEN,

'preis': rezept.preis(),

'gaenge': GAENGE,

'kategorien': REZEPTKATEGORIEN,

'anzahlversionen': anzahlversionen,

})

self.write_out_template('rezept-bearbeiten.html', template_values)

def post(self, *param):

#id = param[0]

rezept = db.get(db.Key(self.request.get('rezeptkey')))

rezept.titel = self.request.get('titel')

rezept.calculateId(rezept.titel)

rezept.kommentar = self.request.get('kommentar')

rezept.personen = [long(self.request.get('kinder')),

long(self.request.get('erwachsene'))]

rezept.zubereitung = self.request.get('zubereitung')

rezept.anmerkungen = self.request.get('anmerkungen')

rezept.typ = self.request.get_all('gang')

rezept.kategorie = self.request.get('kategorie')

rezept.put()

self.redirect('/rezepte/%s/%s' % (param[0],

def get(self, key):

if self.authorize():

rezept = db.get(db.Key(key))

zutaten = rezept.zutaten.fetch(100)

db.delete(zutaten)

rezept.delete()

def get(self):

if self.authorize():

rezepte = models.Rezept.all().order("kategorie"

).order("titel"

).fetch(1000)

rezepte_d = dict([(r.key(), r) for r in rezepte])

for r in rezepte:

r.zutatenliste = []

for z in models.RezeptZutat.all().run(batch_size=1000):

rezepte_d[models.RezeptZutat.rezept.get_value_for_datastore(z)

].zutatenliste.append(z.toStr())

rez = [{"gang": g,

"rezepte": [r for r in rezepte if g in r.typ]}

for g in GAENGE]

def get(self, jahr=None, monat=None):

# jetziger Monat als default

try:

monat, jahr = int(monat), int(jahr)

if jahr<2000:

jahr += 2000

except (TypeError, ValueError):

today = date.today()

monat, jahr = today.month, today.year

# wichtige Daten errechnen

erster = date(jahr, monat, 1)

naechstererster = (monat<12) and date(jahr, monat+1, 1) or date(jahr+1, 1, 1)

vorigererster = (monat>1) and date(jahr, monat-1, 1) or date(jahr-1, 12, 1)

anzahltage = (naechstererster - erster).days

class Tag():

""" Definition eines Tages:

Datum, ob es ein Feiertag ist, und ein String,

der die Kategorie festhaelt

"""

def __init__(self, jahr, monat, tag):

self.tag = date(jahr, monat, tag)

self.feiertag = self.tag.weekday() > 4 # Sa + So

self.klasse = 'Feiertag' if self.feiertag else 'Menue'

self.menue = None

tage = [Tag(jahr, monat, tag) for tag in range(1, anzahltage+1)]

tagesplaene = models.Tagesplan.all().filter('datum >=', erster

).filter('datum <', naechstererster

).order('datum')

# Verweise auf gelöschte Rezepte entfernen

for plan in tagesplaene:

for gang in ('vorspeise', 'hauptgang', 'nachtisch'):

try:

getattr(plan, gang)

except:

setattr(plan, gang, None)

plan.put()

# Menueplaene in die Tage eintragen

for plan in tagesplaene:

tag = tage[(plan.datum - erster).days]

tag.klasse = plan.class_name()

tag.menue = plan

# Rezepte zur Auswahl

hauptgangrezepte = models.Rezept.all().filter('typ =', 'Hauptgang')

hauptgangrezepte.order('titel')

template_values = standard_template_values()

template_values.update({

'monat': monat, # int

'jahr': jahr, # int

'tage': tage, # array mit tag (date), feiertag (bool)

# klasse ("Feiertag", "Menue")

# menue (Feiertag, Menue)

'gaenge': [

(u'vorspeise', models.Rezept.all().filter('typ =', 'Vorspeise').order('titel')),

(u'hauptgang', hauptgangrezepte),

(u'nachtisch', models.Rezept.all().filter('typ =', 'Nachtisch').order('titel')),

],

})

# Links zum nächsten und vorigen Monat

# in späteren Djangoversionen übernimmt das die Templatesprache

MONATE = (u"Januar", u"Februar", u"März", u"April", u"Mai", u"Juni",

u"Juli", u"August", u"September", u"Oktober", u"November",

u"Dezember")

for mname, m in (('vormonat', vorigererster),

('naechstermonat', naechstererster)):

logging.error('mname: ' + mname)

logging.error('m: ' + str(m))

template_values[mname] = {'name': ('%s %d' % (MONATE[m.month-1],

m.year)),

'link': '/monatsplan/%d/%d' % (m.year, m.month)}

logging.error(repr(template_values[mname]))

def get(self, jahr, monat, tag):

datum = date(int(jahr), int(monat), int(tag))

menue = models.Menue.all().filter('datum =', datum).get()

template_values = standard_template_values()

template_values['datum'] = datum.strftime('%d. %m. %Y')

if not menue:

template_values['fehlermeldung'] = u'Menü nicht gefunden'

else:

template_values['koch'] = menue.koch

rezepte = []

for gang in (u'vorspeise', u'hauptgang', u'nachtisch'):

rezept = getattr(menue, gang, None)

if rezept:

rezepte.append({

'gang': gang.capitalize(),

'rezept': rezept,

'kinder': rezept.personen[0],

'erwachsene': rezept.personen[1],

})

template_values['rezepte'] = rezepte

tage = models.Menue.all()

tage.filter('datum >=', beginn).filter('datum <', beginn + timedelta(dauer))

rezepte = [] # Für "Folgende Rezepte wurden geplant"

messbar = {} # Die Zutaten mit quantitativer Mengenangabe

einheiten = {}

qualitativ = {} # Die Zutaten mit qualitativer Mengenangabe

rezeptzutaten = {}

for t in tage:

for r in (t.vorspeise, t.hauptgang, t.nachtisch):

if r:

rezepte.append(r)

for rz in r.zutaten:

rzzutat = rz.zutat

zutatkey = str(rzzutat.key())

rezeptzutaten[zutatkey] = rzzutat

zt = rzzutat.name

if rz.menge:

if zutatkey in messbar.keys():

messbar[zutatkey] += rz.menge

else:

messbar[zutatkey] = rz.menge

elif rz.menge_qualitativ:

if not zutatkey in qualitativ.keys():

qualitativ[zutatkey] = []

qualitativ[zutatkey].append(rz.menge_qualitativ)

messbarkat = dict([(kat, []) for kat in models.ZUTATENKATEGORIEN])

for zk, menge in messbar.items():

zutat = rezeptzutaten[zk]

messbarkat[zutat.kategorie].append({'name': zutat.name,

'menge': tools.prettyFloat(menge),

'einheit': zutat.masseinheit,

'key': str(zk)})

for z in messbarkat.values():

z.sort(lambda x,y: cmp(x["name"].lower(), y["name"].lower()))

qualitativkat = dict([(kat, []) for kat in models.ZUTATENKATEGORIEN])

for zk, menge in qualitativ.items():

zutat = rezeptzutaten[zk]

qualitativkat[zutat.kategorie].append({'name': zutat.name,

'menge': ', '.join(menge),

'key': str(zk)})

for z in qualitativkat.values():

z.sort(lambda x,y: cmp(x["name"].lower(), y["name"].lower()))

rezepte.sort(lambda x,y: cmp(x.titel.lower(), y.titel.lower()))

res = standard_template_values()

res.update({'dauer': dauer,

'beginn': beginn.strftime('%d. %m. %Y'),

'rezepte': rezepte,

'messbar': messbarkat,

'qualitativ': qualitativkat,

})

def get(self, *param):

bisdienstag = 8 - date.today().weekday()

if bisdienstag >6:

bisdienstag -= 7

beginn = date.today() + timedelta(bisdienstag)

dauer = 7

try:

b, d = "", 0

# Aufruf mit '/einkaufsliste/20.09.2009/7'?

if len(param)>1:

b = param[0]

d = int(param[1])

# Aufruf aus Formdaten?

temp = self.request.get('beginn')

if temp:

b = temp

temp = self.request.get('dauer')

if temp:

d = int(temp)

beginn = tools.str2date(b)

dauer = d

except (IndexError, ValueError):

pass

def get(self):

write = self.response.out.write

write(["""#coding: utf-8

import os

from google.appengine.ext import db

import datetime

import models

def apply_fixture():

if not os.environ['SERVER_SOFTWARE'].startswith('Development'):

return

rezepte = models.Rezept.all().fetch(200)

zutaten = models.Zutat.all().fetch(200)

rz = models.RezeptZutat.all().fetch(200)

menues = models.Menue.all().fetch(200)

db.delete(rezepte + zutaten + rz + menues)

"""])

for entitaet in (models.Zutat, models.Rezept, models.RezeptZutat, models.Menue):

for e in entitaet.all():

write(e.initString())

def get(self):

if not os.environ['SERVER_SOFTWARE'].startswith('Development'):

logging.error('Fixture darf nur auf dem Developmentserver aufgerufen werden.')

elif not self.authorize():

logging.error('Fixture: Der Benutzer ist nicht angemeldet.')

else:

import fixture

fixture.apply_fixture()

('/', MainPage),

('/index.html', MainPage),

('/googleea70c6ff94a550df.html', SiteVerification),

(r'/zutaten/(.+)', ZutatenEingabe),

(r'/zutaten', ZutatenEingabe),

(r'/zutatloeschen/(.+)', ZutatLoeschen),

(r'/rezepteingabe/?', RezeptEingabe),

(r'/rezepteingabe/(.+)/(.+)/?', RezeptBearbeiten),

(r'/rezepteingabe/(.+)/?', RezeptBearbeiten),

(r'/rezeptloeschen/(.+)/?', RezeptLoeschen),

(r'/rezepte/?', RezepteAnzeigen),

(r'/rezepte-mit-preis/?', RezepteAnzeigenMitPreis),

(r'/rezepte/(.+)/(.+)/?', RezeptAnzeigen),

(r'/rezepte/(.+)/?', RezeptAnzeigen),

(r'/rezeptbuch/?', RezeptBuch),

(r'/monatsplan/?', Monatsplan),

(r'/monatsplan/(.+)/(.+)/?', Monatsplan),

(r'/menueplan/(.+)/(.+)/(.+)/?', Menueplan),

(r'/einkaufsliste/(.+)/(.+)/?', Einkaufsliste),

(r'/einkaufsliste/(.+)/?', Einkaufsliste),

(r'/einkaufsliste/?', Einkaufsliste),

(r'/daten/?', DatenAusgabe),

(r'/impressum/?', Impressum),

(r'/fixture/?', Fixture),