def liccreate(self, environ):
"""Create a new license to be hosted on this site.
URLS :
/license/create
/license/create?form=submit&formname=createlic
"""
from zeta.config.environment import vfcomp
c.rclose = h.ZResp()
# Form handling
def errhandler(errmsg):
c.errmsg = errmsg
vfcomp.process(request,
c,
defer=True,
errhandler=h.hitchfn(errhandler),
formnames=['createlic'],
user=c.authuser)
# Setup context for page generation
c.licensenames, c.licenselist, licfields = self._selectoptions()
c.title = (c.form == 'request' and '-Skip-') or 'CreateLicense'
# Html page generation
if c.errmsg:
html = self.returnerrmsg(environ)
else:
html = render('/derived/license/liccreate.html')
c.rclose.append(html)
return c.rclose
def remove_attach(self, attach=None, log=False, doclose=None, byuser=None):
"""Remove the attachment entry identified by,
`attach` which can be
`id` or `Attachment` instance.
"""
from zeta.config.environment import userscomp, tlcomp, srchcomp
attach = self.get_attach(attach=attach)
msession = meta.Session()
attach and self._remove_content(attach)
filename = attach.filename
with msession.begin(subtransactions=True):
attach and msession.delete(attach)
msession.flush()
log = log and 'deleted attachment, %s' % filename or ''
# Post processing, optional deferred handling
def onclose(tlcomp, srchcomp, attach, log, byuser):
# TODO : Delete this attachment.
#srchcomp.indexattach( [attach], replace=True )
log and tlcomp.log(byuser, log)
doclose(h.hitchfn(onclose, tlcomp, srchcomp, attach, log, byuser))
return attach
def create( self, environ ) :
"""Create and host a new project
URLS :
/p/newproject?form=request&formname=createprj
/p/newproject?form=submit&formname=createprj
"""
from zeta.config.environment import liccomp, projcomp, vfcomp
c.rclose = h.ZResp()
# Form handling
def errhandler(errmsg) :
c.errmsg = errmsg
vfcomp.process(
request, c, defer=True, errhandler=h.hitchfn(errhandler),
formnames=['createprj'], user=c.authuser
)
# Setup context for page generation
c.licensenames = sorted([ l[1] for l in liccomp.licensefields() ])
c.projectnames = projcomp.projectnames
c.liceditable = h.authorized( h.HasPermname(['LICENSE_CREATE']) )
c.title = 'CreateProject'
# Html page generation
if c.errmsg :
html = self.returnerrmsg(environ)
elif c.form == 'submit' :
h.redirect_url( h.url_createprj )
else :
html = render( '/derived/projects/create.html' )
c.rclose.append(html)
return c.rclose
def create_attach(self,
filename,
fdfile=None,
uploader=None,
summary=None,
log=False,
doclose=None):
"""Create an attachment for `filename`,
Return,
Attachment instance."""
from zeta.config.environment import userscomp, tlcomp, srchcomp
uploader = uploader and userscomp.get_user(uploader)
content = fdfile and fdfile.read() or ''
msession = meta.Session()
with msession.begin(subtransactions=True):
attach = Attachment(filename, 0)
summary and setattr(attach, 'summary', summary)
uploader and setattr(attach, 'uploader', uploader)
attach.size = len(content)
msession.add(attach)
self._store_fileupload(content, attach)
fdfile and fdfile.close()
log = log and 'Uploaded attachment, %s' % filename or ''
# Post processing, optional deferred handling
def onclose(tlcomp, srchcomp, attach, uploader, log):
srchcomp.indexattach([attach])
log and tlcomp.log(uploader, log, attach=attach)
doclose(h.hitchfn(onclose, tlcomp, srchcomp, attach, uploader, log))
return attach
def create_mount(self,
vcs,
name,
repospath,
content=h.MNT_TEXTCONTENT,
doclose=None,
byuser=None):
"""Create a mount point for repository directory"""
from zeta.config.environment import tlcomp
vcs = self.get_vcs(vcs, attrload=['project'])
msession = meta.Session()
with msession.begin(subtransactions=True):
vmount = VcsMount(name, repospath, content)
vmount.vcs = vcs
msession.add(vmount)
msession.flush()
log = 'Mounted directory `%s` onto mount point %s' % (repospath, name)
# Post processing, optional deferred handling
def onclose(tlcomp, vcs, byuser, log):
tlcomp.log(byuser, log, project=vcs.project)
doclose(h.hitchfn(onclose, tlcomp, vcs, byuser, log))
return vmount
def update_mount(self,
mount,
name=None,
repospath=None,
content=None,
doclose=None,
byuser=None):
"""Update already created mount"""
from zeta.config.environment import tlcomp
mount = self.get_mount(mount, attrload_all=['vcs.project'])
logs = []
msession = meta.Session()
with msession.begin(subtransactions=True):
if name:
mount.name = name
logs.append('name : %s' % name)
if repospath:
mount.repospath = repospath
logs.append('repospath : %s' % repospath)
if content:
mount.content = content
logs.append('content : %s' % content)
log = ''
if logs and mount:
log = '\n'.join(['Updated repository mount, %s' % mount.name] +
logs)
# Post processing, optional deferred handling
def onclose(tlcomp, mount, byuser, log):
log and tlcomp.log(byuser, log, project=mount.vcs.project)
doclose(h.hitchfn(onclose, tlcomp, mount, byuser, log))
return None
def remove_content(self, wiki, version, doclose=None, byuser=None):
"""For the Wiki page identified by
`wiki`, which can be,
`id` or `wikiurl` or `Wiki` instance.
Remove the version,
`version` which should be a valid `wikipage.id`."""
from zeta.config.environment import tlcomp, srchcomp
wiki = self.get_wiki(wiki)
msession = meta.Session()
with msession.begin(subtransactions=True):
WikiPage = self._map_wikipage(wiki.tablemap.table_pagenum)
wikipage = msession.query(WikiPage).filter_by(id=version).first()
removed_id = wikipage.id
msession.delete(wikipage)
with msession.begin(subtransactions=True):
if wiki.latest_version == removed_id:
wikipage = self._latestversion(WikiPage)
if wikipage:
wiki.latest_version = wikipage.id
else:
wiki.latest_version = 0
log = 'removed wiki page version %s' % version
# Post processing, optional deferred handling
def onclose(tlcomp, srchcomp, wiki, byuser, log):
tlcomp.log(byuser, log, wiki=wiki)
srchcomp.indexwiki([wiki], replace=True)
doclose(h.hitchfn(onclose, tlcomp, srchcomp, wiki, byuser, log))
return None
def integrate_vcs(self, project, vcsdetail, doclose=None, byuser=None):
"""Create a new vcs based on,
`project` can be,
`id` or `projectname` or `Project` instance
`vcsdetail` which is a tuple of,
( type, name, rooturl, loginname, password )
type can be `id` or `vcs_typename`
Return,
Vcs instance."""
from zeta.config.environment import userscomp, prjcomp, tlcomp
project = prjcomp.get_project(project)
vcs_type = self.get_vcstype(vcsdetail[0])
msession = meta.Session()
with msession.begin(subtransactions=True):
type, name, rooturl, loginname, password = vcsdetail
vcs = Vcs(name, rooturl, loginname, password)
vcs_type and setattr(vcs, 'type', vcs_type)
project.vcslist.append(vcs)
msession.add(vcs)
msession.flush()
log = 'added project repository, `%s`' % vcs.name
# Post processing, optional deferred handling
def onclose(tlcomp, vcs, byuser, log):
tlcomp.log(byuser, log, vcs=vcs)
doclose(h.hitchfn(onclose, tlcomp, vcs, byuser, log))
return vcs
def delfavorites(self, wiki, favusers, doclose=None, byuser=None):
"""Delete the wiki as favorite for users identified by
`favusers`, which can be (also can be an array of)
`id` or `username` or `User` instance.
to `wiki` which can be,
`id` or `wikiurl` or `Wiki` instance."""
from zeta.config.environment import userscomp, tlcomp, srchcomp
if not isinstance(favusers, list):
favusers = [favusers]
favusers = [userscomp.get_user(u) for u in favusers]
wiki = self.get_wiki(wiki)
msession = meta.Session()
with msession.begin(subtransactions=True):
[
wiki.favoriteof.remove(u) for u in favusers
if u in wiki.favoriteof
]
log = 'removed wiki page from favorite'
# Post processing, optional deferred handling
def onclose(tlcomp, wiki, byuser, log):
tlcomp.log(byuser, log, wiki=wiki)
doclose(h.hitchfn(onclose, tlcomp, wiki, byuser, log))
return None
def uploadlogo( self, environ ) :
"""Action to upload site logo file"""
from zeta.config.environment import vfcomp, userscomp
c.rclose = h.ZResp()
# Form handling
def errhandler(errmsg) :
c.errmsg = errmsg
vfcomp.process(
request, c, defer=True,
errhandler=h.hitchfn(errhandler), formnames=[ 'sitelogo']
)
c.title = 'SiteLogo'
# Html page generation
if c.errmsg :
html = self.returnerrmsg(environ)
elif c.form == 'submit' :
h.redirect_url( h.url_siteadmin )
else :
html = render( '/derived/siteadmin/sitelogo.html' )
c.rclose.append(html)
return html
def create(self, environ, projectname):
"""Create a new project review
URLS :
/p/{projectname}/r/createrevw?form=request&formname=createrev
/p/{projectname}/r/createrevw?form=submit&formname=createrev
"""
from zeta.config.environment import projcomp, userscomp, vcscomp, vfcomp
cfok = lambda cf : ( cf['mime_type'] != 'text/directory' ) and \
( cf['changetype'] != 'deleted' )
c.rclose = h.ZResp()
# Handle forms
def errhandler(errmsg):
c.errmsg = errmsg
vfcomp.process(request,
c,
defer=True,
errhandler=h.hitchfn(errhandler),
formnames=['createrev'],
user=c.authuser)
# Setup context for page generation
c.projsummary = c.project.summary
c.projusers = self.projusers(c.project)
c.usernames = sorted(userscomp.usernames)
c.rsets = [[rs.id, rs.name] for rs in c.project.reviewsets]
c.forsrc = request.params.getall('rurl')
c.forversion = request.params.get('ver', None)
c.forversion = int(c.forversion) if c.forversion != None else None
vcsid = request.params.get('vcsid', None)
c.vcs = vcsid and vcscomp.get_vcs(int(vcsid))
c.vrep = c.vcs and va.open_repository(c.vcs)
c.title = 'CreateReview'
if c.vrep:
c.changedfiles = c.vrep.changedfiles(c.vcs.rooturl,
revstart=c.forversion - 1,
revend=c.forversion)
c.forsrc = [
join(c.vcs.rooturl, cf['repos_path'].lstrip('/'))
for cf in c.changedfiles if cfok(cf)
]
# HTML page generation
if c.errmsg:
html = self.returnerrmsg(environ)
elif c.form == 'submit' and c.formname == 'createrev':
# Skip breadcrumbing, if it is a form submit
c.title = '-Skip-'
h.redirect_url(h.url_revwcreate)
else:
html = render('/derived/projects/reviewcreate.html')
c.rclose.append(html)
return c.rclose
def config_wiki(self,
wiki,
wtype=None,
summary=None,
sourceurl=None,
project=None,
doclose=None,
byuser=None):
"""For the wiki page identified by
`wiki`, which can be,
`id` or `wikiurl` or `Wiki` instance.
Set the wiki wtype.
`wtype`, can be
`id` or `wiki_typename` or `WikiType` instance.
Add the project to which the wiki belongs to.
`project` can be,
`id` or `projectname` or `Project` instance
if project can also be a string."""
from zeta.config.environment import projcomp, tlcomp, srchcomp
wiki = self.get_wiki(wiki)
wtype = wtype and self.get_wikitype(wtype)
project = project and projcomp.get_project(project)
msession = meta.Session()
summary = summary and summary.replace('\n', ' ').replace('\r', ' ')
with msession.begin(subtransactions=True):
# Construct log based on attributes that have changed
loglines = []
wtype and loglines.append(
('type', wiki.type.wiki_typename, wtype.wiki_typename))
summary and loglines.append(('summary', wiki.summary, summary))
sourceurl and loglines.append(
('sourceurl', wiki.sourceurl, sourceurl))
log = h.logfor(loglines)
if log:
log = 'Changed,\n%s' % log
# Logging ends here
if wtype:
wiki.type = wtype
if summary != None:
wiki.summary = unicode(summary)
if sourceurl != None:
wiki.sourceurl = unicode(sourceurl)
if project != None:
wiki.project = project
# Post processing, optional deferred handling
def onclose(tlcomp, srchcomp, wiki, byuser, log):
log and tlcomp.log(byuser, log, wiki=wiki)
srchcomp.indexwiki([wiki], replace=True)
doclose(h.hitchfn(onclose, tlcomp, srchcomp, wiki, byuser, log))
return None
def set_sysentry(self, entries, doclose=None, byuser=None):
"""`entries` is a dictionary of 'field': 'value' which should be populated
into the database."""
from zeta.config.environment import tlcomp
msession = meta.Session()
# Sometimes, the caller might log the fact that sys-table is being
# updated, so skip them here.
#skiplog = [ 'projteamtypes', 'tickettypes', 'ticketstatus',
# 'ticketseverity', 'reviewnatures', 'reviewactions',
# 'wikitypes', 'vcstypes', 'specialtags' ]
skiplog = []
with msession.begin(subtransactions=True):
dbentries = dict(
map(lambda e: (e.field, e),
msession.query(System).all()))
loglines = []
for k, v in entries.iteritems():
if not isinstance(entries[k], (str, unicode)):
continue
e = dbentries.get(k, None)
if e == None:
msession.add(System(k, v))
log = k not in skiplog
elif k in csvfields and \
( sorted(h.parse_csv(e.value)) != sorted(h.parse_csv(v)) ) :
dbentries[k].value = v
log = k not in skiplog
elif (k not in csvfields) and (e.value != v):
dbentries[k].value = v
log = k not in skiplog
else:
log = False
loglines.append('%s : %s' % (k, v)) if log else None
log = loglines and 'system configuration,\n%s' % '\n'.join(
loglines) or ''
# Post processing, optional deferred handling
cache.invalidate(self._sysentries)
def onclose(tlcomp, byuser, log):
log and tlcomp.log(byuser, log)
doclose(h.hitchfn(onclose, tlcomp, byuser, log))
return None
def create_license(self,
licensedetail,
update=False,
doclose=None,
byuser=None):
"""Create an entry in the license table.
licensedetail is,
(licid, licensename, summary, text, source)
if update=True,
An exisiting license identified by `licensedetail[0]` will be
updated with licensedetail.
`licid` can be `id` ir `License` instance."""
from zeta.config.environment import tlcomp, srchcomp
if filter(h.filter_badargs, licensedetail[1:]):
raise ZetaLicenseError(
"License Field empty while creating license entry ( %s ) !!" \
% licensedetail )
msession = meta.Session()
license = (update and self.get_license(licensedetail[0])) or None
with msession.begin(subtransactions=True):
if (update and license) or license:
licensedetail[1] and \
setattr( license, 'licensename', licensedetail[1] )
licensedetail[2] and \
setattr( license, 'summary', licensedetail[2] )
licensedetail[3] and \
setattr( license, 'text', licensedetail[3] )
licensedetail[4] and \
setattr( license, 'source', licensedetail[4] )
log = 'updated license'
idxreplace = True
else:
license = License(*licensedetail[1:])
msession.add(license)
msession.flush()
log = 'created new license'
idxreplace = False
# Post processing, optional deferred handling
def onclose(tlcomp, srchcomp, license, byuser, log, idxreplace):
log and tlcomp.log(byuser, log, license=license)
srchcomp.indexlicense([license], replace=idxreplace)
doclose(
h.hitchfn(onclose, tlcomp, srchcomp, license, byuser, log,
idxreplace))
return license
def newaccount( self, environ ) :
"""Create new user account
URLS :
/accounts/newaccount?form=request&formname=createuser
/accounts/newaccount?form=request&formname=createuser&digest=<digest>
/accounts/newaccount?form=submit&formname=createuser
/accounts/newaccount?form=submit&formname=createuser&digest=<digest>
"""
from zeta.config.environment import userscomp, vfcomp
c.rclose = h.ZResp()
# Calculate whether registration is allowed.
regrbyinvite = h.str2bool( c.sysentries['regrbyinvite'] )
c.uinv = None
if not regrbyinvite :
c.allowregistration = True
elif c.digest :
c.uinv = userscomp.invbydigest( c.digest )
c.allowregistration = bool(c.uinv)
else :
c.uinv = None
c.allowregistration = False
# Setup context for page generation
c.usernames = userscomp.usernames
# Form handling
def errhandler(ERROR_FLASH, errmsg) :
h.flash( ERROR_FLASH + errmsg )
h.redirect_url( h.url_register )
vfcomp.process(
request, c,
defer=True, errhandler=h.hitchfn(errhandler, ERROR_FLASH),
formnames=['createuser']
)
# If registeration was successful in `form handling` go-to-signin
if c.form == 'submit' :
username = request.POST.get( 'username', None )
c.uinv and userscomp.acceptedby( unicode(username), c.uinv )
h.flash( self.okmsg1 )
h.redirect_url( h.url_signin )
# Generate page
c.rclose.append(render( '/derived/accounts/register.html' ))
return c.rclose
def projecthome( self, environ, projectname ) :
"""Project main-page for `projectname`
URLS :
/p/<projectname>
/p/<projectname>?translate=1
/p/<projectname>?jsonobj=projectlogo&view=js
/p/<projectname>?jsonobj=projecticon&view=js
/p/<projectname>?form=submit&formname=projfav&view=js
"""
from zeta.config.environment import projcomp, wikicomp, vfcomp
c.rclose = h.ZResp()
# Form handling
def errhandler(errmsg) :
c.errmsg = errmsg
vfcomp.process(
request, c, defer=True, errhandler=h.hitchfn(errhandler),
formnames=['projfav'], user=c.authuser
)
# Setup context for page generation
c.projsummary = c.project.summary
pt = {}
[ pt.setdefault( t.teamtype.team_type, [] ).append( t.user.username )
for t in c.project.team ]
c.projectteams = pt
c.att_editable = h.authorized( h.ProjectAdmin() )
c.tag_editable = c.att_editable
c.isfavorite = projcomp.checkfavorite( c.project.id, c.authuser.id )
c.tags = self._prjtags( c.project )
c.title = c.projectname
fpurl = unicode( self.url_wikiurl( c.projectname, PROJHOMEPAGE ))
w = wikicomp.get_wiki( fpurl, attrload=[ 'tablemap' ] )
c.fpwcnt = wikicomp.get_content( w, translate=True ) if w else None
c.fphtml = wikipage2html( c.fpwcnt, c.translate )
# Html page generation
if c.errmsg :
html = self.returnerrmsg(environ)
elif c.jsonobj and c.view == 'js' :
html = self.handlejson(environ)
elif c.view != 'js' :
html = render( '/derived/projects/project.html' )
c.rclose.append(html)
return c.rclose
def set_staticwiki(self,
path,
text,
swtype=None,
sourceurl=None,
doclose=None,
byuser=None):
"""Set the static wiki page specified by 'path'"""
from zeta.config.environment import tlcomp, srchcomp, wikicomp
swtype = swtype and wikicomp.get_wikitype(swtype)
swtype = swtype or wikicomp.get_wikitype(
self.get_sysentry(u'def_wikitype'))
sw = self.get_staticwiki(path)
msession = meta.Session()
with msession.begin(subtransactions=True):
if sw:
swtype and setattr(sw, 'type', swtype)
if sourceurl != None:
sw.sourceurl = unicode(sourceurl)
sw.text = unicode(text)
sw.texthtml = sw.translate(wiki=sw) # To HTML
log = 'updated guest wiki page, %s' % path
idxreplace = True
else:
sw = StaticWiki(unicode(path), unicode(text))
swtype and setattr(sw, 'type', swtype)
if sourceurl != None:
sw.sourceurl = unicode(sourceurl)
sw.texthtml = sw.translate(wiki=sw) # To HTML
msession.add(sw)
log = 'created new guest wiki page, %s' % path
idxreplace = False
# Database Post processing
# Post processing, optional deferred handling
def onclose(tlcomp, srchcomp, byuser, log, idxreplace):
tlcomp.log(byuser, log)
srchcomp.indexstaticwiki([sw], replace=idxreplace)
doclose(h.hitchfn(onclose, tlcomp, srchcomp, byuser, log, idxreplace))
return sw
def create_content(self, wiki, author, text, version=None, doclose=None):
"""For the Wiki page identified by
`wiki`, which can be,
`id` or `wikiurl` or `Wiki` instance.
add wiki content as the next version to wikipage table. if version is
specified and matches a wikipage.id, then update the entry."""
from zeta.config.environment import userscomp, tlcomp, srchcomp
log = ''
wiki = self.get_wiki(wiki)
author = userscomp.get_user(author)
msession = meta.Session()
with msession.begin(subtransactions=True):
WikiPage = self._map_wikipage(wiki.tablemap.table_pagenum)
if version:
wikipage = msession.query(WikiPage).filter_by(
id=version).first()
wikipage and author and setattr(wikipage, 'author',
author.username)
if wikipage and text:
wikipage.text = text
wikipage.translate(
wiki=wiki,
cache=True) # To HTML, maybe cached, maybe not !
log = 'updated existing wiki version %s' % version
else:
wikipage = WikiPage(text)
wikipage and author and setattr(wikipage, 'author',
author.username)
if wikipage and text:
wikipage.text = text
wikipage.translate(
wiki=wiki,
cache=True) # To HTML, maybe cached, maybe not !
msession.add(wikipage)
msession.flush()
wiki.latest_version = wikipage.id
log = 'updated wiki content to version %s' % wiki.latest_version
# Post processing, optional deferred handling
def onclose(tlcomp, srchcomp, wiki, author, log):
tlcomp.log(author, log, wiki=wiki)
srchcomp.indexwiki([wiki], replace=True)
doclose(h.hitchfn(onclose, tlcomp, srchcomp, wiki, author, log))
return wikipage
def wikiindex(self, environ, projectname):
"""Project wiki pages.
URLS :
/p/{projectname}/wiki
/p/{projectname}/wiki?jsonobj=wikilist&view=js
/p/{projectname}/wiki?form=submit&formname=vcsfile2wiki&view=js
/p/{projectname}/wiki?form=submit&formname=configwiki&view=js
"""
from zeta.config.environment import projcomp, wikicomp, vfcomp
c.rclose = h.ZResp()
# Handle forms
def errhandler(errmsg):
c.errmsg = errmsg
if self.formpermission():
c.errmsg = 'Do not have %s permission !!' % tckperm[c.formname]
else:
vfcomp.process(
request,
c,
defer=True,
errhandler=h.hitchfn(errhandler),
formnames=['vcsfile2wiki', 'configwiki'],
)
# Setup context for page generation
c.projsummary = c.project.summary
if not c.jsonobj and c.formname != 'vcsfile2wiki':
c.wikitypenames = wikicomp.typenames
c.wikipagenames = self.wikipagename(wikicomp.wikiurls(c.project))
c.wikipagename = None
c.wikieditable = h.authorized(h.HasPermname('WIKI_CREATE'))
c.title = '%s:wiki' % projectname
# HTML page generation
html = ''
if c.errmsg:
html = self.returnerrmsg(environ)
elif c.view == 'js' and c.jsonobj:
html = self.handlejson(environ)
elif c.view != 'js':
html = render('/derived/projects/wikiindex.html')
c.rclose.append(html)
return c.rclose
def create_wikicomment(self,
wiki,
wcmtdetail,
update=False,
doclose=None,
byuser=None):
"""For the Wiki instance identified by,
`wiki` which can be,
`id` or `wikiurl` or `Wiki` instance.
`wcmtdetail` can be,
(id, commentby, version_id, text)
if update==True,
then wcmtdetail[0] must be valid, in which an older comment
will be updated.
"""
from zeta.config.environment import userscomp, tlcomp, srchcomp
log = ''
wiki = self.get_wiki(wiki)
wikicmt = (update and self.get_wikicomment(wcmtdetail[0])) or None
commentby = userscomp.get_user(wcmtdetail[1])
msession = meta.Session()
with msession.begin(subtransactions=True):
if (update and wikicmt) or wikicmt:
wikicmt.commentby = commentby
wikicmt.version_id = wcmtdetail[2]
wikicmt.text = wcmtdetail[3]
wikicmt.texthtml = wikicmt.translate() # To HTML
log = 'updated comment,\n%s' % wikicmt.text
else:
wikicmt = WikiComment(wcmtdetail[2], wcmtdetail[3])
wikicmt.commentby = commentby
wikicmt.wiki = wiki
wikicmt.texthtml = wikicmt.translate() # To HTML
wiki.comments.append(wikicmt)
msession.add(wikicmt)
log = 'commented as,\n%s' % wikicmt.text
# Post processing, optional deferred handling
def onclose(tlcomp, srchcomp, wiki, byuser, log):
tlcomp.log(byuser, log, wiki=wiki)
srchcomp.indexwiki([wiki], replace=True)
doclose(h.hitchfn(onclose, tlcomp, srchcomp, wiki, byuser, log))
return wikicmt
def preference( self, environ, username, **kwargs ) :
"""Handle user preference
URLS :
/u/{username}/preference?form=request
/u/{username}/preference?form=submit&formname=updateuser&view=js
/u/{username}/preference?form=submit&formname=updtpass&view=js
/u/{username}/preference?form=submit&formname=userphoto&view=js
/u/{username}/preference?form=submit&formname=deluserphoto&view=js
/u/{username}/preference?form=submit&formname=usericon&view=js
/u/{username}/preference?form=submit&formname=delusericon&view=js
/u/{username}/preference?form=submit&formname=adduserrels&view=js
/u/{username}/preference?form=submit&formname=approveuserrels&view=js
/u/{username}/preference?form=submit&formname=deluserrels&view=js
"""
from zeta.config.environment import vfcomp
c.rclose = h.ZResp()
# Form handling
def errhandler(errmsg) :
c.errmsg = errmsg
if c.usercaninvite :
vfcomp.process(
request, c, defer=True, errhandler=h.hitchfn(errhandler),
formnames=[ 'updateuser', 'updtpass', 'userphoto',
'deluserphoto', 'usericon', 'delusericon', 'adduserrels',
'approveuserrels', 'deluserrels' ], user=c.authuser
)
# Setup context for page rendering
uinfo = c.authuser.userinfo
c.title = 'Preference'
c.photo_editable = c.icon_editable = h.authorized( h.ValidUser( strict='True' ))
c.photoattach = self._userphoto( c.authuser )
c.iconattach = self._usericon( c.authuser )
c.googlemaps = h.gmapkey( c.sysentries )
c.fulladdress = h.useraddress( uinfo )
# Html page generation
if c.view == 'js' and c.formname in [ 'userphoto', 'usericon' ] :
html = IFRAME_RET
else :
html = render( '/derived/userpage/preference.html' )
c.rclose.append(html)
return c.rclose
def config_vcs(self,
vcs,
name=None,
type=None,
rooturl=None,
loginname=None,
password=None,
doclose=None,
byuser=None):
"""For the vcs identified by,
`vcs` which can be,
`id` or `Vcs` instance
"""
from zeta.config.environment import userscomp, prjcomp, tlcomp
attrs = ['name', 'type', 'rooturl', 'loginname', 'password']
vcs = self.get_vcs(vcs, attrload=['project'])
# Construct log based on changing attributes
loglines = [('name', vcs.name, name),
('type', vcs.type.vcs_typename, type),
('rooturl', vcs.rooturl, rooturl)]
log = h.logfor(loglines)
if log:
log = 'changed attributes,\n%s' % log
# Logging ends here
# Find the changing attributes
localvars = locals()
type = type and self.get_vcstype(type) or None
msession = meta.Session()
localvars = locals() # locals() where changed.
with msession.begin(subtransactions=True):
[
setattr(vcs, attr, localvars[attr]) for attr in attrs
if localvars[attr]
]
# Post processing, optional deferred handling
def onclose(tlcomp, vcs, byuser, log):
log and tlcomp.log(byuser, log, vcs=vcs)
doclose(h.hitchfn(onclose, tlcomp, vcs, byuser, log))
return None
def reviewsets(self, environ, projectname):
"""Review set
URLS :
/p/{projectname}/rset
/p/{projectname}/rset?form=submit&formname=createrset&view=js
/p/{projectname}/rset?form=submit&formname=updaterset&view=js
/p/{projectname}/rset?form=submit&formname=addtorset&view=js
/p/{projectname}/rset?form=submit&formname=delfromrset&view=js
"""
from zeta.config.environment import userscomp, revcomp, vfcomp
c.rclose = h.ZResp()
# Handle forms
def errhandler(errmsg):
c.errmsg = errmsg
if self.formpermission():
c.errmsg = 'Do not have %s permission !!' % revwperm[c.formname]
else:
vfcomp.process(request,
c,
defer=True,
errhandler=h.hitchfn(errhandler),
formnames=[
'createrset', 'updaterset', 'addtorset',
'delfromrset'
],
user=c.authuser)
c.projsummary = c.project.summary
if c.errmsg:
html = self.returnerrmsg(environ)
elif c.view == 'js':
html = ''
else:
c.reviewsets = c.project.reviewsets
c.title = '%s:reviewsets' % projectname
html = render('/derived/projects/reviewset.html')
c.rclose.append(html)
return c.rclose
def vcsindex(self, environ, projectname):
"""Project source control
URLS :
/p/{projectname}/s
/p/{projectname}/s?jsonobj=vcslist&view=js
/p/{projectname}/s?form=submit&formname=configvcs&view=js
"""
from zeta.config.environment import vfcomp, projcomp, vcscomp
c.rclose = h.ZResp()
# Handle forms
def errhandler(errmsg):
c.errmsg = errmsg
if self.formpermission():
c.errmsg = 'Do not have %s permission !!' % tckperm[c.formname]
else:
vfcomp.process(
request,
c,
defer=True,
errhandler=h.hitchfn(errhandler),
formnames=['configvcs'],
)
# Setup context for page generation
c.projsummary = c.project.summary
c.vcs_typenames = vcscomp.vcstypenames
c.vcseditable = h.authorized(h.HasPermname('VCS_CREATE'))
c.title = '%s:source' % projectname
# HTML page generation
if c.errmsg:
html = self.returnerrmsg(environ)
elif c.view == 'js' and c.jsonobj:
html = self.handlejson(environ)
elif c.view != 'js':
html = render('/derived/projects/vcsindex.html')
else:
html = ''
c.rclose.append(html)
return c.rclose
def edit_summary(self, attach, summary='', doclose=None, byuser=None):
"""Edit the summary text for already created attachment, specified by,
`attach` which can be,
`id` or `Attachment` instance."""
from zeta.config.environment import userscomp, tlcomp, srchcomp
attach = self.get_attach(attach)
msession = meta.Session()
with msession.begin(subtransactions=True):
attach.summary = summary
log = 'Updated summary, `%s`' % summary
# Post processing, optional deferred handling
def onclose(tlcomp, srchcomp, attach, log, byuser):
srchcomp.indexattach([attach], replace=True)
attach and tlcomp.log(byuser, log, attach=attach)
doclose(h.hitchfn(onclose, tlcomp, srchcomp, attach, log, byuser))
return attach
def remove_license(self, license, doclose=False, byuser=None):
"""Remove the license instance identified by,
`licence` which can be,
`id` or `licensename` or License instance.
"""
from zeta.config.environment import tlcomp, srchcomp
msession = meta.Session()
license = self.get_license(license)
licname = license and license.licensename or ''
with msession.begin(subtransactions=True):
license and msession.delete(license)
# Post processing, optional deferred handling
def onclose(tlcomp, licname, byuser):
tlcomp.log(byuser, 'deleted license %s' % licname)
doclose(h.hitchfn(onclose, tlcomp, licname, byuser))
return None
def index( self, environ ) :
"""Action to handle siteadministration"""
from zeta.config.environment import projcomp, vfcomp, userscomp
c.rclose = h.ZResp()
# Form handling
def errhandler(errmsg) :
c.errmsg = errmsg
vfcomp.process(
request, c,
defer=True, errhandler=h.hitchfn(errhandler),
formnames=[ 'system', 'userenb', 'userdis', 'prjenb', 'prjdis',
'adduserperms', 'deluserperms', 'createpg',
'updatepg', 'addpntopg', 'delpnfrompg' ]
)
# Setup context for page rendering
if c.jsonobj not in [ 'pgmap' ] :
c.licenselist = self._licenselist()
c.permnames = sorted( userscomp.perm_names )
c.usernames, userperms, c.userstatus = userscomp.siteadmin()
defuser = sorted(userperms.keys())[0]
c.defuserperms = [ defuser, sorted(userperms[defuser][0]),
userperms[defuser][1] ]
c.projectstatus = projcomp.projectstatus
c.liceditable = True
c.title = 'SiteAdmin'
# Html page generation
if c.errmsg :
html = self.returnerrmsg(environ)
elif c.view == 'js' and c.jsonobj :
html = self.handlejson(environ)
elif c.view != 'js' :
html = render( '/derived/siteadmin/siteadmin.html' )
else :
html = ''
c.rclose.append(html)
return c.rclose
def delete_vcs(self, vcs, doclose=None, byuser=None):
"""Delete the vcs entry identified by,
`vcs` which can be,
`id` or `Vcs` instance"""
from zeta.config.environment import userscomp, prjcomp, tlcomp
vcs = self.get_vcs(vcs)
project = vcs.project
name = vcs.name
msession = meta.Session()
with msession.begin(subtransactions=True):
log = 'deleted project repository, `%s`' % vcs.name
msession.delete(vcs)
# Post processing, optional deferred handling
def onclose(tlcomp, project, byuser, log):
tlcomp.log(byuser, log, project=project)
doclose(h.hitchfn(onclose, tlcomp, project, byuser, log))
return None
def remove_attach(self, wiki, attach, doclose=None, byuser=None):
"""Remove attachment to the wiki identified by,
`wiki` which can be,
`id` or `wikiurl` or `Wiki` instance.
`attach` can be
`id` or `resource_url` or `Attachment` instance."""
from zeta.config.environment import attachcomp, tlcomp, srchcomp
log = ''
wiki = self.get_wiki(wiki)
attach = attachcomp.get_attach(attach)
if wiki:
attachcomp.model_remove_attach(attach, wiki, byuser=byuser)
log = 'deleted attachment, `%s`' % attach.filename
# Post processing, optional deferred handling
def onclose(tlcomp, wiki, byuser, log):
tlcomp.log(byuser, log, wiki=wiki)
doclose(h.hitchfn(onclose, tlcomp, wiki, byuser, log))
return None
def remove_staticwiki(self, paths=None, doclose=None, byuser=None):
"""Remove the static wiki page identified by 'path'"""
from zeta.config.environment import tlcomp, srchcomp
if isinstance(paths, (str, unicode)):
paths = [paths]
swikis = self.get_staticwiki()
msession = meta.Session()
with msession.begin(subtransactions=True):
if paths:
[msession.delete(sw) for sw in swikis if sw.path in paths]
else:
[msession.delete(sw) for sw in swikis]
log = 'deleted guest wiki pages,\n%s' % ', '.join(paths)
# Post processing, optional deferred handling
def onclose(tlcomp, byuser, log):
tlcomp.log(byuser, log)
doclose(h.hitchfn(onclose, tlcomp, byuser, log))
return None
