def create_dependency(self, name, dep_id, rev_id=-1):
"""
Add a new dependency
"""
dep_id = int(dep_id)
try:
dep = DBSession.query(GameDepPage).filter_by(gamedeptype="dep",
id=dep_id).one()
if rev_id != -1:
rev = DBSession.query(GameDepRevision).filter_by(
id=rev_id).one()
else:
if dep.revisions.count() > 0:
rev = dep.revisions[0]
else:
raise GameDepNotFound
if not rev in dep.revisions:
raise GameDepNotFound
except NoResultFound:
raise GameDepNotFound
page = self.show(name, no_revision_error=False)[0]
for pagedep in page.dependencies:
if pagedep.page.id == dep.id:
raise GameDepFound
page.dependencies.append(rev)
def update_binary(self, name, revision, binary_id, operatingsystem,
architecture, binary, request):
"""
Update a binary
"""
try:
if not binary:
os_obj = DBSession.query(OperatingSystems).filter_by(
id=operatingsystem).one()
arch_obj = DBSession.query(Architectures).filter_by(
id=architecture).one()
except NoResultFound:
raise GameDepNotFound
rev = self.show(name, revision)[1]
bin_obj = None
for x in rev.binary:
if x.id == int(binary_id):
bin_obj = x
break
if not bin_obj:
raise GameDepNotFound
if not binary:
bin_obj.operatingsystem_obj = os_obj
bin_obj.architecture_obj = arch_obj
else:
file_lib = FileLib(request)
old_name = bin_obj.file_obj.name
old_mimetype = bin_obj.file_obj.mimetype
aio_obj = file_lib.write(old_name, binary, old_mimetype)
file_lib.delete(bin_obj.file_obj)
bin_obj.file_obj = aio_obj
def delete_dependency(self, name, dep_id):
"""
Delete a dependency
"""
dep_id = int(dep_id)
page = self.show(name)[0]
item = self.show_dependency(page, dep_id)
page.dependencies.remove(item)
DBSession.flush()
DBSession.delete(item)
def add_vote(self, db_obj, user, like):
"""
Add a vote to the database
"""
vote = BBVotes(user, like)
vote.post = db_obj
try:
DBSession.add(vote)
transaction.commit()
except IntegrityError:
transaction.abort()
raise AlreadyVoted
def add_forum(self, name, description, category):
"""
Add a forum
"""
try:
self.get_forum_by_name(name)
raise ForumFound
except ForumNotFound:
pass
forum_obj = BBForum(name, description, category)
DBSession.add(forum_obj)
DBSession.flush()
return forum_obj
def add_vote(self, db_obj, user, like):
"""
Add a vote to the database
"""
vote = GameDepVotes(user, like)
vote.game = db_obj
try:
DBSession.add(vote)
transaction.commit()
except IntegrityError:
transaction.abort()
raise AlreadyVoted
def list_architectures(self, with_display_name=True):
"""
Get a Architecture list from database.
"""
if with_display_name:
archlist = DBSession.query(Architectures.id,
Architectures.display_name).order_by(
Architectures.id).all()
archlist = [(x[0], x[1]) for x in archlist]
else:
archlist = DBSession.query(Architectures.id).order_by(
Architectures.id).all()
archlist = [x[0] for x in archlist]
return archlist
def list_operatingsystems(self, with_display_name=True):
"""
Get a Operating System list from database.
"""
if with_display_name:
oslist = DBSession.query(OperatingSystems.id,
OperatingSystems.display_name).order_by(
OperatingSystems.id).all()
oslist = [(x[0], x[1]) for x in oslist]
else:
oslist = DBSession.query(OperatingSystems.id).order_by(
OperatingSystems.id).all()
oslist = [x[0] for x in oslist]
return oslist
def delete(self, request, page):
"""
Delete a page
Raise PageNotFound if page does not exist
"""
if page.thread_id != -1:
from pyracms_forum.lib.boardlib import BoardLib
BoardLib().delete_thread(page.thread_id)
if page.album_id != -1:
from pyracms_gallery.lib.gallerylib import GalleryLib
GalleryLib().delete_album(page.album_id, request)
DBSession.delete(page)
self.s.delete_from_index(
request.route_url("article_read", page_id=page.name))
def list_operatingsystems(self, with_display_name=True):
"""
Get a Operating System list from database.
"""
if with_display_name:
oslist = DBSession.query(OperatingSystems.id,
OperatingSystems.display_name).order_by(
OperatingSystems.id).all()
oslist = [(x[0], x[1]) for x in oslist]
else:
oslist = DBSession.query(OperatingSystems.id).order_by(
OperatingSystems.id).all()
oslist = [x[0] for x in oslist]
return oslist
def update(self, request, page, article, summary, user, tags=''):
"""
Update a page
Raise PageNotFound if page does not exist
"""
if not article:
self.delete(page, user)
return
self.t.set_tags(page, tags)
revision = ArticleRevision(article, summary, user)
revision.page = page
if not page.private:
self.update_article_index(request, page, revision, user.name)
DBSession.add(revision)
def list_architectures(self, with_display_name=True):
"""
Get a Architecture list from database.
"""
if with_display_name:
archlist = DBSession.query(Architectures.id,
Architectures.display_name).order_by(
Architectures.id).all()
archlist = [(x[0], x[1]) for x in archlist]
else:
archlist = DBSession.query(Architectures.id).order_by(
Architectures.id).all()
archlist = [x[0] for x in archlist]
return archlist
def delete_binary(self, name, revision, bin_id):
"""
Delete a binary
"""
bin_id = int(bin_id)
rev = self.show(name, revision)[1]
binitem = None
for revbin in rev.binary:
if revbin.id == bin_id:
binitem = revbin
if binitem:
rev.binary.remove(binitem)
DBSession.delete(binitem)
else:
raise GameDepNotFound
def delete_binary(self, name, revision, bin_id):
"""
Delete a binary
"""
bin_id = int(bin_id)
rev = self.show(name, revision)[1]
binitem = None
for revbin in rev.binary:
if revbin.id == bin_id:
binitem = revbin
if binitem:
rev.binary.remove(binitem)
DBSession.delete(binitem)
else:
raise GameDepNotFound
def show_binary(self, binary_id):
try:
bin_obj = DBSession.query(GameDepBinary).filter_by(
id=binary_id).one()
except NoResultFound:
raise GameDepNotFound
return bin_obj
def revision_dropdown(self, dep_id, with_display_name=True):
initial_item = [("-1", "Use Latest Version")]
if with_display_name:
rev = DBSession.query(GameDepRevision.id,
GameDepRevision.version).filter_by(
page_id=dep_id, published=True)
else:
rev = DBSession.query(GameDepRevision.id).filter_by(
page_id=dep_id, published=True)
result = initial_item
result.extend(rev.all())
if with_display_name:
result = [(str(x[0]), str(x[1])) for x in result]
else:
result = [str(x[0]) for x in result]
return result
def delete(self, name, request):
"""
Delete a page
Raise GameDepNotFound if page does not exist
"""
page = self.show(name, no_revision_error=False)[0]
for item in page.revisions:
rev_id = item.id
self.delete_revision(name, rev_id, request)
if page.thread_id != -1:
from pyracms_forum.lib.boardlib import BoardLib
BoardLib().delete_thread(page.thread_id)
if page.album_id != -1:
from pyracms_gallery.lib.gallerylib import GalleryLib
GalleryLib().delete_album(page.album_id, request)
DBSession.delete(page)
def show(self, name, revision=None, no_revision_error=True):
"""
Get article of a page or revision
Raise GameDepNotFound if page does not exist
"""
if revision:
revision = int(revision)
if not name:
raise GameDepNotFound
if not revision:
try:
page = DBSession.query(GameDepPage).filter_by(
name=name,
gamedeptype=self.gamedep_type
).one()
except NoResultFound:
raise GameDepNotFound("NoResultFound")
if not page.revisions.count() and no_revision_error:
raise GameDepNotFound("no_revision_error")
return (page, page.revisions)
else:
try:
page, rev = self.show(name)
rev_result = rev.filter_by(id=revision).one()
return (page, rev_result)
except NoResultFound:
raise GameDepNotFound
def delete(self, name, request):
"""
Delete a page
Raise GameDepNotFound if page does not exist
"""
page = self.show(name, no_revision_error=False)[0]
for item in page.revisions:
rev_id = item.id
self.delete_revision(name, rev_id, request)
if page.thread_id != -1:
from pyracms_forum.lib.boardlib import BoardLib
BoardLib().delete_thread(page.thread_id)
if page.album_id != -1:
from pyracms_gallery.lib.gallerylib import GalleryLib
GalleryLib().delete_album(page.album_id, request)
DBSession.delete(page)
def switch_renderer(self, name):
page = self.show_page(name)
renderer_count = DBSession.query(ArticleRenderers).count()
if page.renderer_id == renderer_count:
page.renderer_id = 1
return
page.renderer_id += 1
def revision_dropdown(self, dep_id, with_display_name=True):
initial_item = [("-1", "Use Latest Version")]
if with_display_name:
rev = DBSession.query(GameDepRevision.id,
GameDepRevision.version).filter_by(
page_id=dep_id, published=True)
else:
rev = DBSession.query(GameDepRevision.id).filter_by(page_id=dep_id,
published=True)
result = initial_item
result.extend(rev.all())
if with_display_name:
result = [(str(x[0]), str(x[1])) for x in result]
else:
result = [str(x[0]) for x in result]
return result
def show_binary(self, binary_id):
try:
bin_obj = DBSession.query(GameDepBinary).filter_by(
id=binary_id).one()
except NoResultFound:
raise GameDepNotFound
return bin_obj
def show(self, name, revision=None, no_revision_error=True):
"""
Get article of a page or revision
Raise GameDepNotFound if page does not exist
"""
if revision:
revision = int(revision)
if not name:
raise GameDepNotFound
if not revision:
try:
page = DBSession.query(GameDepPage).filter_by(
name=name, gamedeptype=self.gamedep_type).one()
except NoResultFound:
raise GameDepNotFound("NoResultFound")
if not page.revisions.count() and no_revision_error:
raise GameDepNotFound("no_revision_error")
return (page, page.revisions)
else:
try:
page, rev = self.show(name)
rev_result = rev.filter_by(id=revision).one()
return (page, rev_result)
except NoResultFound:
raise GameDepNotFound
def main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
# Add Groups
u = UserLib()
u.create_group("forum_moderator",
"Ability to Edit " + "and Delete forum posts/threads.")
u.create_group("forum", "Ability to Add forum posts/threads.")
# Default ACL
acl = RootFactory(session=DBSession)
acl.__acl__.append((Allow, Everyone, 'forum_view'))
acl.__acl__.append((Allow, "group:admin", 'edit_board'))
acl.__acl__.append((Allow, "group:forum", "group:forum"))
acl.__acl__.append((Allow, "group:forum", 'forum_reply'))
acl.__acl__.append((Allow, "group:forum", 'forum_edit'))
acl.__acl__.append((Allow, "group:forum", 'forum_delete'))
acl.__acl__.append(
(Allow, "group:forum_moderator", "group:forum_moderator"))
acl.__acl__.append((Allow, "group:forum_moderator", 'forum_mod_edit'))
acl.__acl__.append(
(Allow, "group:forum_moderator", 'forum_mod_delete'))
# Add Menu Items
m = MenuLib()
m.add_menu_item_route("Forum", "category_list", 10,
m.show_group("main_menu"), Everyone)
group = m.show_group("admin_area")
m.add_menu_item_route("Forum Categories", "edit_forum_category", 20,
group, 'edit_menu')
m.add_menu_item_route("Edit Forums", "list_forum_category", 21, group,
'edit_menu')
# Append CSS
s = SettingsLib()
s.update("CSS", s.show_setting("CSS") + css)
s.create("INFO_FORUM_CATEGORY_UPDATED",
"The list of forum categories has been updated.")
s.create("PYRACMS_FORUM")
s.update("DEFAULTGROUPS", s.show_setting("DEFAULTGROUPS") + "forum\n")
def list(self): #@ReservedAssignment
"""
List all the pages
"""
pages = DBSession.query(ArticlePage)
if not pages:
raise PageNotFound
return [(page.name, page.display_name or page.name) for page in pages]
def get_post(self, postid):
"""
Get a bulletin board post database object
"""
try:
return DBSession.query(BBPost).filter_by(id=postid).one()
except NoResultFound:
raise PostNotFound
def delete_revision(self, name, revision, request):
"""
Delete a revision
Raise GameDepNotFound if page does not exist
"""
f = FileLib(request)
rev = self.show(name, revision)[1]
files = set()
if rev.file_obj:
files.add(rev.file_obj)
rev.file_obj = None
for item in rev.binary:
files.add(item.file_obj)
item.file_obj = None
for item in files:
f.delete(item)
DBSession.delete(rev)
def get_category(self, name):
"""
Get a forum category
"""
try:
return DBSession.query(BBCategory).filter_by(name=name).one()
except NoResultFound:
raise CategoryNotFound
def delete_revision(self, name, revision, request):
"""
Delete a revision
Raise GameDepNotFound if page does not exist
"""
f = FileLib(request)
rev = self.show(name, revision)[1]
files = set()
if rev.file_obj:
files.add(rev.file_obj)
rev.file_obj = None
for item in rev.binary:
files.add(item.file_obj)
item.file_obj = None
for item in files:
f.delete(item)
DBSession.delete(rev)
def create_binary(self, name, revision, operatingsystem, architecture,
binary, mimetype, filename, request):
"""
Add a new binary
"""
try:
os_obj = DBSession.query(OperatingSystems).filter_by(
id=operatingsystem).one()
arch_obj = DBSession.query(Architectures).filter_by(
id=architecture).one()
except NoResultFound:
raise GameDepNotFound
rev = self.show(name, revision)[1]
file_lib = FileLib(request)
aio_obj = file_lib.write(filename, binary, mimetype)
bin_obj = GameDepBinary(aio_obj, os_obj, arch_obj)
rev.binary.append(bin_obj)
def create_binary(self, name, revision, operatingsystem, architecture,
binary, mimetype, filename, request):
"""
Add a new binary
"""
try:
os_obj = DBSession.query(OperatingSystems).filter_by(
id=operatingsystem).one()
arch_obj = DBSession.query(Architectures).filter_by(
id=architecture).one()
except NoResultFound:
raise GameDepNotFound
rev = self.show(name, revision)[1]
file_lib = FileLib(request)
aio_obj = file_lib.write(filename, binary, mimetype)
bin_obj = GameDepBinary(aio_obj, os_obj, arch_obj)
rev.binary.append(bin_obj)
def get_thread(self, threadid):
"""
Returns the specified thread
"""
try:
thread = DBSession.query(BBThread).filter_by(id=threadid).one()
except NoResultFound:
raise ThreadNotFound
return thread
def add_thread(self,
title,
description,
body,
user,
forum=None,
add_post=True):
"""
Add a thread, optionally to a forum.
"""
thread = BBThread(title, description)
if forum:
thread.forum = forum
if add_post:
self.add_post(thread, title, body, user)
DBSession.add(thread)
DBSession.flush()
return thread
def get_forum_by_name(self, forum_name):
"""
Returns the specified forum by name
"""
try:
forum = DBSession.query(BBForum).filter_by(name=forum_name).one()
except NoResultFound:
raise ForumNotFound
return forum
def get_forum(self, forumid):
"""
Returns the specified forum
"""
try:
forum = DBSession.query(BBForum).filter_by(id=forumid).one()
except NoResultFound:
raise ForumNotFound
return forum
def to_json(self):
pages = DBSession.query(ArticlePage)
items = serialize_relation(pages)
result = []
for item in items:
item['revisions'] = serialize_relation(
self.show_page(item["name"]).revisions)
result.append(item)
dthandler = (lambda obj: obj.isoformat()
if isinstance(obj, datetime.datetime) else None)
return json.dumps(result, default=dthandler)
def delete_post(self, post):
"""
Delete the specified post
Returns:
1 - Post Deleted
2 - Thread Deleted
"""
# If it's the first post of a thread, delete the whole thread
thread = post.thread
if post == thread.posts[0]:
for posts in thread.posts:
posts.user.postcount += -1
DBSession.delete(thread)
return 2
else:
post.user.postcount += -1
DBSession.delete(post)
return 1
def create(self, name, display_name, description, tags, owner, request):
"""
Add a new page
Raise GameDepFound if page exists
"""
if not self.exists(name, raise_if_found=True):
page = GameDepPage(self.gamedep_type, name, display_name, owner)
page.description = description
self.t.set_tags(page, tags)
s = SettingsLib()
if s.has_setting("PYRACMS_FORUM"):
from pyracms_forum.lib.boardlib import BoardLib
page.thread_id = BoardLib().add_thread(name, display_name, "",
owner, add_post=False).id
if s.has_setting("PYRACMS_GALLERY"):
from pyracms_gallery.lib.gallerylib import GalleryLib
g = GalleryLib()
album = g.create_album(name, display_name, owner)
page.album_id = album
DBSession.add(page)
def show_page(self, name):
"""
Get page objects.
Raise PageNotFound if page does not exist.
"""
try:
page = DBSession.query(ArticlePage).filter(
ArticlePage.name.like(name)).one()
except NoResultFound:
raise PageNotFound
return page
def list(self): #@ReservedAssignment
"""
List all the pages
"""
result = set()
gamedeps = DBSession.query(GameDepPage).filter_by(
gamedeptype=self.gamedep_type)
if not gamedeps:
raise GameDepNotFound
for gamedep in gamedeps:
result.add(gamedep.name)
return result
def list(self): #@ReservedAssignment
"""
List all the pages
"""
result = set()
gamedeps = DBSession.query(GameDepPage).filter_by(
gamedeptype=self.gamedep_type)
if not gamedeps:
raise GameDepNotFound
for gamedep in gamedeps:
result.add(gamedep.name)
return result
def create(self, name, display_name, description, tags, owner, request):
"""
Add a new page
Raise GameDepFound if page exists
"""
if not self.exists(name, raise_if_found=True):
page = GameDepPage(self.gamedep_type, name, display_name, owner)
page.description = description
self.t.set_tags(page, tags)
s = SettingsLib()
if s.has_setting("PYRACMS_FORUM"):
from pyracms_forum.lib.boardlib import BoardLib
page.thread_id = BoardLib().add_thread(name,
display_name,
"",
owner,
add_post=False).id
if s.has_setting("PYRACMS_GALLERY"):
from pyracms_gallery.lib.gallerylib import GalleryLib
g = GalleryLib()
album = g.create_album(name, display_name, owner)
page.album_id = album
DBSession.add(page)
def dependency_dropdown(self, with_display_name=True):
result = []
page = DBSession.query(GameDepPage).filter_by(gamedeptype="dep")
for x in page:
if x.revisions.count():
i = 0
for revision in x.revisions:
if revision.published:
i += 1
if i > 0:
if with_display_name:
result.append(
(str(x.id), "%s (%s)" % (x.display_name, x.name)))
else:
result.append(str(x.id))
return result
def dependency_dropdown(self, with_display_name=True):
result = []
page = DBSession.query(GameDepPage).filter_by(gamedeptype="dep")
for x in page:
if x.revisions.count():
i = 0
for revision in x.revisions:
if revision.published:
i += 1
if i > 0:
if with_display_name:
result.append((str(x.id),
"%s (%s)" % (x.display_name,
x.name)))
else:
result.append(str(x.id))
return result
def exists(self, name, version=None, raise_if_found=False):
"""
Check to see if a page exists
Return True/False
"""
try:
page = DBSession.query(GameDepPage).filter_by(
name=name, gamedeptype=self.gamedep_type).one()
except NoResultFound:
return False
if version:
versions = [x.version for x in page.revisions]
if not version in versions:
return False
if raise_if_found:
raise GameDepFound
return True
def exists(self, name, version=None, raise_if_found=False):
"""
Check to see if a page exists
Return True/False
"""
try:
page = DBSession.query(GameDepPage).filter_by(
name=name,
gamedeptype=self.gamedep_type
).one()
except NoResultFound:
return False
if version:
versions = [x.version for x in page.revisions]
if not version in versions:
return False
if raise_if_found:
raise GameDepFound
return True
def show_json(self):
"""
Serialise gamedep into json
"""
root = {"operatingsystems": [],
"architectures": [],
"gamedep": []}
key = None
gametype = "game"
deptype = "dep"
game = DBSession.query(GameDepPage).filter_by(gamedeptype=gametype
).all()
dep = DBSession.query(GameDepPage).filter_by(gamedeptype=deptype).all()
oslist = DBSession.query(OperatingSystems)
archlist = DBSession.query(Architectures)
for os in oslist:
osdict = {}
osdict["name"] = os.name
osdict["display_name"] = os.display_name
root["operatingsystems"].append(osdict)
for arch in archlist:
archdict = {}
archdict["name"] = arch.name
archdict["display_name"] = arch.display_name
root["architectures"].append(archdict)
for gamedep in [game, dep]:
if gamedep == game:
key = "game"
else:
key = "dependency"
for item in gamedep:
if item.revisions.count() == 0:
continue
gamedepdict = {}
gamedepdict["name"] = item.name
gamedepdict["display_name"] = item.display_name
gamedepdict["description"] = item.description
gamedepdict["created"] = str(item.created)
gamedepdict["dependencies"] = []
for loopdep in item.dependencies:
depdict = {}
if loopdep.page.revisions.count() == 0:
continue
depdict['dependency'] = loopdep.page.name
if loopdep:
depdict['version'] = str(loopdep.version)
else:
depdict['version'] = str(loopdep.page.\
revisions[0].version)
gamedepdict["dependencies"].append(depdict)
gamedepdict["tags"] = []
for looptag in item.tags:
if looptag.name.strip():
gamedepdict["tags"].append(looptag.name)
gamedepdict["pictures"] = []
if self.gallery:
album = self.gallery.show_album(item.album_id)
for pic in album.pictures:
picture = {}
picture['url'] = (self.uploadurl + pic.file_obj.uuid +
"/" + pic.file_obj.name)
thumb_name = (splitext(pic.file_obj.name)[0] +
".thumbnail.png")
picture['thumb_url'] = (self.uploadurl +
pic.file_obj.uuid +
"/" + thumb_name)
picture['thumb_name'] = thumb_name
picture['default'] = False
picture['display_name'] = pic.display_name
picture['description'] = pic.description
picture['uuid'] = pic.file_obj.uuid
picture['name'] = pic.file_obj.name
if album.default_picture == pic:
picture['default'] = True
gamedepdict["pictures"].append(picture)
gamedepdict["revisions"] = []
for looprev in item.revisions:
if looprev.published:
revdict = {}
revdict["version"] = str(looprev.version)
revdict["created"] = str(looprev.created)
revdict["moduletype"] = looprev.moduletype
if gamedep == game:
revdict["source"]= self.uploadurl + \
looprev.file_obj.uuid \
+ "/" + looprev.file_obj.name
revdict['source_uuid'] = looprev.file_obj.uuid
revdict['source_name'] = looprev.file_obj.name
revdict["binaries"] = []
for loopbin in looprev.binary:
bindict = {}
bindict["binary"] = self.uploadurl + \
loopbin.file_obj.uuid \
+ "/" + loopbin.file_obj.name
bindict["operating_system"] = \
loopbin.operatingsystem_obj.name
bindict["architecture"] = \
loopbin.architecture_obj.name
bindict['uuid'] = loopbin.file_obj.uuid
bindict['name'] = loopbin.file_obj.name
revdict["binaries"].append(bindict)
gamedepdict["revisions"].append(revdict)
root["gamedep"].append({key: gamedepdict})
return json.dumps(root, sort_keys=True, indent=4)
def render_comment(self, context, request, *args):
comment = self.get_comment(*args)
DBSession.flush()
return render('board/view_thread_content.jinja2',
get_thread(context, request, comment.thread.id), request)
def main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
# Add Operating Systems
DBSession.add(OperatingSystems("pi", "Platform Independent"))
DBSession.add(OperatingSystems("win", "Windows"))
DBSession.add(OperatingSystems("mac", "Mac OS X"))
DBSession.add(OperatingSystems("lin", "Linux"))
DBSession.add(OperatingSystems("sol", "Solaris"))
DBSession.add(OperatingSystems("fbsd", "FreeBSD"))
DBSession.add(OperatingSystems("nbsd", "NetBSD"))
DBSession.add(OperatingSystems("obsd", "OpenBSD"))
# Add Architectures
DBSession.add(Architectures("pi", "Platform Independent"))
DBSession.add(Architectures("i386", "32bit X86"))
DBSession.add(Architectures("x86_64", "64bit X86"))
DBSession.add(Architectures("arm", "ARM Little Endian"))
DBSession.add(Architectures("armeb", "ARM Big Endian"))
DBSession.add(Architectures("ppc", "32bit PowerPC"))
DBSession.add(Architectures("ppc64", "64bit PowerPC"))
DBSession.add(Architectures("sparc", "32bit SPARC"))
DBSession.add(Architectures("sparc64", "64bit SPARC"))
# Default Groups
u = UserLib()
u.create_group("gamedep", "Ability to Add, Edit and Delete" +
" games and dependencies.")
# Default ACL
acl = RootFactory()
acl.__acl__.append((Allow, Everyone, 'gamedep_view'))
acl.__acl__.append((Allow, Everyone, 'gamedep_list'))
acl.__acl__.append((Allow, "group:admin", 'gamedep_mod'))
acl.__acl__.append((Allow, "group:gamedep", "group:gamedep"))
acl.__acl__.append((Allow, "group:gamedep", 'gamedep_view'))
acl.__acl__.append((Allow, "group:gamedep", 'gamedep_list'))
acl.__acl__.append((Allow, "group:gamedep", 'gamedep_publish'))
acl.__acl__.append((Allow, "group:gamedep", 'gamedep_edit'))
acl.__acl__.append((Allow, "group:gamedep", 'gamedep_delete'))
acl.__acl__.append((Allow, "group:gamedep", 'gamedep_add_picture'))
acl.__acl__.append((Allow, "group:gamedep", 'gamedep_delete_picture'))
acl.__acl__.append((Allow, "group:gamedep", 'gamedep_add_source'))
acl.__acl__.append((Allow, "group:gamedep", 'gamedep_add_binary'))
acl.__acl__.append((Allow, "group:gamedep", 'gamedep_edit_binary'))
acl.__acl__.append((Allow, "group:gamedep", 'gamedep_delete_binary'))
acl.__acl__.append((Allow, "group:gamedep", 'gamedep_add_dependency'))
acl.__acl__.append((Allow, "group:gamedep", 'gamedep_delete_dependency'))
acl.__acl__.append((Allow, "group:gamedep", 'gamedep_edit_revision'))
s = SettingsLib()
s.update("DEFAULTGROUPS", s.show_setting("DEFAULTGROUPS") +
"gamedep\n")
s.create("INFO_PIC_ADDED", "Your picture (%s) has been added.")
s.create("INFO_PIC_DELETED", "Your picture (%s) has been deleted.")
s.create("INFO_BINARY_ADDED", "Your binary (%s) has been added.")
s.create("INFO_BINARY_UPDATED", "Your binary (%s) has been updated.")
s.create("INFO_BINARY_DELETED", "Your binary (%s) has been deleted.")
s.create("INFO_SOURCE_UPLOADED", "The source code (%s) has been "
"successfully uploaded.")
s.create("INFO_DEPENDENCY_ADDED",
"Your dependency (%s) has been added.")
s.create("INFO_DEPENDENCY_DELETED",
"Your dependency (%s) has been deleted.")
s.create("INFO_REVISION_UPDATED", "A new version (%s) has been "
"updated for %s.")
s.create("INFO_REVISION_CREATED", "A new version (%s) has been "
"created for %s.")
s.create("ERROR_INVALID_BINARY_ID",
"Invalid Binary ID and/or Edit Type.")
s.create("ERROR_NOT_UPLOADED_BINARY",
"You have not uploaded any binaries.")
s.create("ERROR_NOT_UPLOADED_SOURCE_CODE",
"You have not uploaded any source code.")
s.create("HYPERNUCLEUS_SERVER")
m = MenuLib()
group = m.show_group("main_menu")
m.add_menu_item_route("Games", "gamedeplist", 3, group, Everyone,
{"type": GAME})
m.add_menu_item_route("Dependencies", "gamedeplist", 4,
group, Everyone, {"type": DEP})
