class Dao:
def __init__(self, dbname):
self.db = Base(dbname).open()
self.db.set_string_format(unicode, 'utf-8')
def regist_admin(self, data):
return self.db.insert(
generation = data.get('generation'),
dept = data.get('dept'),
name_sei = data.get('name_sei'),
name_mei = data.get('name_mei'),
mail = data.get('mail'),
account = data.get('account'),
passwd = data.get('crypt_passwd'),
add_dt = datetime.now()
)
def get_admins(self):
result = self.db.select()
return result
def close(self):
self.db.close()
def __del__(self):
self.db.close()
class RepDB:
def __init__(self, path):
self.path = path
self.dbh_stored_blocks = Base(self.path)
try:
self.dbh_stored_blocks.create(('key', str), ('version', str))
except IOError:
pass
def open(self):
self.dbh_stored_blocks.open()
def add(self, oid, block_id, version):
key = str((oid, block_id))
# lets see if we already have a key stored
set = self.dbh_stored_blocks.select_for_update(['key', 'version'],
key=key)
if set == []:
self.dbh_stored_blocks.insert(key, str(version))
else:
set[0].update()
def get(self, oid, block_id):
key = str((oid, block_id))
result = self.dbh_stored_blocks.select(['key', 'version'], key=key)
return result[0].version
def update(self, oid, block_id, version):
self.add(oid, block_id, version)
def delete(self, oid, block_id):
key = str((oid, block_id))
set = self.dbh_stored_blocks.select_for_update(['key', 'version'],
key=key)
self.dbh_stored_blocks.delete(set[0])
def close(self):
self.dbh_stored_blocks.close()
def getIterator(self):
return RepDBIterator([record for record in self.dbh_stored_blocks])
class RepDB:
def __init__(self, path):
self.path = path
self.dbh_stored_blocks = Base(self.path)
try:
self.dbh_stored_blocks.create(('key', str), ('version', str))
except IOError:
pass
def open(self):
self.dbh_stored_blocks.open()
def add(self, oid, block_id, version):
key = str((oid, block_id))
# lets see if we already have a key stored
set = self.dbh_stored_blocks.select_for_update(['key','version'],key=key)
if set == []:
self.dbh_stored_blocks.insert(key, str(version))
else:
set[0].update()
def get(self, oid, block_id):
key = str((oid, block_id))
result = self.dbh_stored_blocks.select(['key','version'],key=key)
return result[0].version
def update(self, oid, block_id, version):
self.add(oid, block_id, version)
def delete(self, oid, block_id):
key = str((oid, block_id))
set = self.dbh_stored_blocks.select_for_update(['key','version'],key=key)
self.dbh_stored_blocks.delete(set[0])
def close(self):
self.dbh_stored_blocks.close()
def getIterator(self):
return RepDBIterator([record for record in self.dbh_stored_blocks])
class DB:
def __init__(self, storage_path):
self.dbh_objects = Base(os.path.join(storage_path, 'objects'))
self.dbh_blocks = Base(os.path.join(storage_path, 'blocks'))
self.dbh_replicas = Base(os.path.join(storage_path, 'replicas'))
self.dbh_tree = Base(os.path.join(storage_path, 'tree'))
self.dbh_paths = Base(os.path.join(storage_path, 'paths'))
self.dbh_id = Base(os.path.join(storage_path, 'id'))
self.dbh_tags = Base(os.path.join(storage_path, 'tags'))
self.storage_path = storage_path
def __create_root(self):
""" Check if the filesystem has a / and if not create it"""
print "Initializing filesystem..."
if self.get_file(path='/'):
return
print "Creating root..."
f = FSObject(1,1,'/',0,0,0,0)
# lets see if we already have a key stored
set = self.dbh_objects.select(['oid'],oid=str(f.oid))
if set == []:
# we have create tree and paths first
self.dbh_tree.insert(str(f.oid), str(f.parent))
self.dbh_paths.insert(str((f.parent, f.path)))
self.dbh_objects.insert(str(f.oid), dumps(f), self.dbh_tree[len(self.dbh_tree)-1], self.dbh_paths[len(self.dbh_paths)-1])
#set the current oid for the id increment sequence
set = self.dbh_id.select(['curr_oid'])
if set == []:
self.dbh_id.insert('1')
def setup_fs_db(self):
try:
self.dbh_blocks.create(('key', str), ('blocks', str))
except IOError:
self.dbh_blocks.open()
try:
self.dbh_replicas.create(('key', str), ('replicas', str))
except IOError:
self.dbh_replicas.open()
try:
self.dbh_tree.create(('oid', str), ('parent', str))
except IOError:
self.dbh_tree.open()
try:
self.dbh_tags.create(('oid', str), ('tag', str))
except IOError:
self.dbh_tags.open()
try:
self.dbh_paths.create(('key', str))
except IOError:
self.dbh_paths.open()
try:
self.dbh_id.create(('curr_oid', str))
except IOError:
self.dbh_id.open()
try:
self.dbh_objects.create(('oid', str), ('fsobj', str), ('tree', self.dbh_tree), ('paths', self.dbh_paths))
except IOError:
self.dbh_objects.open()
self.__create_root()
def get_path_oid(self, path):
"""Gets the parent filenode for path"""
nodes = []
parent_path = path
while 1:
(parent_path,node) = os.path.split(parent_path)
if node == '':
nodes.insert(0,'/')
break
nodes.insert(0,node)
parent_oid = 0
for node_name in nodes:
key = str((parent_oid, node_name))
print "looking up: %s" % key
# search for a match
f = None
for record in [record for record in self.dbh_objects]:
if record.paths.key == key:
f = loads(record.fsobj)
break
print "found it!"
if not f:
return 0
parent_oid = f.oid
return parent_oid
def insert_file(self, path, fsobj):
#check first if there is a parent directory to store this file
f = self.get_file(path=path)
print "inserting file with path: "+path
print fsobj
if not f:
print "ERR: [%s]" % os.path.split(fsobj.path)[0]
raise FileSystemError('No parent directory to store: %s' % fsobj.path)
#the parent of this object is the path
fsobj.parent = f.oid
set = self.dbh_id.select_for_update(['curr_oid'])
curr_oid = int(set[0].curr_oid) + 1
fsobj.oid = curr_oid
print "Inserting OID: %s" % fsobj
# lets see if we already have a key stored
result = self.dbh_objects.select(['oid','fsobj'],oid=str(fsobj.oid))
if result != []:
raise FileSystemError('File already exists')
else:
# we have create tree and paths first
self.dbh_tree.insert(str(fsobj.oid), str(fsobj.parent))
self.dbh_paths.insert(str((fsobj.parent, fsobj.path)))
self.dbh_objects.insert(str(fsobj.oid), dumps(fsobj), self.dbh_tree[len(self.dbh_tree)-1], self.dbh_paths[len(self.dbh_paths)-1])
set[0].update(curr_oid=str(curr_oid))
return curr_oid
def get_file(self, oid='', path=''):
if oid:
set = self.dbh_objects.select(['oid', 'fsobj'], oid=str(oid))
if set == []:
f = None
else:
f = set[0].fsobj
elif path:
if path == '/':
key = str((0,'/'))
else:
parent_oid = self.get_path_oid(os.path.split(path)[0])
node_name = os.path.split(path)[1]
key = str((parent_oid, node_name))
# search for a match
f = None
for record in [record for record in self.dbh_objects]:
print record.paths.key
if record.paths.key == key:
f = record.fsobj
break
else:
f = None
if f:
f = loads(f)
return f
def get_children(self, oid):
# lookup FSOBJECT with given oid
set = self.dbh_objects.select(['oid', 'fsobj'], oid=str(oid))
if set == []:
return []
file_array = []
# lookup objects with parent oid
set = self.dbh_tree.select(['oid', 'parent'], parent=str(oid))
for i in set:
obj = self.dbh_objects.select(['oid', 'fsobj'], oid=str(i.oid))
if obj != []:
file_array.append(loads(obj[0].fsobj))
return file_array
def debug_print_db(self, db):
pass
def print_object_db(self):
self.debug_print_db(self.dbh_objects)
def delete_dir(self,oid):
pass
def delete_file(self, oid):
pass
def rename_file(self,src,dest):
pass
def update_file(self, fsobj):
set = self.dbh_objects.select_for_update(['oid', 'fsobj'], oid=str(fsobj.oid))
if set != []:
set[0].update(fsobj=dumps(fsobj))
def add_block(self, block, serverid):
f = self.get_file(oid=str(block.oid))
if not f:
raise FileSystemError('add_block: Object %s does not exist' % block.oid)
key = str((long(block.oid),long(block.block_id))) #the key is both the oid and the block_id
set1 = self.dbh_replicas.select_for_update(['key', 'replicas'], key=key)
if set1 == []:
replicas = FSReplicas(block.oid, block.block_id)
else:
replicas = loads(set1[0].replicas)
f.blocks[block.block_id] = block.version
set2 = self.dbh_blocks.select_for_update(['key', 'blocks'], key=key)
if set2 == []:
b = None
else:
b = set2[0].block
if b:
b = loads(b)
diff = block.size - b.size
else:
diff = block.size
f.size += diff
# update or insert?
if set1 == []:
self.dbh_blocks.insert(key, dumps(block))
else:
set1[0].update(blocks=dumps(block))
self.update_file(f)
replicas.add(serverid, block.version)
# update or insert?
if set2 == []:
self.dbh_replicas.insert(key,dumps(replicas))
else:
set2[0].update(replicas=dumps(replicas))
def add_block_replica(self, block, serverid):
f = self.get_file(str(block.oid))
if not f:
raise FileSystemError('add_block_replica: Object %s does not exist' % block.oid)
key = str((block.oid, block.block_id))
set = self.dbh_replicas.select_for_update(['key', 'replicas'], key=key)
if set == []:
replicas = FSReplicas(block.oid, block.block_id)
else:
replicas = loads(set[0].replicas)
replicas.add(serverid, block.version)
# update or insert?
if set == []:
self.dbh_replicas.insert(key,dumps(replicas))
else:
set[0].update(replicas=dumps(replicas))
def get_block_replicas(self, oid, block_id):
key = str((long(oid), long(block_id)))
set = self.dbh_replicas.select(['key', 'replicas'], key=key)
if set == []:
return None
return loads(set[0].replicas)
def get_block(self, oid, block_id):
key = str((long(oid), long(block_id)))
set = self.dbh_blocks.select(['key', 'blocks'], key=key)
if set == []:
return None
return loads(set[0].blocks)
def print_replicas_db(self):
self.debug_print_db(self.dbh_replicas)
def close_fs_db(self):
self.dbh_blocks.close()
self.dbh_replicas.close()
self.dbh_tree.close()
self.dbh_id.close()
self.dbh_paths.close()
self.dbh_objects.close()
imagesDB.update(record,url=str(child['src']))
break
tag = img_soup.find(text=re.compile("all users"))
record.update(score=float(tag.next_element))
img_url = record.url
img_req = Request(img_url)
ext=os.path.splitext(img_url)[1]
try:
f = urlopen(img_req)
imgFile='%0*d' % (6,record.__id__)
imgFile=os.getcwd()+"\\Images\\training\\" + imgFile + ext
local_file = open(imgFile,"wb")
local_file.write(f.read())
local_file.close()
record.update(fileloc=imgFile)
except HTTPError, e:
print "HTTP Error:",e.code , url
except URLError, e:
print "URL Error:",e.reason , url
##records = imagesDB().sort_by("+__id__")
except:
pass
for rec in imagesDB().sort_by("+__id__"):
print rec
imagesDB.close()
print "Done"
#this is a commandline utility to quickly get book text for testing purposes
from buzhug import Base
import os
import sys
import json
db = Base(os.getcwd() + '/db/bookDB')
db.open()
c=0
l = len(sys.argv)
while c < l-1:
c+=1
inp = sys.argv[c]
dupProtect = True
bookID = int(inp)
records = db.select(ID = bookID)
bookText = ''
slug = ''
for r in records:
j = json.loads(r.json)
if j.get('ID') == bookID:
text = j.get('pages')
for p in text:
bookText += p['text'] + '\n'
slug = r.slug
if dupProtect:
break
print bookText
db.close()
class DB:
def __init__(self, storage_path):
self.dbh_objects = Base(os.path.join(storage_path, 'objects'))
self.dbh_blocks = Base(os.path.join(storage_path, 'blocks'))
self.dbh_replicas = Base(os.path.join(storage_path, 'replicas'))
self.dbh_tree = Base(os.path.join(storage_path, 'tree'))
self.dbh_paths = Base(os.path.join(storage_path, 'paths'))
self.dbh_id = Base(os.path.join(storage_path, 'id'))
self.dbh_tags = Base(os.path.join(storage_path, 'tags'))
self.storage_path = storage_path
def __create_root(self):
""" Check if the filesystem has a / and if not create it"""
print "Initializing filesystem..."
if self.get_file(path='/'):
return
print "Creating root..."
f = FSObject(1, 1, '/', 0, 0, 0, 0)
# lets see if we already have a key stored
set = self.dbh_objects.select(['oid'], oid=str(f.oid))
if set == []:
# we have create tree and paths first
self.dbh_tree.insert(str(f.oid), str(f.parent))
self.dbh_paths.insert(str((f.parent, f.path)))
self.dbh_objects.insert(str(f.oid), dumps(f),
self.dbh_tree[len(self.dbh_tree) - 1],
self.dbh_paths[len(self.dbh_paths) - 1])
#set the current oid for the id increment sequence
set = self.dbh_id.select(['curr_oid'])
if set == []:
self.dbh_id.insert('1')
def setup_fs_db(self):
try:
self.dbh_blocks.create(('key', str), ('blocks', str))
except IOError:
self.dbh_blocks.open()
try:
self.dbh_replicas.create(('key', str), ('replicas', str))
except IOError:
self.dbh_replicas.open()
try:
self.dbh_tree.create(('oid', str), ('parent', str))
except IOError:
self.dbh_tree.open()
try:
self.dbh_tags.create(('oid', str), ('tag', str))
except IOError:
self.dbh_tags.open()
try:
self.dbh_paths.create(('key', str))
except IOError:
self.dbh_paths.open()
try:
self.dbh_id.create(('curr_oid', str))
except IOError:
self.dbh_id.open()
try:
self.dbh_objects.create(('oid', str), ('fsobj', str),
('tree', self.dbh_tree),
('paths', self.dbh_paths))
except IOError:
self.dbh_objects.open()
self.__create_root()
def get_path_oid(self, path):
"""Gets the parent filenode for path"""
nodes = []
parent_path = path
while 1:
(parent_path, node) = os.path.split(parent_path)
if node == '':
nodes.insert(0, '/')
break
nodes.insert(0, node)
parent_oid = 0
for node_name in nodes:
key = str((parent_oid, node_name))
print "looking up: %s" % key
# search for a match
f = None
for record in [record for record in self.dbh_objects]:
if record.paths.key == key:
f = loads(record.fsobj)
break
print "found it!"
if not f:
return 0
parent_oid = f.oid
return parent_oid
def insert_file(self, path, fsobj):
#check first if there is a parent directory to store this file
f = self.get_file(path=path)
print "inserting file with path: " + path
print fsobj
if not f:
print "ERR: [%s]" % os.path.split(fsobj.path)[0]
raise FileSystemError('No parent directory to store: %s' %
fsobj.path)
#the parent of this object is the path
fsobj.parent = f.oid
set = self.dbh_id.select_for_update(['curr_oid'])
curr_oid = int(set[0].curr_oid) + 1
fsobj.oid = curr_oid
print "Inserting OID: %s" % fsobj
# lets see if we already have a key stored
result = self.dbh_objects.select(['oid', 'fsobj'], oid=str(fsobj.oid))
if result != []:
raise FileSystemError('File already exists')
else:
# we have create tree and paths first
self.dbh_tree.insert(str(fsobj.oid), str(fsobj.parent))
self.dbh_paths.insert(str((fsobj.parent, fsobj.path)))
self.dbh_objects.insert(str(fsobj.oid), dumps(fsobj),
self.dbh_tree[len(self.dbh_tree) - 1],
self.dbh_paths[len(self.dbh_paths) - 1])
set[0].update(curr_oid=str(curr_oid))
return curr_oid
def get_file(self, oid='', path=''):
if oid:
set = self.dbh_objects.select(['oid', 'fsobj'], oid=str(oid))
if set == []:
f = None
else:
f = set[0].fsobj
elif path:
if path == '/':
key = str((0, '/'))
else:
parent_oid = self.get_path_oid(os.path.split(path)[0])
node_name = os.path.split(path)[1]
key = str((parent_oid, node_name))
# search for a match
f = None
for record in [record for record in self.dbh_objects]:
print record.paths.key
if record.paths.key == key:
f = record.fsobj
break
else:
f = None
if f:
f = loads(f)
return f
def get_children(self, oid):
# lookup FSOBJECT with given oid
set = self.dbh_objects.select(['oid', 'fsobj'], oid=str(oid))
if set == []:
return []
file_array = []
# lookup objects with parent oid
set = self.dbh_tree.select(['oid', 'parent'], parent=str(oid))
for i in set:
obj = self.dbh_objects.select(['oid', 'fsobj'], oid=str(i.oid))
if obj != []:
file_array.append(loads(obj[0].fsobj))
return file_array
def debug_print_db(self, db):
pass
def print_object_db(self):
self.debug_print_db(self.dbh_objects)
def delete_dir(self, oid):
pass
def delete_file(self, oid):
pass
def rename_file(self, src, dest):
pass
def update_file(self, fsobj):
set = self.dbh_objects.select_for_update(['oid', 'fsobj'],
oid=str(fsobj.oid))
if set != []:
set[0].update(fsobj=dumps(fsobj))
def add_block(self, block, serverid):
f = self.get_file(oid=str(block.oid))
if not f:
raise FileSystemError('add_block: Object %s does not exist' %
block.oid)
key = str(
(long(block.oid),
long(block.block_id))) #the key is both the oid and the block_id
set1 = self.dbh_replicas.select_for_update(['key', 'replicas'],
key=key)
if set1 == []:
replicas = FSReplicas(block.oid, block.block_id)
else:
replicas = loads(set1[0].replicas)
f.blocks[block.block_id] = block.version
set2 = self.dbh_blocks.select_for_update(['key', 'blocks'], key=key)
if set2 == []:
b = None
else:
b = set2[0].block
if b:
b = loads(b)
diff = block.size - b.size
else:
diff = block.size
f.size += diff
# update or insert?
if set1 == []:
self.dbh_blocks.insert(key, dumps(block))
else:
set1[0].update(blocks=dumps(block))
self.update_file(f)
replicas.add(serverid, block.version)
# update or insert?
if set2 == []:
self.dbh_replicas.insert(key, dumps(replicas))
else:
set2[0].update(replicas=dumps(replicas))
def add_block_replica(self, block, serverid):
f = self.get_file(str(block.oid))
if not f:
raise FileSystemError(
'add_block_replica: Object %s does not exist' % block.oid)
key = str((block.oid, block.block_id))
set = self.dbh_replicas.select_for_update(['key', 'replicas'], key=key)
if set == []:
replicas = FSReplicas(block.oid, block.block_id)
else:
replicas = loads(set[0].replicas)
replicas.add(serverid, block.version)
# update or insert?
if set == []:
self.dbh_replicas.insert(key, dumps(replicas))
else:
set[0].update(replicas=dumps(replicas))
def get_block_replicas(self, oid, block_id):
key = str((long(oid), long(block_id)))
set = self.dbh_replicas.select(['key', 'replicas'], key=key)
if set == []:
return None
return loads(set[0].replicas)
def get_block(self, oid, block_id):
key = str((long(oid), long(block_id)))
set = self.dbh_blocks.select(['key', 'blocks'], key=key)
if set == []:
return None
return loads(set[0].blocks)
def print_replicas_db(self):
self.debug_print_db(self.dbh_replicas)
def close_fs_db(self):
self.dbh_blocks.close()
self.dbh_replicas.close()
self.dbh_tree.close()
self.dbh_id.close()
self.dbh_paths.close()
self.dbh_objects.close()
for record in (record for record in db):
print(time.strftime("%a, %d %b %Y %H:%M:%S ", time.localtime(record.time)),
record.__id__, str(record.url), record.q, record.a, str(record.cmd))
# ('Sat, 01 Jan 2011 02:44:13 ', 31, 'cases.txt', 0, None, 'None')
print(' time __id__ url q a cmd')
raise SystemExit
# insert recrod
record_id = db.insert(localtime=time.time(),
filename='test',
question=0,
answer=1)
record_id = db.insert(localtime=time.time(),
filename='test',
question=1,
answer=2)
# Close database
db.close()
# Get list of questions touched
[record.question for record in records]
# Get list of answers touched
[(record.question, record.answer) for record in records]
# Create database
db = Base(path)
db.create(('localTime', float), ('fileName', string), ('question', int),
('answer', int))
class TransactionsDB(object):
BASE = 'banan/transactions'
def __init__(self, conf):
self.config = conf
self._sessions = {}
self.open()
# Management
def open(self):
self.db = Base(TransactionsDB.BASE)
try:
self.db.open()
except IOError:
self.db.create(('amount' , float),
('amount_local', float),
('date' , date),
('account' , str),
('label' , str),
('currency' , str))
def close(self):
self.db.close()
def clearall(self):
self.db.destroy()
self.open()
def insert(self, entry):
self.db.insert(amount = entry['amount'],
amount_local = entry['amount_local'],
date = entry['date'],
account = entry['account'],
label = entry['label'],
currency = entry['currency'])
def feed(self, fpath, parser, skip_duplicates=True, overwrite=False, delete=False, dry_run=False):
deleted = added = 0
for entry in parser.parse(fpath):
if dry_run:
print('%s %-40s\t%12.2f %s' % (entry['date'].isoformat(),
entry['account'][:40],
entry['amount'],
entry['currency'])); continue
if skip_duplicates or overwrite or delete:
_dup = self.db(date=entry['date'], account=entry['account'], amount=entry['amount'])
if _dup:
if overwrite or delete:
deleted += len(_dup)
self.db.delete(_dup)
else:
continue
if delete:
continue
entry['label'] = self.config.assign_label(entry)
self.insert(entry)
added += 1
if not dry_run:
INFO(' added %i transactions' % added)
INFO(' deleted %i transactions' % deleted)
parser.post_process(self.db, added)
def update_labels(self):
# Load all records into memory. File will get corrupt if using the iterator.
records = [rec for rec in self.db]
for record in records:
as_dict = dict((field, getattr(record, field)) for field in record.fields)
label = self.config.assign_label(as_dict)
if label != record.label:
self.db.update(record, label=label)
self.db.cleanup()
# Queries
get_amount = lambda rec: rec.amount_local
def results_as_text(self, results):
results.sort_by('date')
idx = 0
record = results[idx]
text_list = []
while True:
text_list.append('%s %-40s\t%12.2f %s' %
(record.date.isoformat(),
unicode(record.account[:40], 'utf-8'),
record.amount,
record.currency));
try:
idx += 1
record = results[idx]
except IndexError:
return text_list
def assemble_data(self, sid, datatype, foreach, show, select):
try:
session = self._sessions.get(sid, {})
if session:
if session['raw_query'] == (foreach, show, select):
# Same query, return cached result
return True, \
self._sessions[sid]['flot_' + show] if datatype == 'plot' else \
self._sessions[sid]['text']
# Helpers
get_amount = lambda rec: rec.amount_local
M = range(1,13)
total = strlen = 0
data = {}
text = {}
query = 'date1 <= date < date2 and label == l'
if foreach == 'label':
if session:
if session['raw_query'][0] == 'label' and session['raw_query'][2] == select:
# Same query, but different presentation (sum or average)
return True, \
self._sessions[sid]['flot_' + show] if datatype == 'plot' else \
self._sessions[sid]['text']
# New query
dates = re.findall('[0-9]{6}', unquote_plus(select))
date1 = date2 = date(int(dates[0][2:]), int(dates[0][:2]), 1)
if len(dates) == 2:
date2 = date(int(dates[1][2:]), int(dates[1][:2]), 1)
date2 = date(date2.year + (date2.month == 12), M[date2.month - 12], 1)
for label in self.config.labels.iterkeys():
results = self.db.select(None, query, l = label, date1 = date1, date2 = date2)
value = sum(map(get_amount, results))
if abs(value) > 1:
data[label] = value
if label not in self.config.cash_flow_ignore:
total += value
else:
label += '*'
text[label] = self.results_as_text(results)
strlen = len(text[label][-1])
sumstr = '%12.2f %s' % (value, self.config.local_currency)
text[label].append('-' * strlen)
text[label].append(' ' * (strlen - len(sumstr)) + sumstr)
ydelta = date2.year - date1.year
mdelta = date2.month - date1.month
delta = 12 * ydelta + mdelta
session['flot_average'] = {}
for key, val in data.iteritems():
session['flot_average'][key] = val/delta
elif foreach in ('month', 'year'):
# New query
date1 = date2 = first = datetime.now()
if foreach == 'month':
first = date(date1.year - 1, date1.month, 1)
date1 = date(date1.year - (date1.month == 1), M[date1.month - 2], 1)
date2 = date(date2.year, date2.month, 1)
else:
first = date(date1.year - 9, 1, 1)
date1 = date(date1.year, 1, 1)
date2 = date(date2.year + 1, 1, 1)
select = unquote_plus(select)
while date1 >= first:
results = self.db.select(None, query, l = select, date1 = date1, date2 = date2)
value = sum(map(get_amount, results))
date2 = date1
if foreach == 'month':
key = date1.strftime('%Y.%m')
date1 = date(date2.year - (date2.month == 1), M[date2.month - 2], 1)
else:
key = str(date1.year)
date1 = date(date2.year - 1, 1, 1)
data[key] = value
total += value
if results:
text[key] = self.results_as_text(results)
strlen = len(text[key][-1])
sumstr = '%12.2f %s' % (value, self.config.local_currency)
text[key].append('-' * strlen)
text[key].append(' ' * (strlen - len(sumstr)) + sumstr)
# All good, set new session attributes
session['raw_query'] = (foreach, show, select)
session['flot_sum'] = data
session['text'] = text
if session['text']:
session['text']['***'] = ['-' * strlen,
'SUM: %12.2f %s' % (total, self.config.local_currency),
'-' * strlen]
self._sessions[sid] = session
return True, session['flot_' + show] if datatype == 'plot' else session['text']
except Exception as e:
return False, str(e)
class bookDBHandler:
def __init__(self):
self.userdir = os.getcwd()
self.bookDB = Base(self.userdir + '/db/bookDB').open()
#this selects the whole db, for now
self.resultset = self.bookDB.select()
#for loading the db in memory
self.membooks = []
def loadDBIn(self):
for r in self.resultset:
#load specific book's json from bookDB
jsonObj = json.loads(r.json)
dbID = r.__id__
script_review_status = r.script_review_status
#put all relavant info into convienient fields.
#Im sure there is a quicker way involving commas
#with Python, will look at later
status = jsonObj.get('status')
rating_count = jsonObj.get('rating_count')
#slug = jsonObj.get('slug')
#language = jsonObj.get('language')
author = jsonObj.get('author')
rating_value = jsonObj.get('rating_value')
title = jsonObj.get('title')
modified = jsonObj.get('modified')
#bust = jsonObj.get('bust')
reviewed = jsonObj.get('reviewed')
audience = jsonObj.get('audience')
tags = jsonObj.get('tags')
created = jsonObj.get('created')
link = jsonObj.get('link')
author_id = jsonObj.get('author_id')
iD = jsonObj.get('ID')
typex = jsonObj.get('type')
pages = jsonObj.get('pages')
categories = jsonObj.get('categories')
rating_total = jsonObj.get('rating_total')
slug = r.slug
text = []
#do the same for the pages
for p in pages:
text.append(p['text'])
#nice little book object
#print dbID
#break
elBook = book(dbID, status, rating_count,
author, rating_value, title, modified,
reviewed, audience, tags, created, link,
author_id, iD, typex, pages, categories,
rating_total, text, script_review_status, slug)
self.membooks.append(elBook)
def saveDB(self):
#for now the only thing that
#should be saved is the script_reviewed_status
for b in self.membooks:
self.resultset[b.dbID].script_review_status = b.script_review_status
def closeDB(self):
self.bookDB.cleanup()
self.bookDB.close()
