#!/usr/bin/env python
import os
from Cheetah.Template import Template
from model.Record import EntitySet
CommentDatabase = EntitySet("groups", key="groupid")
def store_new_comment(the_comment):
return CommentDatabase.new_record(the_comment)
def read_database():
return CommentDatabase.read_database()
def store_comment(comment):
return CommentDatabase.store_record(comment)
def get_comment(comment):
return CommentDatabase.get_record(comment)
def delete_comment(comment):
return CommentDatabase.delete_record(comment)
# #
# # Map web request to data layer
# #
#!/usr/bin/python
from Cheetah.Template import Template
from model.Record import EntitySet
import sys
import os
ItemsDatabase = EntitySet("items",key="itemid")
def store_new_item(the_item): return ItemsDatabase.new_record(the_item)
def read_database(): return ItemsDatabase.read_database()
def store_item(item): return ItemsDatabase.store_record(item)
def get_item(item): return ItemsDatabase.get_record(item)
def delete_item(item): return ItemsDatabase.delete_record(item)
#
# Map web request to data layer
#
def make_item(stem="form", **argd):
new_item = {
"item" : argd.get(stem + ".item",""),
"__filename" : argd.get(stem + ".upload.1.__filename",""),
"tags" : argd.get(stem + ".tags",""),
}
new_item = store_new_item(new_item)
return new_item
#
# Map web request to data layer
#
#!/usr/bin/env python
from Cheetah.Template import Template
from model.Record import EntitySet
PeopleDatabase = EntitySet("people")
def store_new_person(the_person):
return PeopleDatabase.new_record(the_person)
def read_database():
return PeopleDatabase.read_database()
def store_person(person):
return PeopleDatabase.store_record(person)
def get_person(person):
return PeopleDatabase.get_record(person)
def delete_person(person):
return PeopleDatabase.delete_record(person)
#
# Map web request to data layer
#
#!/usr/bin/env python
import os
from Cheetah.Template import Template
from model.Record import EntitySet
CommentDatabase = EntitySet("comments", key="commentid")
def store_new_comment(the_comment):
return CommentDatabase.new_record(the_comment)
def read_database():
return CommentDatabase.read_database()
def store_comment(comment):
return CommentDatabase.store_record(comment)
def get_comment(comment):
return CommentDatabase.get_record(comment)
def delete_comment(comment):
return CommentDatabase.delete_record(comment)
# #
# # Map web request to data layer
# #
#!/usr/bin/env python
import os.path
import sys
sys.path.append("/srv/www/sites/bicker.kamaelia.org/cgi/app/Facilitate")
import CookieJar
from model.Record import EntitySet
EntitySet.data = "/srv/www/sites/bicker.kamaelia.org/cgi/app/data"
Registrations = EntitySet("registrations", key="regid")
Videos = EntitySet("videos", key="imageid")
loggedout = False
def loggedIn(env):
if loggedout:
return False
cookies = env.get("cookies", None)
if not cookies:
return False
sessioncookie_raw = cookies.get("sessioncookie", None)
if not sessioncookie_raw:
return False
#!/usr/bin/env python
from Cheetah.Template import Template
from model.Record import EntitySet
import cjson
import sys
import os
RelationSet = EntitySet
MissionStepsRelation = RelationSet("lists", key="relationid")
ItemsDatabase = EntitySet("missions", key="missionid")
PeopleDatabase = EntitySet("missions", key="missionid")
#
# This lot need dealing with more sensibly
#
def store_new_item(the_item):
return MissionStepsRelation.new_record(the_item)
def read_database():
return MissionStepsRelation.read_database()
def store_item(item):
return MissionStepsRelation.store_record(item)
#!/usr/bin/env python
import os.path
import sys ; sys.path.append("/srv/www/sites/bicker.kamaelia.org/cgi/app/Facilitate")
import CookieJar
from model.Record import EntitySet
EntitySet.data = "/srv/www/sites/bicker.kamaelia.org/cgi/app/data"
Registrations = EntitySet("registrations", key="regid")
Videos = EntitySet("videos", key="imageid")
loggedout = False
def loggedIn(env):
if loggedout:
return False
cookies = env.get("cookies", None)
if not cookies:
return False
sessioncookie_raw = cookies.get("sessioncookie", None)
if not sessioncookie_raw:
return False
sessioncookie = sessioncookie_raw.value
#!/usr/bin/python
from Cheetah.Template import Template
from model.Record import EntitySet
# NOTE: You would rename "Missions" here to match your entity set's name
MissionsDatabase = EntitySet("missions", key="missionid")
# NOTE: Likewise, rather than MissionsDatabase, this would be your entity's name
def store_new_mission(the_mission):
return MissionsDatabase.new_record(the_mission)
def read_database():
return MissionsDatabase.read_database()
def store_mission(mission):
return MissionsDatabase.store_record(mission)
def get_mission(mission):
return MissionsDatabase.get_record(mission)
def delete_mission(mission):
return MissionsDatabase.delete_record(mission)
#
# Map web request to data layer
if structure[0] == "responsestored":
return [], Interstitials.thankyou_template
if structure[0] == "error":
structure[1]["record"] = pprint.pformat(structure[1]["record"])
page = Interstitials.error % structure[1]
headers = []
if structure[1].get("setcookies", False):
cookies = structure[1]["setcookies"]
for cookie in cookies:
headers.append(
("Set-Cookie", "%s=%s" % (cookie, cookies[cookie])))
return headers, page
return [], Interstitials.failback % {"body": pprint.pformat(structure)}
def page_render_html(json, **argd):
extra_headers, page = MakeHTML(page_logic(json, **argd))
status = "200 OK"
headers = [('Content-type', "text/html")]
return status, headers + extra_headers, page
SimpleResponses = EntitySet("simpleresponses", key="responseid")
if __name__ == "__main__":
pass
#!/usr/bin/env python
from Cheetah.Template import Template
from model.Record import EntitySet
PeopleDatabase = EntitySet("people", "personid")
#
# Map web request to data layer
#
def make_person(stem="form", **argd):
new_person = {
"person": argd.get(stem + ".person", ""),
"house": argd.get(stem + ".house", ""),
"street": argd.get(stem + ".street", ""),
"town": argd.get(stem + ".town", ""),
"county": argd.get(stem + ".county", ""),
"postcode": argd.get(stem + ".postcode", ""),
"phone": argd.get(stem + ".phone", ""),
}
new_person = PeopleDatabase.new_record(new_person)
return new_person
#
# Map web request to data layer
#
#!/usr/bin/env python
from Cheetah.Template import Template
from model.Record import EntitySet
import sys
import os
RelationSet = EntitySet
TreesMembers = RelationSet("treesmembers", key="treememberid")
TreesDatabase = EntitySet("trees", key="treeid")
PeopleDatabase = EntitySet("people", key="personid")
#
# This lot need dealing with more sensibly
#
def store_new_item(the_item):
return TreesMembers.new_record(the_item)
def read_database():
return TreesMembers.read_database()
def store_item(item):
return TreesMembers.store_record(item)
def get_item(item):
#!/usr/bin/env python
import os
from Cheetah.Template import Template
from model.Record import EntitySet
CommentDatabase = EntitySet("trees", key="treeid")
def store_new_comment(the_comment):
return CommentDatabase.new_record(the_comment)
def read_database():
return CommentDatabase.read_database()
def store_comment(comment):
return CommentDatabase.store_record(comment)
def get_comment(comment):
return CommentDatabase.get_record(comment)
def delete_comment(comment):
return CommentDatabase.delete_record(comment)
# #
# # Map web request to data layer
# #
def page_render_html(json, **argd):
action = argd.get("formtype", "overview")
R = RelationRender(argd["__environ__"])
if action == "overview":
relations = read_database()
rendered_relations = R.rendered_record_list(
relations) # generalised Rendered Relation
return R.render_page(content=rendered_relations) #str(R.environ)) #
if action == "edit_new":
relations = read_database()
rendered_relations = R.rendered_record_list(
relations) #generalised Rendered Realtion
leftitemtypes = get_itemtypes(
) #return the list of top level data items
relations = read_database()
rendered_relations = R.rendered_record_list(relations)
empty_data_entry = R.rendered_itemtypes(-1, leftitemtypes)
configured_form = R.render_configured_form(empty_data_entry,
nextstep="edit_items")
return R.render_page(content=rendered_relations,
dataentry=configured_form)
if action == "edit_items":
relations = read_database()
#rendered_relations = R.rendered_record_list(relations) # need generalised RenderedRealtion here
#os.sys.stderr.write(argd.get("form.leftid")+"\n")
#os.sys.stderr.write(argd.get("form.rightid")+"\n")
leftdbid = argd.get("form.leftid")
rightdbid = argd.get("form.rightid")
leftdb_key = get_itemtype_key(leftdbid)
rightdb_key = get_itemtype_key(rightdbid)
relationid = -1
#os.sys.stderr.write(leftdb_key+" "+rightdb_key+ "\n")
leftdb = EntitySet(leftdbid, key=leftdb_key)
rightdb = EntitySet(rightdbid, key=rightdb_key)
#relation = RenderedRelation(R,leftdb, rightdb )
available_relations = RenderedRelation(R, leftdb, rightdb)
empty_data_entry = RenderedRelationEntryForm(relationid, leftdbid,
rightdbid, leftdb_key,
rightdb_key, leftdb,
rightdb)
#os.sys.stderr.write("empty data entry returned \n")
#os.sys.stderr.write(repr(empty_data_entry))
configured_form = R.render_configured_item_form(empty_data_entry,
nextstep="create_new",
submitlabel="Add Item")
return R.render_page(content=available_relations,
dataentry=configured_form)
if action == "view_relation":
relations = read_database()
rendered_relations = R.rendered_record_list(relations)
relation = get_item(argd["relationid"])
relation_pair = get_item_record_pair(relation)
rendered_relation_pair = RenderedRelationPair(R, relation,
relation_pair)
return R.render_page(content=rendered_relations,
dataentry=rendered_relation_pair)
if action == "edit_relation":
relations = read_database()
rendered_relations = R.rendered_record_list(relations)
relation = get_item(argd["relationid"])
relation_pair = get_item_record_pair(relation)
rendered_relation_pair = RenderedRelationPair(R, relation,
relation_pair)
leftitemtypes = get_itemtypes()
empty_data_entry = R.rendered_itemtypes(argd["relationid"],
leftitemtypes)
configured_form = R.render_configured_form(
empty_data_entry,
nextstep="update_items",
submitlabel="Update Item",
)
return R.render_page(extra=rendered_relations,
content=rendered_relation_pair,
dataentry=configured_form)
if action == "create_new":
os.sys.stderr.write(argd.get("form.left_dbid") + "\n")
os.sys.stderr.write(argd.get("form.right_dbid") + "\n")
new_relation = make_item(stem="form",
**argd) # Also stores them in the database
relations = read_database()
rendered_relations = R.rendered_record_list(relations)
relation_pair = get_item_record_pair(new_relation)
rendered_relation_pair = RenderedRelationPair(R, new_relation,
relation_pair)
#rendered_tuple = RenderedTuple(argd["__environ__"],"missionstepid", new_item["missionstepid"], ItemsDatabase, PeopleDatabase)
rendered_relation_pair = "<B> Record Saved </B>. If you wish to update, please do" + str(
rendered_relation_pair)
#rendered_tuple = "<B> Record Saved </B>. If you wish to update, please do" + str(rendered_tuple)
#relation = get_item(argd["relationid"])
return R.render_page(content=rendered_relations,
dataentry=rendered_relation_pair)
if action == "delete_relation":
# Take the data sent to us, and use that to fill out an edit form
#
# Note: This is actually filling in an *edit* form at that point, not a *new* user form
# If they submit the new form, the surely they should be viewed to be updating the form?
# yes...
#
# Show the database & a few options
relations = read_database()
rendered_relations = R.rendered_record_list(
relations) # generalised Rendered Relation
relation = get_item(argd["relationid"])
relation_pair = get_item_record_pair(relation)
rendered_relation_pair = RenderedRelationPair(R, relation,
relation_pair)
prebanner = "<h3> Are you sure you wish to delete this item</h3>"
delete_action = "<a href='/cgi-bin/app/relations?formtype=confirm_delete&relationid=%s'>%s</a>" % (
relation["relationid"], "Delete this item")
cancel_action = "<a href='/cgi-bin/app/relations?formtype=view_relation&relationid=%s'>%s</a>" % (
relation["relationid"], "Cancel deletion")
delete_message = "%s <ul> %s </ul><h3> %s | %s </h3>" % (
prebanner, str(rendered_relation_pair), delete_action,
cancel_action)
return R.render_page(content=rendered_relations,
dataentry=delete_message)
if action == "confirm_delete":
relation = get_item(argd["relationid"])
delete_item(argd["relationid"])
relations = read_database() # Show the database & a few options
rendered_relations = R.rendered_record_list(
relations) # generalised Rendered Relation
return R.render_page(content=rendered_relations,
dataentry="<h1> Record %s Deleted </h1>" %
argd["relationid"])
if action == "update_items":
relationid = argd.get("form.relationid")
relation = get_item(relationid)
relation_pair = get_item_record_pair(relation)
rendered_relation_pair = RenderedRelationPair(R, relation,
relation_pair)
relations = read_database()
leftdbid = argd.get("form.leftid")
rightdbid = argd.get("form.rightid")
leftdb_key = get_itemtype_key(leftdbid)
rightdb_key = get_itemtype_key(rightdbid)
#os.sys.stderr.write(leftdb_key+" "+rightdb_key+ "\n")
leftdb = EntitySet(leftdbid, key=leftdb_key)
rightdb = EntitySet(rightdbid, key=rightdb_key)
available_relations = RenderedRelation(R, leftdb, rightdb)
empty_data_entry = RenderedRelationEntryForm(relationid, leftdbid,
rightdbid, leftdb_key,
rightdb_key, leftdb,
rightdb)
configured_form = R.render_configured_item_form(
empty_data_entry, nextstep="update", submitlabel="Update Item")
return R.render_page(content=available_relations,
dataentry=configured_form)
if action == "update":
# Take the data sent to us, and use that to fill out an edit form
#
# Note: This is actually filling in an *edit* form at that point, not a *new* user form
# If they submit the new form, the surely they should be viewed to be updating the form?
# yes...
#
relation = get_item(argd.get("form.relationid"))
theitem = update_item(stem="form", **argd)
relations = read_database()
rendered_relations = R.rendered_record_list(
relations) # generalised Rendered Relation
relation_pair = get_item_record_pair(relation)
rendered_relation_pair = RenderedRelationPair(R, relation,
relation_pair)
rendered_tuple = "<B> Record Saved </B>. If you wish to update, please do" + str(
rendered_relation_pair)
return R.render_page(content=rendered_relations,
dataentry=rendered_tuple)
return str(
Template(
file='templates/Page.tmpl',
searchList=[
argd["__environ__"],
{
"extra":
"",
"content":
"Sorry, got no idea what you want! (%s)" % str(action),
"dataentry":
"",
"banner":
"Not found", # XXXX should send back a 404 status
}
]))
return [], Interstitials.uploadok
if structure[0] == "error":
structure[1]["record"] = pprint.pformat(structure[1]["record"])
page = Interstitials.error % structure[1]
headers = []
if structure[1].get("setcookies", False):
cookies = structure[1]["setcookies"]
for cookie in cookies:
headers.append(
("Set-Cookie", "%s=%s" % (cookie, cookies[cookie])))
return headers, page
return [], Interstitials.failback % {"body": pprint.pformat(structure)}
def page_render_html(json, **argd):
extra_headers, page = MakeHTML(page_logic(json, **argd))
status = "200 OK"
headers = [('Content-type', "text/html")]
return status, headers + extra_headers, page
Images = EntitySet("images", key="imageid")
Registrations = EntitySet("registrations", key="regid")
Contacts = EntitySet("contacts", key="contactid")
if __name__ == "__main__":
pass
#!/usr/bin/env python
import os.path
import sys
sys.path.append("/srv/www/sites/bicker.kamaelia.org/cgi/app/Facilitate")
import CookieJar
from model.Record import EntitySet
EntitySet.data = "/srv/www/sites/bicker.kamaelia.org/cgi/app/data"
Registrations = EntitySet("registrations", key="regid")
Contacts = EntitySet("contacts", key="contactid")
def set_cookie(env, thecookie, value):
env["context"]["newcookies"][thecookie] = value
loggedout = False
def loggedIn(env):
if loggedout:
return False
cookies = env.get("cookies", None)
if not cookies:
return False
sessioncookie_raw = cookies.get("sessioncookie", None)
if not sessioncookie_raw:
headers.append(
("Set-Cookie", "%s=%s" % (cookie, cookies[cookie])))
return headers, page
return [], Interstitials.failback % {"body": pprint.pformat(structure)}
def page_render_html(json, **argd):
extra_headers, page = MakeHTML(page_logic(json, **argd))
status = "200 OK"
headers = [('Content-type', "text/html")]
return status, headers + extra_headers, page
Registrations = EntitySet("registrations", key="regid")
if __name__ == "__main__":
print "Enter password for [email protected]"
password = raw_input(
">> ") # To avoid putting even a test password in the repository... :)
loginbundle = {
'email': '*****@*****.**',
'password': password,
'submit': '+Login+',
}
result = page_logic(None, **loginbundle)
print result
result = page_render_html(None, **loginbundle)
#!/usr/bin/env python
from Cheetah.Template import Template
from model.Record import EntitySet
import sys
import os
RelationSet = EntitySet
ItemsPeopleRelation = RelationSet("itemspeople_relation", key="itempersonid")
ItemsDatabase = EntitySet("items", key="itemid")
PeopleDatabase = EntitySet("people")
#
# This lot need dealing with more sensibly
#
def store_new_item(the_item):
return ItemsPeopleRelation.new_record(the_item)
def read_database():
return ItemsPeopleRelation.read_database()
def store_item(item):
return ItemsPeopleRelation.store_record(item)
def get_item(item):
#!/usr/bin/env python
import os.path
import sys ; sys.path.append("/srv/www/sites/bicker.kamaelia.org/cgi/app/Facilitate")
import CookieJar
from model.Record import EntitySet
EntitySet.data = "/srv/www/sites/bicker.kamaelia.org/cgi/app/data"
Images = EntitySet("images", key="imageid")
Registrations = EntitySet("registrations", key="regid")
Contacts = EntitySet("contacts", key="contactid")
loggedout = False
def loggedIn(env):
if loggedout:
return False
cookies = env.get("cookies", None)
if not cookies:
return False
sessioncookie_raw = cookies.get("sessioncookie", None)
if not sessioncookie_raw:
return False
sessioncookie = sessioncookie_raw.value
return [], Interstitials.video_uploadok
if structure[0] == "error":
structure[1]["record"] = pprint.pformat(structure[1]["record"])
page = Interstitials.error % structure[1]
headers = []
if structure[1].get("setcookies", False):
cookies = structure[1]["setcookies"]
for cookie in cookies:
headers.append(
("Set-Cookie", "%s=%s" % (cookie, cookies[cookie])))
return headers, page
return [], Interstitials.failback % {"body": pprint.pformat(structure)}
def page_render_html(json, **argd):
extra_headers, page = MakeHTML(page_logic(json, **argd))
status = "200 OK"
headers = [('Content-type', "text/html")]
return status, headers + extra_headers, page
Videos = EntitySet("videos", key="videoid")
Registrations = EntitySet("registrations", key="regid")
Contacts = EntitySet("contacts", key="contactid")
if __name__ == "__main__":
pass
cookies = structure[1]["setcookies"]
for cookie in cookies:
headers.append( ("Set-Cookie", "%s=%s" % ( cookie, cookies[cookie]) ) )
return headers, page
return [], Interstitials.failback % { "body" : pprint.pformat(structure) }
def page_render_html(json, **argd):
extra_headers, page = MakeHTML( page_logic(json, **argd) )
status = "200 OK"
headers = [('Content-type', "text/html")]
return status, headers+extra_headers, page
Registrations = EntitySet("registrations", key="regid")
if __name__ == "__main__":
if 0:
print "WARNING, running this test will zap your local store"
print "press return to continue, control-c to not continue"
raw_input()
Registrations.Zap("registrations","regid")
testcases = [
[ "new",
"should succeed",
"Can create new record in new database",
{
'action' : 'new',
'dob.day': '30',
'dob.month': 'June',
#!/usr/bin/env python
from Cheetah.Template import Template
from model.Record import EntitySet
import os,time
UsersDatabase = EntitySet("users",key="userid")des
def store_new_user(the_user): return UsersDatabase.new_record(the_user)
def read_database(): return UsersDatabase.read_database()
def store_user(user): return UsersDatabase.store_record(user)
def get_user(user): return UsersDatabase.get_record(user)
def delete_user(user): return UsersDatabase.delete_record(user)
#
# Map web request to data layer
#
def make_user_unique(fields = [], stem="form", **argd):
if fields==[]:
make_user(stem="form", **argd)
else:
new_vals = {}
for field in fields:
new_vals[field] = argd.get("form."+field)
users = read_database()
if not users:
os.sys.stderr.write("new user empty db+++++++++++++++++++++++++\n")
return make_user(stem="form", **argd)
for user in users:
def page_render_html(json, **argd):
action = argd.get("formtype", "overview")
R = RelationRender(argd["__environ__"])
if action == "overview":
relations = read_database()
rendered_relations = R.rendered_record_list(
relations) # generalised Rendered Relation
return R.render_page(content=rendered_relations) #str(R.environ)) #
if action == "edit_new":
relations = read_database()
os.sys.stderr.write(
repr(relations) + "***************empty db *****\n")
if relations == []:
leftitemtypes = get_itemtypes(dirlist=["items", "comments"])
else:
leftitemtypes = get_itemtypes()
rendered_relations = R.rendered_record_list(
relations) #generalised Rendered Relation
#leftitemtypes = get_itemtypes() #return the list of top level data items
relations = read_database()
rendered_relations = R.rendered_record_list(relations)
empty_data_entry = R.rendered_itemtypes(-1, relations, leftitemtypes)
configured_form = R.render_configured_form(empty_data_entry,
nextstep="edit_items")
return R.render_page(content=rendered_relations,
dataentry=configured_form)
if action == "edit_items":
relations = read_database()
#rendered_relations = R.rendered_record_list(relations) # need generalised RenderedRelation here
#os.sys.stderr.write(argd.get("form.leftid")+"\n")
#os.sys.stderr.write(argd.get("form.rightid")+"\n")
leftdbid = argd.get("form.leftid")
rightdbid = argd.get("form.rightid")
leftdb_key = get_itemtype_key(leftdbid)
rightdb_key = get_itemtype_key(rightdbid)
relationid = -1
#os.sys.stderr.write(leftdb_key+" "+rightdb_key+ "\n")
leftdb = EntitySet(leftdbid, key=leftdb_key)
rightdb = EntitySet(rightdbid, key=rightdb_key)
#relation = RenderedRelation(R,leftdb, rightdb )
available_relations = RenderedRelation(R, leftdb, rightdb)
empty_data_entry = RenderedRelationEntryForm(relationid, leftdbid,
rightdbid, leftdb_key,
rightdb_key, leftdb,
rightdb)
#os.sys.stderr.write("empty data entry returned \n")
#os.sys.stderr.write(repr(empty_data_entry))
configured_form = R.render_configured_item_form(empty_data_entry,
nextstep="create_new",
submitlabel="Add Item")
return R.render_page(content=available_relations,
dataentry=configured_form)
if action == "view_relation":
relations = read_database()
rendered_relations = R.rendered_record_list(relations)
relation = get_item(argd["relationid"])
relation_pair = get_item_record_pair(relation)
rendered_relation_pair = RenderedRelationPair(R, relation,
relation_pair)
return R.render_page(content=rendered_relations,
dataentry=rendered_relation_pair)
if action == "edit_relation":
relations = read_database()
rendered_relations = R.rendered_record_list(relations)
relation = get_item(argd["relationid"])
relation_pair = get_item_record_pair(relation)
rendered_relation_pair = RenderedRelationPair(R, relation,
relation_pair)
leftitemtypes = get_itemtypes()
empty_data_entry = R.rendered_itemtypes(argd["relationid"], relations,
leftitemtypes)
configured_form = R.render_configured_form(
empty_data_entry,
nextstep="update_items",
submitlabel="Update Item",
)
return R.render_page(
extra=rendered_relations,
content=rendered_relation_pair,
dataentry=configured_form) # rendered_relations , "pop")
if action == "create_new":
#os.sys.stderr.write(argd.get("form.left_dbid")+"\n")
#os.sys.stderr.write(argd.get("form.right_dbid")+"\n")
relations = read_database()
rendered_relations = R.rendered_record_list(relations)
if argd.get("form.left_dbid"
) == "lists": # now we handle building the tree
for relation in relations: # check lhs existence
if argd.get("form.left_itemid") == relation[
"left_itemid"] and relation["left_dbid"] == "lists":
duplicate_content = "<B> Record Not Saved </B>. The relation you requested already exists"
return R.render_page(content=rendered_relations,
dataentry=duplicate_content)
parent_record = get_item_record("lists",
argd.get("form.left_itemid"))
if parent_record["left_dbid"] != "lists": # We are at the root node
argd["form.root_id"] = parent_record["relationid"]
else: # child node
argd["form.root_id"] = parent_record["root_id"]
else:
argd["form.root_id"] = -1
# Don't need to track back to root node just look at parent
# This will be handy for displaying the lists later.
# rootid = None
# while parent_record["left_dbid"]!=None and parent_record["left_dbid"]=="lists": # find the root node
# rootid=parent_record["root_id"] # set rootid to current root node
# parent_record = get_item_record("lists", parent_record["left_itemid"])
# if parent_record == None: # root node has been deleted
# argd["form.root_id"]=rootid
# break
# if parent_record != None: # this is the root
# argd["form.root_id"]=parent_record["relationid"]
# else: # use child root
# argd["form.root_id"]=rootid
# else:
# argd["form.root_id"]=-1
new_relation = make_item(stem="form",
**argd) # Also stores them in the database
rendered_relations = R.rendered_record_list(relations)
relation_pair = get_item_record_pair(new_relation)
rendered_relation_pair = RenderedRelationPair(R, new_relation,
relation_pair)
#rendered_tuple = RenderedTuple(argd["__environ__"],"missionstepid", new_item["missionstepid"], ItemsDatabase, PeopleDatabase)
rendered_relation_pair = "<B> Record Saved </B>. If you wish to update, please do" + str(
rendered_relation_pair)
#rendered_tuple = "<B> Record Saved </B>. If you wish to update, please do" + str(rendered_tuple)
#relation = get_item(argd["relationid"])
return R.render_page(content=rendered_relations,
dataentry=rendered_relation_pair)
if action == "delete_relation":
# Take the data sent to us, and use that to fill out an edit form
#
# Note: This is actually filling in an *edit* form at that point, not a *new* user form
# If they submit the new form, the surely they should be viewed to be updating the form?
# yes...
#
# Show the database & a few options
relations = read_database()
rendered_relations = R.rendered_record_list(
relations) # generalised Rendered Relation
relation = get_item(argd["relationid"])
relation_pair = get_item_record_pair(relation)
rendered_relation_pair = RenderedRelationPair(R, relation,
relation_pair)
prebanner = "<h3> Are you sure you wish to delete this item</h3>"
delete_action = "<a href='/cgi-bin/app/lists?formtype=confirm_delete&relationid=%s'>%s</a>" % (
relation["relationid"], "Delete this item")
cancel_action = "<a href='/cgi-bin/app/lists?formtype=view_relation&relationid=%s'>%s</a>" % (
relation["relationid"], "Cancel deletion")
delete_message = "%s <ul> %s </ul><h3> %s | %s </h3>" % (
prebanner, str(rendered_relation_pair), delete_action,
cancel_action)
return R.render_page(content=rendered_relations,
dataentry=delete_message)
if action == "confirm_delete":
relation = get_item(argd["relationid"])
delete_item(argd["relationid"])
relations = read_database() # Show the database & a few options
rendered_relations = R.rendered_record_list(
relations) # generalised Rendered Relation
return R.render_page(content=rendered_relations,
dataentry="<h1> Record %s Deleted </h1>" %
argd["relationid"])
if action == "update_items":
relationid = argd.get("form.relationid")
relation = get_item(relationid)
relation_pair = get_item_record_pair(relation)
rendered_relation_pair = RenderedRelationPair(R, relation,
relation_pair)
relations = read_database()
leftdbid = argd.get("form.leftid")
rightdbid = argd.get("form.rightid")
leftdb_key = get_itemtype_key(leftdbid)
rightdb_key = get_itemtype_key(rightdbid)
#os.sys.stderr.write(leftdb_key+" "+rightdb_key+ "\n")
leftdb = EntitySet(leftdbid, key=leftdb_key)
rightdb = EntitySet(rightdbid, key=rightdb_key)
available_relations = RenderedRelation(R, leftdb, rightdb)
empty_ata_entry = RenderedRelationEntryForm(relationid, leftdbid,
rightdbid, leftdb_key,
rightdb_key, leftdb,
rightdb)
configured_form = R.render_configured_item_form(
empty_data_entry, nextstep="update", submitlabel="Update Item")
return R.render_page(content=available_relations,
dataentry=configured_form)
if action == "update":
# Take the data sent to us, and use that to fill out an edit form
#
# Note: This is actually filling in an *edit* form at that point, not a *new* user form
# If they submit the new form, the surely they should be viewed to be updating the form?
# yes...
#
relation = get_item(argd.get("form.relationid"))
#the_relation = update_relationt(stem="form", **argd)
theitem = update_item(stem="form", **argd)
relations = read_database()
rendered_relations = R.rendered_record_list(
relations) # generalised Rendered Relation
relation_pair = get_item_record_pair(relation)
rendered_relation_pair = RenderedRelationPair(R, theitem,
relation_pair)
rendered_tuple = "<B> Record Saved </B>. If you wish to update, please do" + str(
rendered_relation_pair)
return R.render_page(content=rendered_relations,
dataentry=rendered_tuple)
return str(
Template(
file='templates/Page.tmpl',
searchList=[
argd["__environ__"],
{
"extra":
"",
"content":
"Sorry, got no idea what you want! (%s)" % str(action),
"dataentry":
"",
"banner":
"Not found", # XXXX should send back a 404 status
}
]))
#!/usr/bin/env python
from Cheetah.Template import Template
from model.Record import EntitySet
import sys
import os
RelationSet = EntitySet
GroupsMembers = RelationSet("groupsmembers",key="groupmemberid")
GroupsDatabase = EntitySet("groups",key="groupid")
PeopleDatabase = EntitySet("people",key="personid")
#
# This lot need dealing with more sensibly
#
def store_new_item(the_item): return GroupsMembers.new_record(the_item)
def read_database(): return GroupsMembers.read_database()
def store_item(item): return GroupsMembers.store_record(item)
def get_item(item): return GroupsMembers.get_record(item)
def delete_item(item): return GroupsMembers.delete_record(item)
#
# Map web request to data layer
#
def make_item(stem="form", **argd):
new_item = {
"groupid" : argd.get(stem + ".groupid",""),
"groupname": argd.get(stem + ".groupname",""),