def external_point_update(point, user):
db_point = list(point_by_uuid(point.uuid) or [])
if db_point:
# !!! should we update lat, lon too?
point.id = db_point[0].id
web.query("""
UPDATE locations
SET title=$title
WHERE id = $id
;
""",
vars=point.copy())
# how to update tags???
# tags_insert(point, user, point.tags, deny_namespaces=[])
return "update"
else:
web.insert(
"locations",
lat=point.lat,
lon=point.lon,
title=point.title,
uuid=point.uuid,
user_id=user.id,
origin=point.origin,
added=point.added, #!!!?
url=point.url)
db_point = list(point_by_uuid(point.uuid))[0]
tags_insert(db_point, user, point.tags, deny_namespaces=[])
point.id = db_point.id
return "insert"
def update_projects_points(project, point):
project_id = project.id
if not hasattr(point, "id"):
db_point = list(point_by_uuid(point.uuid))
if db_point:
# !!! should we update lat, lon too?
point_id = db_point[0].id
else:
point_id = 0 #!!!
else:
point_id = point.id
exists = web.query("""
SELECT * FROM projects_points
WHERE
location_id=$point_id
AND project_id=$project_id
AND projects_points.visible = 1
LIMIT 1;
""", vars=locals())
if not exists:
web.insert("projects_points",
location_id=point_id,
project_id=project_id,
visible=project.visible and getattr(point, "visible", 1),
)
def external_point_update(point, user):
db_point = list(point_by_uuid(point.uuid) or [])
if db_point:
# !!! should we update lat, lon too?
point.id = db_point[0].id
web.query("""
UPDATE locations
SET title=$title
WHERE id = $id
;
""", vars=point.copy())
# how to update tags???
# tags_insert(point, user, point.tags, deny_namespaces=[])
return "update"
else:
web.insert("locations",
lat=point.lat,
lon=point.lon,
title=point.title,
uuid=point.uuid,
user_id=user.id,
origin=point.origin,
added=point.added, #!!!?
url=point.url)
db_point = list(point_by_uuid(point.uuid))[0]
tags_insert(db_point, user, point.tags, deny_namespaces=[])
point.id = db_point.id
return "insert"
def update_projects_points(project, point):
project_id = project.id
if not hasattr(point, "id"):
db_point = list(point_by_uuid(point.uuid))
if db_point:
# !!! should we update lat, lon too?
point_id = db_point[0].id
else:
point_id = 0 #!!!
else:
point_id = point.id
exists = web.query("""
SELECT * FROM projects_points
WHERE
location_id=$point_id
AND project_id=$project_id
AND projects_points.visible = 1
LIMIT 1;
""",
vars=locals())
if not exists:
web.insert(
"projects_points",
location_id=point_id,
project_id=project_id,
visible=project.visible and getattr(point, "visible", 1),
)
def set_policies(object, user, roles, adder_user):
for role in roles:
web.insert("locations_policy_table",
user_id=user.id,
location_id=object.id,
adder_user_id=adder_user.id,
role=role)
def _prepared(node, raw=False):
if node.cache and not raw:
cached = pickle.loads(node.cache)
# override the user info in cached, since when the user updates their
# profile, it will not update the node cache
cached.name = node.name
cached.picture = node.picture
return cached
# Proceed to build the node from scratch.
# Merge data created by node modules.
node = _node_load(node)
# Apply filters or other preperations.
if not raw:
node = _node_prepare(node)
# Cache all that work so we never have to do it until something changes.
pickled = pickle.dumps(node)
if node.cache_nid:
web.update('cache_node',where='nid=$node.nid AND vid=$node.vid',
created=time.time(), cache=pickled)
else:
web.insert('cache_node',nid=node.nid,vid=node.vid,
created=time.time(),cache=pickled)
return node
def approve(self, url, user_id, path, revision):
site_id = core.db.get_site_id(url)
page_id = core.db.get_page_id(url, path)
# @@ is there any better way?
web.transact()
try:
web.delete(
"review",
where=
"site_id=$site_id AND page_id=$page_id AND user_id=$user_id",
vars=locals(),
)
web.insert(
"review",
site_id=site_id,
page_id=page_id,
user_id=user_id,
revision=revision,
)
except:
web.rollback()
raise
else:
web.commit()
def set_policies(object, user, roles, adder_user):
for role in roles:
web.insert("locations_policy_table",
user_id=user.id,
location_id=object.id,
adder_user_id=adder_user.id,
role=role
)
def node_update(node):
teaser = node.body.split('<!--break-->')[0] # Create the teaser
# TODO: add something so it doesn't have to create a new revision
# every single time we change something.
new_vid = node.vid + 1
web.insert('node_revisions',nid=node.nid,vid=new_vid, uid=node.uid,
teaser=teaser, body=node.body, timestamp=node.time_now,
title=node.title, format=node.format)
def process_record(file_id, pos, length, data):
rec = index_fields(data, ['001', '010', '020', '035', '245'], check_author = False)
if not rec:
return
extra = dict((f, rec[f][0]) for f in ('title', 'lccn', 'call_number') if f in rec)
rec_id = web.insert('rec', marc_file = file_id, pos=pos, len=length, **extra)
for f in (f for f in ('isbn', 'oclc') if f in rec):
for v in rec[f]:
web.insert(f, seqname=False, rec=rec_id, value=v)
def process_record(file_id, pos, length, data):
rec = index_fields(data, ['001', '010', '020', '035', '245'], check_author = False)
if not rec:
return
extra = dict((f, rec[f][0]) for f in ('title', 'lccn', 'call_number') if f in rec)
rec_id = web.insert('rec', marc_file = file_id, pos=pos, len=length, **extra)
for f in (f for f in ('isbn', 'oclc') if f in rec):
for v in rec[f]:
web.insert(f, seqname=False, rec=rec_id, value=v)
def __setitem__(self, key, values):
#make values a storage object if it's not...
#there is probably a cleaner way to do this
if issubclass(values,dict) is not True:
values = web.storify({key:values})
if self.has_key(key):
web.update(self.table,where=self.index+'=$key',vars=locals(),**web.storify(values,**self[key]))
else:
web.insert(self.table,**web.storify({self.index:key},**values))
dict.__setitem__(self,key,values)
def store_infos(infos, extra_db_entries):
print " %s" % (infos)
#web.debug(" %s" % (infos))
simple_infos = infos.copy()
multiple_infos = {}
for imv in config.have_many_values:
try:
del simple_infos[imv]
multiple_infos[imv] = infos[imv]
except KeyError:
pass
#checking for file renaming with sha
possiblePrevFiles = web.query("select id, filename, batch from images where sha ='"+infos['sha']+"'")
updatingFile = False
if len(possiblePrevFiles) == 1:
#file found in db
print "INFO duplicate found : "+infos['filename']
prevFile = possiblePrevFiles[0]
file_id = prevFile.id
simple_infos['batch'] = prevFile.batch
try:
extra_db_entries.remove(prevFile.filename)
web.update('images', 'id = %s' % file_id, None, **simple_infos)
updatingFile = True
except ValueError:
#raise with .remove when the filename do not match
print "WARNING duplicate sha accross fileset, creating new entry"
else:
if len(possiblePrevFiles) > 1:
#more than one file with this sha...
print "INFO sha present multiple time for file : "+infos["filename"]
file_id = web.insert('images', True, **simple_infos)
for index in multiple_infos.keys():
#store the value in its table
for value in multiple_infos[index]:
try:
value_id = web.insert(index+'s', True, **{"value" : value})
#debuginsert(index+'s', False, **{"value" : value})
except:
#TODO should be IntegrityError for mysql but not sure how best integrate that without breaking the DB abstraction...
#but if the error wasn't an IntegrityError then the next line should fail
value_id = web.query('select id from %ss where value = "%s"' % (index, value))[0].id
#store the relationship between the value and the file
try:
web.insert("images_"+index+'s', False, **{index+"_id": value_id, "image_id" : file_id})
except Exception, inst:
#if we are update a file we might raise some integrity error here
if updatingFile:
pass
else:
raise inst
def datasource_insert(datasource, project, user):
#!!! check for doubles
ds_id = web.insert("datasources",
type=datasource.type,
adapter=datasource.adapter,
url=datasource.url,
frequency=datasource.frequency,
description=datasource.description)
web.insert("locations_datasources",
datasource_id=ds_id,
location_id=project.id,
)
return ds_id
def approve(self, url, user_id, path, revision):
site_id = core.db.get_site_id(url)
page_id = core.db.get_page_id(url, path)
#@@ is there any better way?
web.transact()
try:
web.delete('review', where="site_id=$site_id AND page_id=$page_id AND user_id=$user_id", vars=locals())
web.insert('review', site_id=site_id, page_id=page_id, user_id=user_id, revision=revision)
except:
web.rollback()
raise
else:
web.commit()
def datasource_insert(datasource, project, user):
#!!! check for doubles
ds_id = web.insert("datasources",
type=datasource.type,
adapter=datasource.adapter,
url=datasource.url,
frequency=datasource.frequency,
description=datasource.description)
web.insert(
"locations_datasources",
datasource_id=ds_id,
location_id=project.id,
)
return ds_id
def new_site(content, scroll_pos, caret_pos, secret_url, public_url, partner):
schemes = [('520000', 'fff', 'ffbfbf', 0, 214),
('523000', 'fff', 'ffe5bf', 25, 214),
('515200', 'fff', 'feffbf', 43, 214),
('2c5200', 'fff', 'e2ffbf', 62, 214),
('003452', 'fff', 'bfe8ff', 143, 214),
('001152', 'fff', 'bfcdff', 161, 214),
('4d0052', 'fff', 'fbbfff', 210, 214),
('520036', 'fff', 'ffbfe9', 227, 214),
('760000', 'fff', 'ffbfbf', 0, 196),
('764000', 'fff', 'ffe2bf', 23, 196),
('087600', 'fff', 'c4ffbf', 82, 196),
('004876', 'fff', 'bfe6ff', 144, 196),
('760043', 'fff', 'ffbfe3', 231, 196),
('92e600', '000', '3a5c00', 58, 140),
('d7ecff', '000', '003566', 148, 20),
('d8ffd7', '000', '026600', 84, 20),
('fcd7ff', '000', '5e0066', 209, 20),
('ffffd7', '000', '656600', 43, 20),
('ffd7d7', '000', '660000', 0, 20),
('d7fff9', '000', '006656', 121, 20),
('d7d7ff', '000', '000066', 170, 20)]
def url_taken(url):
return web.select('sites', where='public_url=$url or secret_url=$url', vars=locals())
def create_url():
def safe36(s):
for c in '0o1li':
if c in s:
return False
return True
s = '0'
while not safe36(s):
s = web.to36(random.randrange(50000, 60000000))
return s
if not secret_url:
secret_url = create_url()
while(url_taken(secret_url)):
secret_url = create_url()
header_color, title_color, subtitle_color, hue, brightness = schemes[random.randrange(0, len(schemes))]
site_id = web.insert('sites', secret_url=secret_url, public_url=public_url, partner=partner)
jt.site = web.select('sites', where='id=$site_id', vars=locals())[0]
web.insert('designs', site_id=jt.site.id, title_font='Lucida_Grande', subtitle_font='Lucida_Grande', headings_font='Lucida_Grande', content_font='Lucida_Grande', header_color='#'+header_color, title_color='#'+title_color, subtitle_color='#'+subtitle_color, hue=hue, brightness=brightness)
new_page('', content, scroll_pos, caret_pos)
jt.site = get_site(id=site_id)
def POST(self):
i = web.input()
if hasattr(web, 'insert'):
n = web.insert('todo', title=i.title)
else:
db.insert('todo', title=i.title)
web.seeother('/todo')
def POST(self, node_type):
page = self.page
form = _form_node(node_type,
page.user.roles.keys()) # checks if this node_type exists too
checkaccess(page.user, ''.join(('create ',node_type,' content')))
if form.validates():
node = form.d
node.time_now = int(time.time())
node.uid = page.user.uid
# Get publishing settings.
options = mod[node_type].defaults
# Insert main entry in 'node' table
node.nid = web.insert('node',uid=page.user.uid,created=node.time_now,
changed=node.time_now, title=node.title, type=node_type,
**options)
# Do module specific insertions.
if hasattr(mod[node_type], 'node_insert'):
mod[node_type].node_insert(node)
web.redirect('/node/'+str(node.nid))
content = '<form method="post" name="new_node">'
content += form.render()
content += '<input type="submit" /></form>'
web.render('generic.html')
def new_user(name, password, email):
pw = md5.new(password).hexdigest()
now = int(time.time())
return web.insert('users', name=name, password=pw, email=email,
created=now, init=email)
def POST(self, id):
f = commentform()
if not f.validates():
web.seeother('/thread/%s/archive/' % id)
else:
cid = web.insert('archive_comments', thread_id=id, author_id=f.d.author_id, message=f.d.comment)
web.seeother('/thread/%s/archive/' % id)
def project_insert(project, user):
return web.insert("locations",
lat=project.lat, #!!!
lon=project.lon, #!!!
title=project.title,
user_id=user.id,
origin=project.origin,
type='project',
url=project.url)
def trigger_insert(trigger, project, user):
return web.insert("triggers",
trigger_condition=trigger.trigger_condition,
trigger_action=trigger.trigger_action,
adapter=trigger.adapter,
url=trigger.url,
description=trigger.description,
user_id=user.id,
project_id=project.id,
)
def comment_insert(comment, point, user):
if comment.get("text", ""):
return web.insert("notes",
text=comment.text,
location_id=point.id,
user_id=user.id,
origin=comment.origin,
ranking=0,
type=comment.type,
)
def project_insert(project, user):
return web.insert(
"locations",
lat=project.lat, #!!!
lon=project.lon, #!!!
title=project.title,
user_id=user.id,
origin=project.origin,
type='project',
url=project.url)
def comment_insert(comment, point, user):
if comment.get("text", ""):
return web.insert(
"notes",
text=comment.text,
location_id=point.id,
user_id=user.id,
origin=comment.origin,
ranking=0,
type=comment.type,
)
def insert(self, _test=False):
""" Insert current row as a new row into the database.
>>> u = UserTest(username='******', hash='asdf')
>>> print u.insert(_test=True)
INSERT INTO users (username, hash) VALUES ('bob', 'asdf')
"""
changed = self._changed_values()
if self._primary_key in changed:
del changed[self._primary_key]
return web.insert(self._table, _test=_test, **changed)
def point_insert(point, user, times=[]):
return web.insert("locations",
lat=point.lat,
lon=point.lon,
title=point.title,
user_id=user.id,
origin=point.origin,
url=point.url,
visible=point.visible,
# added=datetime.datetime.utcnow(), #!!!
uuid=point.get("uuid", ''))
def trigger_insert(trigger, project, user):
return web.insert(
"triggers",
trigger_condition=trigger.trigger_condition,
trigger_action=trigger.trigger_action,
adapter=trigger.adapter,
url=trigger.url,
description=trigger.description,
user_id=user.id,
project_id=project.id,
)
def POST(self, providerName, id):
lid = scrappers[providerName].local(id)
i = web.input()
username = usernameProvider.get()
web.transact()
n = web.insert('places_forum', idPlace=lid, owner=username,
description=i.description)
web.query(self.SQL_ACTION % (web.db.sqlquote(username),
web.db.sqlquote('agrego un comentario a %s-%s' % (providerName,id))));
web.commit()
web.seeother('../')
def point_insert(point, user, times=[]):
return web.insert(
"locations",
lat=point.lat,
lon=point.lon,
title=point.title,
user_id=user.id,
origin=point.origin,
url=point.url,
visible=point.visible,
# added=datetime.datetime.utcnow(), #!!!
uuid=point.get("uuid", ''))
def testRollback(self):
web.transact()
web.insert('person', False, name='user1')
web.insert('person', False, name='user2')
web.insert('person', False, name='user3')
web.rollback()
self.assertRows(0)
def testRollback(self):
web.transact()
web.insert('person', False, name='user1')
web.insert('person', False, name='user2')
web.insert('person', False, name='user3')
web.rollback()
self.assertRows(0)
def multiple_insert(tablename, values, seqname=None, _test=False):
# multiple inserts are supported only in version 8.2+
if get_postgres_version() < (8, 2):
result = [web.insert(tablename, seqname=seqname, **v) for v in values]
if seqname:
return result
else:
return None
if not values:
return []
keys = list(values[0])
#@@ make sure all keys are valid
# make sure all rows have same keys.
for v in values:
if list(v) != keys:
raise Exception('Bad data')
q = web.SQLQuery('INSERT INTO %s (%s) VALUES ' %
(tablename, ', '.join(keys)))
data = []
for row in values:
d = join([web.SQLQuery(web.aparam(), [row[k]]) for k in keys], ', ')
data.append('(' + d + ')')
q += join(data, ',')
if seqname is not False:
if seqname is None:
seqname = tablename + "_id_seq"
q += "; SELECT currval('%s')" % seqname
if _test:
return q
db_cursor = web.ctx.db_cursor()
web.ctx.db_execute(db_cursor, q)
try:
out = db_cursor.fetchone()[0]
out = list(range(out - len(values) + 1, out + 1))
except Exception:
out = None
if not web.ctx.db_transaction:
web.ctx.db.commit()
return out
def multiple_insert(tablename, values, seqname=None, _test=False):
# multiple inserts are supported only in version 8.2+
if get_postgres_version() < (8, 2):
result = [web.insert(tablename, seqname=seqname, **v) for v in values]
if seqname:
return result
else:
return None
if not values:
return []
keys = values[0].keys()
#@@ make sure all keys are valid
# make sure all rows have same keys.
for v in values:
if v.keys() != keys:
raise Exception, 'Bad data'
q = web.SQLQuery('INSERT INTO %s (%s) VALUES ' % (tablename, ', '.join(keys)))
data = []
for row in values:
d = join([web.SQLQuery(web.aparam(), [row[k]]) for k in keys], ', ')
data.append('(' + d + ')')
q += join(data, ',')
if seqname is not False:
if seqname is None:
seqname = tablename + "_id_seq"
q += "; SELECT currval('%s')" % seqname
if _test:
return q
db_cursor = web.ctx.db_cursor()
web.ctx.db_execute(db_cursor, q)
try:
out = db_cursor.fetchone()[0]
out = range(out-len(values)+1, out+1)
except Exception:
out = None
if not web.ctx.db_transaction: web.ctx.db.commit()
return out
def persist(self, obj):
if obj._pm_state_ in [ 'persisted', 'proxy' ]: return
self._persist_one_relation(obj)
_pm_var_ = {}
#with web.transaction():
if obj._pm_state_ == 'New':
self._run_fixture(obj, 'save')
for f in obj._pm_fields_:
_pm_var_[f[0]] = getattr(obj, f[0])
del _pm_var_[obj._pm_id_column_]
self.syslog.debug("insert:" + web.insert(obj._pm_db_table_, _test=True, **_pm_var_))
new_id = web.insert(obj._pm_db_table_, **_pm_var_)
setattr(obj, obj._pm_id_column_, new_id)
obj._pm_updated_field_ = set()
#??
obj._pm_state_ = 'persisted'
self._persist_list_relation(obj)
elif obj._pm_updated_field_:
self._run_fixture(obj, 'update')
for f in obj._pm_updated_field_:
_pm_var_[f] = getattr(obj, f)
sql = web.update(obj._pm_db_table_,
where="%s = $id" % obj._pm_id_column_,
vars={'id':getattr(obj, obj._pm_id_column_)},
_test=True,
**_pm_var_)
self.syslog.debug("update:" + sql)
web.update(obj._pm_db_table_,
where="%s = $id" % obj._pm_id_column_,
vars={'id':getattr(obj, obj._pm_id_column_)},
**_pm_var_)
obj._pm_state_ = 'persisted'
def testCommit(self):
web.transact()
web.insert('person', False, name='user1')
web.commit()
web.transact()
web.insert('person', False, name='user2')
web.insert('person', False, name='user3')
web.commit()
self.assertRows(3)
def testCommit(self):
web.transact()
web.insert('person', False, name='user1')
web.commit()
web.transact()
web.insert('person', False, name='user2')
web.insert('person', False, name='user3')
web.commit()
self.assertRows(3)
def archive(self):
"""docstring for archive"""
if self['resolved'] == 'True': return
messages = self.getmessages()
# TODO instead of hardcoding the html elements in, make use of some kind of template so it can be reformatted easier
s = "<div id=\"chat_archive\">"
t = string.Template('<div id="message_$id" class="line"><span class="author">$author</span><span id="message">$message</span></div>')
for m in messages:
s += t.substitute({'id': m.id, 'author': self._getauthor(m.author_id).name, 'message': m.content})
s += "</div>"
aid = web.insert('thread_archives', thread_id=self['id'], content=s)
self['resolved'] = 'True'
return aid
def testNestedTransactions(self):
web.transact()
web.insert('person', False, name='user1')
self.assertRows(1)
web.transact()
web.insert('person', False, name='user2')
self.assertRows(2)
web.rollback()
self.assertRows(1)
web.transact()
web.insert('person', False, name='user3')
web.commit()
self.assertRows(2)
web.commit()
def testNestedTransactions(self):
web.transact()
web.insert('person', False, name='user1')
self.assertRows(1)
web.transact()
web.insert('person', False, name='user2')
self.assertRows(2)
web.rollback()
self.assertRows(1)
web.transact()
web.insert('person', False, name='user3')
web.commit()
self.assertRows(2)
web.commit()
def POST(self, comparison_name):
"""create or update a location data"""
i = web.input()
if i.gmapurl:
#gmap urls sometime contains a sll parameter
finder = '&ll='
if i.gmapurl.find(finder) == -1:
finder = '?ll='
if i.gmapurl.find(finder) == -1:
print('could not find ll parameter in map url')
#interrupting execution
return
web.debug(i.gmapurl)
web.debug(finder)
web.debug(i.gmapurl.find(finder))
if finder:
ll = i.gmapurl[i.gmapurl.find(finder)+4:i.gmapurl.find('&', i.gmapurl.find(finder)+1)].split(',')
longitude = ll[0]
latitude = ll[1]
mapurl = i.gmapurl
else:
longitude = i.longitude
latitude = i.latitude
mapurl = None
if i.location_id:
#updating/replacing
web.query("update locations set longitude = %s, latitude = %s, originalmapurl = '%s' where id = %s" % (longitude, latitude, mapurl, i.location_id))
else:
#creating
location_id= web.insert('locations', comparison_name=comparison_name, longitude=longitude, latitude=latitude, originalmapurl=mapurl)
if not location_id:
raise Exception('Error when creating location for '% comparison_name)
db.add_new_location(location_id, comparison_name)
web.seeother('/admin/locations/nomap')
return
extra = dict((f, rec[f][0]) for f in ('title', 'lccn', 'call_number') if f in rec)
rec_id = web.insert('rec', marc_file = file_id, pos=pos, len=length, **extra)
for f in (f for f in ('isbn', 'oclc') if f in rec):
for v in rec[f]:
web.insert(f, seqname=False, rec=rec_id, value=v)
t_prev = time()
rec_no = 0
chunk = 1000
total = 32856039
for ia, name in sources():
print ia, name
for part, size in files(ia):
file_id = web.insert('files', ia=ia, part=part)
print part, size
full_part = ia + "/" + part
filename = rc['marc_path'] + full_part
if not os.path.exists(filename):
continue
pos = 0
for data, length in read_file(open(filename)):
pos += length
rec_no +=1
if rec_no % chunk == 0:
t = time() - t_prev
progress_update(rec_no, t)
t_prev = time()
process_record(file_id, pos, length, data)
def POST(self):
i = web.input()
web.debug(type(i.tags))
n = web.insert("bookmarks", title=i.title, url=i.url, tags=i.tags)
web.seeother("./#t" + str(n))
def rollback(value):
web.transact()
web.insert("test", seqname=False, value=value)
web.rollback()
def commit(value):
web.transact()
web.insert("test", seqname=False, value=value)
web.commit()
(f, rec[f][0]) for f in ('title', 'lccn', 'call_number') if f in rec)
rec_id = web.insert('rec', marc_file=file_id, pos=pos, len=length, **extra)
for f in (f for f in ('isbn', 'oclc') if f in rec):
for v in rec[f]:
web.insert(f, seqname=False, rec=rec_id, value=v)
t_prev = time()
rec_no = 0
chunk = 1000
total = 32856039
for ia, name in sources():
print(ia, name)
for part, size in files(ia):
file_id = web.insert('files', ia=ia, part=part)
print(part, size)
full_part = ia + "/" + part
filename = rc['marc_path'] + full_part
if not os.path.exists(filename):
continue
pos = 0
for data, length in read_file(open(filename)):
pos += length
rec_no += 1
if rec_no % chunk == 0:
t = time() - t_prev
progress_update(rec_no, t)
t_prev = time()
process_record(file_id, pos, length, data)
def new(roomid, authorid, summary, question):
id = web.insert('threads', room_id=roomid, summary=summary, question=question)
newmessage(id, authorid, question)
return id
def newmessage(thread, authorid, message):
web.insert('messages', author_id=authorid, content=message, thread_id=thread)
