def delete(self):
ids = self.GetFormValue("ids")
confirm = self.GetFormValue("confirm")
users = []
msgs = []
root = self.context.root()
if isinstance(ids, basestring):
ids = (ids,)
elif not ids:
ids = ()
for i in ids:
u = root.GetUserByID(i, activeOnly=0)
if not u:
msgs.append(self.Translate(_(u"User not found. (id %(name)s)", mapping={"name": i})))
else:
users.append(u)
result = True
if confirm:
for u in users:
name = u.data.name
if not root.Delete(id=u.id, obj=u, user=self.User()):
result = False
msgs.append(self.Translate(_(u"Delete failed: User '%(name)s'", mapping={"name": u.meta.title})))
users=()
if result:
if len(ids)>1:
msgs.append(self.Translate(_(u"OK. Users deleted.")))
else:
msgs.append(self.Translate(_(u"OK. User deleted.")))
return self.Redirect(self.Url(root), msgs)
return {"ids": ids, "users":users, "result": result, "msgs": msgs, "confirm": confirm}
def UpdateSort(self, objs, user):
""" update pool_sort values according to list """
if not objs:
return False, _(u"List is empty")
if isinstance(objs, basestring):
objs = ConvertToNumberList(objs)
ids = []
for oi in objs:
# check if listed objects are objects or ids
if not IObject.providedBy(oi):
ids.append(int(oi))
if ids:
# load remaining objects by id
objs2 = self.GetObjsBatch(ids)
pos = 10
processed = []
for obj in objs:
if not IObject.providedBy(obj):
for o in objs2:
if o.id == int(obj):
obj = o
break
if not IObject.providedBy(obj):
continue
if obj.id in processed:
continue
processed.append(obj.id)
obj.meta.set("pool_sort", pos)
obj.CommitInternal(user)
pos += 10
return True, _(u"OK")
def GetAdminWidgets(self):
url = self.FolderUrl(self.context.root())
confs = [
Conf(id="admin.root", viewmapper=url+"list", name=_(u"List users")),
Conf(id="admin.add", viewmapper=url+"add", name=_(u"Add user"))
]
return confs
def Paste(self, ids, pos, user):
"""
Paste the copied object with id to this object
"""
root = self.GetRoot()
new = []
msgs = []
result = True
for id in ids:
id = int(id)
if self.GetID() == id:
continue
obj = root.LookupObj(id, preload="skip")
if not obj:
msgs.append(_(u"Object not found"))
result = False
continue
newobj = self.Duplicate(obj, user)
if not newobj:
raise TypeError, "Duplicate failed"
if ISort.providedBy(self):
self.InsertAfter(newobj.id, pos, user=user)
new.append(newobj)
if not self.app.configuration.autocommit:
for o in new:
o.Commit(user)
if result:
msgs.append(_(u"OK. Copied and pasted."))
return result, msgs
def Update(self, action, **kw):
"""
Process request data and update object.
returns bool, html
"""
redirectSuccess = kw.get("redirectSuccess")
msgs = []
conf=self.context
result,data,errors = self.Validate(self.request)
if result:
# lookup persistent manager for configuration
storage = self.app.Factory(IModuleConf, "persistence")
if storage:
storage(app=self.app, configuration=conf).Save(data)
msgs.append(_(u"OK. Data saved."))
else:
msgs.append(_(u"No persistent storage for configurations activated. Nothing saved."))
result = False
errors=None
if self.view and redirectSuccess:
redirectSuccess = self.view.ResolveUrl(redirectSuccess, obj)
if self.use_ajax:
self.view.Relocate(redirectSuccess, messages=msgs, raiseException=True)
else:
self.view.Redirect(redirectSuccess, messages=msgs, raiseException=True)
return result, self.Render(data, msgs=msgs, errors=errors)
def _Run(self, **values):
result = 1
codepage="utf-8"
app = self.app
datapool = app.db
conf = app.dbConfiguration
conn = datapool.connection
system = values.get("excludeSystem")
self.filename = app.configuration.id + ".json"
if not conn:
self.stream.write(_(u"Database connection error (${name})\n", mapping={u"name": app.dbConfiguration.context}))
return 0
if not conn.IsConnected():
self.stream.write(_(u"Database connection error (${name})\n", mapping={u"name": app.dbConfiguration.context}))
return 0
def mapfields(fields):
a=[]
for f in fields:
a.append(f.id)
return a
export = [(MetaTbl,mapfields(app.GetAllMetaFlds(ignoreSystem=False)))]
for t in app.GetAllObjectConfs():
export.append((t.dbparam, ["id"]+mapfields(t.data)))
for t in Structure.items():
export.append((t[0], mapfields(t[1]["fields"])))
data = {}
for table in export:
#tablename
tablename=table[0]
if system and tablename in system:
continue
#fields
fields=table[1]
columns = (",").join(fields)
sql="select %s from %s" % (columns, tablename)
c = conn.cursor()
c.execute(sql)
tvalues = []
for rec in c.fetchall():
recvalue = {}
pos = 0
for col in rec:
recvalue[fields[pos]] = col
pos+=1
tvalues.append(recvalue)
data[tablename] = tvalues
self.stream.write(JsonDataEncoder().encode(data))
return 1
def update(self):
user=self.User()
if user and user.id == 0:
return {u"content": _(u"Your current user can only be edited on file system level."), u"result": False, u"head": self.form.HTMLHead()}
self.form.Setup(subset="edit")
try:
result, data, action = self.form.Process()
return {u"content": data, u"result": result, u"head": self.form.HTMLHead()}
except Unauthorized:
return {u"content": _(u"User not found"), u"result": False, u"head": self.form.HTMLHead()}
def delfile(self):
file = self.GetFormValue(u"fid")
try:
r=self.context.DeleteFile(file, self.User())
if not r:
m=_(u"Delete failed")
else:
m=_(u"OK")
except Exception, e:
m=str(e)
def _Run(self, **values):
result = 1
codepage="utf-8"
app = self.app
datapool = app.db
conf = app.dbConfiguration
conn = datapool.connection
system = values.get("excludeSystem")
self.filename = app.configuration.id + ".sql"
if not conn:
self.stream.write(_(u"Database connection error (${name})\n", mapping={u"name": app.dbConfiguration.context}))
return 0
if not conn.IsConnected():
self.stream.write(_(u"Database connection error (${name})\n", mapping={u"name": app.dbConfiguration.context}))
return 0
def mapfields(fields):
a=[]
for f in fields:
a.append(f.id)
return a
export = [(MetaTbl,mapfields(app.GetAllMetaFlds(ignoreSystem=False)))]
for t in app.GetAllObjectConfs():
export.append((t.dbparam, ["id"]+mapfields(t.data)))
for t in Structure.items():
export.append((t[0], mapfields(t[1]["fields"])))
for table in export:
#tablename
tablename=table[0]
if system and tablename in system:
continue
#fields
fields=table[1]
columns = (",").join(fields)
sql="select %s from %s" % (columns, tablename)
c = conn.cursor()
c.execute(sql)
for rec in c.fetchall():
data = []
for col in rec:
data.append(conn.FmtParam(col))
data = (",").join(data)
if not isinstance(data, unicode):
data = unicode(data, codepage)
value = u"INSERT INTO %s (%s) VALUES (%s);\n"%(tablename, columns, data)
value = value.encode(codepage)
self.stream.write(value)
return 1
def Move(self, ids, pos, user):
"""
Move the object with id to this object
Events
- beforeAdd(data=obj.meta, type=type)
- afterDelete(id=obj.id)
- moved()
- afterAdd(obj=obj)
"""
root = self.root()
oldParent=None
moved = []
msgs = []
result = True
for id in ids:
id = int(id)
if self.GetID() == id:
continue
obj = root.LookupObj(id, preload="skip")
if not obj:
msgs.append(_(u"Object not found"))
result = False
continue
type=obj.GetTypeID()
# allow subobject
if not self.IsTypeAllowed(type, user):
raise TypeError, "Object cannot be added here"
self.Signal("beforeAdd", data=obj.meta, type=type)
if not oldParent or oldParent.id != obj.GetParent().id:
oldParent = obj.GetParent()
obj.__parent__ = self
obj.meta["pool_unitref"] = self.GetID()
oldParent.Signal("afterDelete", id=obj.id)
obj.Signal("moved")
#obj.Close()
moved.append(obj)
for o in moved:
o.Commit(user)
if ISort.providedBy(self):
self.InsertAfter(o.id, pos, user=user)
self.Signal("afterAdd", obj=o)
if result:
msgs.append(_(u"OK. Cut and pasted."))
return result, msgs
def _Run(self, **values):
result = 1
importWf = 1
importSecurity = 0
showSystem = values.get("showSystem")
modify = values.get("modify")
request = values["original"]
ignoreTables = self.app.configuration.get("skipUpdateTables", ())
try:
localizer = get_localizer(get_current_request())
except:
localizer = FakeLocalizer()
# localizer.translate(term)
text = _(
u""" <div class="well">
This tool compares the physically existing database structure (tables, columns) with the current configuration settings.
The database structure is shown on the left, configuration settings on the right. <br><br>
Existing database columns will only be altered if manually selected in the 'Modify' column. Modifying a table may destroy the data
stored (e.g if converted from string to integer), so don't forget to create backups of the database before modifying anything.<br>
By default this tool will only create new tables and columns and never delete any column.
</div> """
)
self.stream.write(localizer.translate(_(text)))
self.stream.write(
u"""<form action="" method="post">
<input type="hidden" name="tag" value="dbStructureUpdater">
<input type="hidden" name="modify" value="1">"""
)
app = self.app
try:
conf = app.dbConfiguration
connection = app.NewConnection()
if not connection:
self.stream.write(
localizer.translate(
_(u"""<div class="alert alert-error">No database connection configured</div>""")
)
)
return 0
except OperationalError, e:
self.stream.write(
localizer.translate(_(u"""<div class="alert alert-error">No database connection configured</div>"""))
)
return 0
def RenderField(self, fld, data=None, context=None):
"""
Render the data field for html display. Rendering depends on the datatype defined
in the field configuration.
If data is None the current context is used.
returns string
"""
if context is None:
context = self.context
if isinstance(fld, basestring):
fld = context.GetFieldConf(fld)
if not fld:
return _(u"<em>Unknown field</em>")
if data is None:
data = context.data.get(fld['id'], context.meta.get(fld['id']))
if fld['datatype']=='file':
url = self.FileUrl(fld['id'])
if not url:
return u""
url2 = url.lower()
if url2.find(u".jpg")!=-1 or url2.find(u".jpeg")!=-1 or url2.find(u".png")!=-1 or url2.find(u".gif")!=-1:
return u"""<img src="%s">""" % (url)
return u"""<a href="%s">download</a>""" % (url)
return FieldRenderer(context).Render(fld, data, context=context)
def editroot(self):
root = self.context.app.root(name="")
if not IPersistentRoot.providedBy(root):
return {u"content": _(u"The default root does not support persistent data storage."), u"result": False, u"head": u""}
fields = (
FieldConf(id=u"pool_filename", datatype="string", size=30, required=1, name=_(u"Root url name"),
settings={"validator": RootnameValidator}, default=root.configuration.id),
FieldConf(id=u"title", datatype="string", size=255, required=0, name=_(u"Root title"), default=root.configuration.name),
FieldConf(id=u"description", datatype="text", size=5000, required=0, name=_(u"Root description")),
FieldConf(id="pool_groups", datatype="checkbox", size=250, default="", name=_(u"Permission"),
description=_(u"Only displayed to users in the selected group"))
)
form = RootForm(view=self, context=root, app=self.context)
form.fields = fields
form.Setup()
# process and render the form.
result, data, action = form.Process()
return {u"content": data, u"result": result, u"head": form.HTMLHead()}
def design(self):
fields = (
FieldConf(id=u"columns", datatype="lines", size=100, required=0, name=_(u"Column names"), description=_(u"Column names used in the main template. For multiple columns enter one per line.")),
)
form = ConfigurationForm(view=self, context=self.context.configuration, app=self.context)
form.fields = fields
form.Setup()
# process and render the form.
result, data, action = form.Process()
return {u"content": data, u"result": result, u"head": form.HTMLHead()}
def elementListWidget(self, obj=None, elements=None, addResponse=True):
"""
Widget with existing elements list and edit options
call with obj = current object / page
"""
#i18n?
if not obj:
obj=self.context
html = u"""<div>
<h4 onclick="$.fn.editblocks().toggleBlock('#elements%(id)s',event)">%(title)s</h4>
%(blocks)s
</div>
"""
elHtml = u"""<div class="element">
<div class="el_title">%(title)s</div>
<div class="el_options">%(options)s</div>
<br style="clear:both"/>
</div>"""
if not elements:
elements = obj.GetPageElements()
localizer = translator(self.request)
blocks = StringIO()
static = self.StaticUrl("nive.cms.cmsview:static/images/types/")
for el in elements:
t = el.GetTitle()
if not t:
t = u"<em>%s</em>" % (localizer(el.GetTypeName(), self.request))
if el.GetTypeID()=="box":
title = u"<img src='%s%s.png' align='top'/> %s: %s" % (static, el.GetTypeID(), localizer(u"Box"), t)
blocks.write(elHtml % {u"title": title, u"options": self.editBlockList(obj=el, showCCP=True)})
for elb in el.GetPageElements():
t = elb.GetTitle()
if not t:
t = u"<em>%s</em>" % (localizer(elb.GetTypeName()))
title = u"> <img src='%s%s.png' align='top'/> %s" % (static, elb.GetTypeID(), t)
blocks.write(elHtml % {u"title": title, u"options": self.editBlockList(obj=elb, showCCP=True)})
else:
title = u"<img src='%s%s.png' align='top'/> %s" % (static, el.GetTypeID(), t)
blocks.write(elHtml % {u"title": title, u"options": self.editBlockList(obj=el, showCCP=True)})
if not len(elements):
blocks.write(localizer(_(u"<p><i>empty</i></p>")))
data = html % {u"blocks": blocks.getvalue(), u"id": str(obj.GetID()), u"title": localizer(_(u"Page elements"))}
if addResponse:
r = Response(content_type="text/html", conditional_response=True)
r.unicode_body = data
return r
return data
def selectPageElement(self):
user = self.User()
lt = self.context.GetAllowedTypes(user)
tmpl = u"""<a href="add?pool_type=%s" rel="niveOverlay" class="nivecms addlink">%s</a> """
html = StringIO()
html.write(u"""<div class="addElements">""")
#opt
for t in lt:
html.write(tmpl % (t[u"id"], _(t[u"name"])))
html.write(u"</div>")
return html.getvalue()
def action(self):
transition = self.GetFormValue(u"t")
url = self.GetFormValue("redirect_url")
if not url:
url = self.PageUrl()
user = self.User()
self.context.WfAction("", user, transition=transition)
self.context.CommitInternal(user)
msg = _(u"OK")
self.Redirect(url, messages=[msg])
def copy(self):
"""
"""
ids = self.GetFormValue(u"ids")
if not ids:
ids = [self.context.id]
cp = self.SetCopyInfo(u"copy", ids, self.context)
url = self.GetFormValue(u"url")
if not url:
url = self.PageUrl(self.context)
msgs = _(u"OK. Copied.")
return self.Redirect(url, [msgs])
def RootnameValidator(node, value):
"""
Makes sure the new name does not exist.
"""
# lookup name in database
app = node.widget.form.context.app
for root in app.GetAllRootConfs():
if root.id == value:
# check if its the context
if app.root(root.id)!=node.widget.form.context:
err = _(u"'${name}' already in use. Please choose a different name.", mapping={'name':value})
raise Invalid(node, err)
def __init__(self, configuration = None):
"""
Events:
- init(configuration)
"""
self.components = []
self.groups = [Conf(id=u"authenticated", name=_(u"Authenticated"), visible=True)]
self.__acl__ = [(Allow, "group:admin", ALL_PERMISSIONS)]
self.configuration = configuration or PortalConf()
self.Signal("init", configuration=self.configuration)
def delete(self):
id = self.GetFormValue(u"id")
result = {u"msgs": [], u"objToDelete": None, u"content":u"", u"cmsview": self, u"result": False}
if not id:
result[u"msgs"] = [_(u"Nothing to delete")]
return result
delete = self.GetFormValue(u"delete")
obj = self.context.obj(id)
if not obj:
result[u"msgs"] = [_(u"Object not found")]
return result
if obj.IsContainer() and delete != u"1":
result[u"objToDelete"] = obj
return result
result[u"result"] = self.context.Delete(id, user=self.User(), obj=obj)
if result[u"result"]:
result[u"msgs"] = [_(u"OK. Deleted.")]
self.Relocate("""<script type="text/javascript">window.parent.close("%s");</script>""" % (self.PageUrl()),
[_(u"OK. Deleted.")],
raiseException=True)
return result
def _Run(self, **values):
try:
localizer = get_localizer(get_current_request())
except:
localizer = FakeLocalizer()
app = self.app
datapool = app.db
conn = datapool.connection
c = conn.cursor()
self.stream.write(u"<table>\n")
sql = "select count(*) from pool_meta"
c.execute(sql)
rec = c.fetchall()
self.stream.write(localizer.translate(_(u"<tr><th>Elements in total</th><td>${value}</td></tr>\n", mapping={u"value": rec[0][0]})))
sql = "select count(*) from pool_files"
c.execute(sql)
rec = c.fetchall()
self.stream.write(localizer.translate(_(u"<tr><th>Physical files</th><td>${value}</td></tr>\n", mapping={u"value": rec[0][0]})))
sql = "select sum(size) from pool_files"
c.execute(sql)
rec = c.fetchall()
self.stream.write(localizer.translate(_(u"<tr><th>Physical files size</th><td>${value}</td></tr>\n", mapping={u"value": FormatBytesForDisplay(rec[0][0])})))
for t in app.GetAllObjectConfs():
sql = "select count(*) from pool_meta where pool_type='%s'" % t.id
c.execute(sql)
rec = c.fetchall()
self.stream.write(localizer.translate(_(u"<tr><th>${name}</th><td>${value}</td></tr>\n", mapping={u"name": t.name, u"value": rec[0][0]})))
self.stream.write(u"</table>\n")
c.close()
return 1
def editdatabase(self):
dbtypes=[{"id":"MySql","name":"MySql"},{"id":"Sqlite3","name":"Sqlite3"}]
fields = (
FieldConf(id=u"context", datatype="list", size=20, required=1, name=_(u"Database type to be used"), listItems=dbtypes,
description=_(u"Supports 'Sqlite3' and 'MySql' by default. MySql requires python-mysqldb installed.")),
FieldConf(id=u"fileRoot", datatype="string", size=500, required=0, name=_(u"Relative or absolute root directory for files")),
FieldConf(id=u"dbName", datatype="string", size=500, required=1, name=_(u"Database file path or name"),
description=_(u"Sqlite3=database file path, MySql=database name")),
FieldConf(id=u"host", datatype="string", size=100, required=0, name=_(u"Database server host")),
FieldConf(id=u"port", datatype="number", size=8, required=0, name=_(u"Database server port")),
FieldConf(id=u"user", datatype="string", size=100, required=0, name=_(u"Database server user")),
FieldConf(id=u"password", datatype="password", size=100,required=0, name=_(u"Database server password")),
)
form = ConfigurationForm(view=self, context=self.context.dbConfiguration, app=self.context)
form.fields = fields
form.Setup()
# process and render the form.
result, data, action = form.Process()
return {u"content": data, u"result": result, u"head": form.HTMLHead()}
def __init__(self, view=None, loadFromType=None, context=None, request=None, app=None, **kw):
ObjectForm.__init__(self, view=view, loadFromType=loadFromType)
self.actions = [
Conf(id="default", method="StartForm", name=_(u"Initialize"), hidden=True),
Conf(id="defaultEdit",method="LoadUser", name=_(u"Initialize"), hidden=True),
Conf(id="create", method="AddUser", name=_(u"Signup"), hidden=False, options={"renderSuccess":False}),
Conf(id="edit", method="Update", name=_(u"Confirm"), hidden=False),
Conf(id="mailpass", method="MailPass", name=_(u"Mail password"), hidden=False),
Conf(id="resetpass", method="ResetPass", name=_(u"Reset password"), hidden=False),
Conf(id="login", method="Login", name=_(u"Login"), hidden=False),
]
self.subsets = {
"create": {"fields": ["name", "password", "email", "surname", "lastname"],
"actions": ["create"],
"defaultAction": "default"},
"create2":{"fields": ["name", "email"],
"actions": ["create"],
"defaultAction": "default"},
"edit": {"fields": ["email",
FieldConf(id="password", name=_("Password"), datatype="password", required=False, settings={"update": True}),
"surname", "lastname"],
"actions": ["defaultEdit", "edit"],
"defaultAction": "defaultEdit"},
"login": {"fields": ["name", FieldConf(id="password", name=_("Password"), datatype="password", settings={"single": True})],
"actions": ["login"],
"defaultAction": "default"},
"mailpass":{"fields": ["email"],
"actions": ["mailpass"],
"defaultAction": "default"},
"resetpass":{"fields": ["email"],
"actions": ["resetpass"],
"defaultAction": "default"},
}
self.activate = 1
self.generatePW = 0
self.notify = True
self.mail = None
self.mailpass = None
self.groups = ""
self.css_class = "smallform"
def _Run(self, **values):
try:
localizer = get_localizer(get_current_request())
except:
localizer = FakeLocalizer()
app = self.app
root = app.root()
datapool = app.db
conn = datapool.connection
c = conn.cursor()
# delete
sql = u"delete from pool_fulltext"
c.execute(sql)
c.close()
conn.commit()
self.stream.write(localizer.translate(_(u"Deleted previous fulltext index.<br>")))
pages = root.Select(parameter={"pool_stag":10,"pool_state":1})
cnt = len(pages)
err = 0
for page in pages:
page = page[0]
obj = root.LookupObj(page)
if not obj:
err += 1
self.stream.write(localizer.translate(_(u"Error: Unable to open page (${id}).<br>", mapping={"id":page})))
else:
try:
obj.UpdateFulltext()
except Exception, e:
err += 1
self.stream.write(localizer.translate(_(u"Error: Unable to update page (${id}).<br>", mapping={"id":page})))
self.stream.write(unicode(e))
self.stream.write(u"<br><br>")
def pageListWidget(self, page=None, pages=None):
"""
Widget with existing pages list and edit options
call with page = current page
"""
if not page:
page=self.context
html = u"""<div class="subpages"> %(blocks)s </div>"""
pHtml = u"""<div class="element">
<div class="el_title">%(workflow)s<a href="%(url)s">%(title)s </a> </div>
<div class="el_options">%(options)s</div>
<br style="clear:both"/>
</div>"""
useworkflow = 1
localizer = translator(self.request)
static = self.StaticUrl("nive.cms.workflow:static/exclamation.png")
if not pages:
pages = page.GetPages(includeMenu=1)
blocks = StringIO()
for p in pages:
wf = u""
if useworkflow and not p.meta.pool_state:
wf = u"""<a href="%(url)sworkflow" class="right" rel="niveOverlay"><img src="%(static)s" title="%(name)s"/></a>""" % {
u"static": static,
u"url": self.FolderUrl(p),
u"name": localizer(_(u"This page is not public."))
}
title = p.meta.get(u"title")
options = self.editBlockList(obj=p, page=page)
blocks.write(pHtml % {u"url": self.FolderUrl(p), u"title": title, u"options": options, u"workflow": wf})
if not len(pages):
blocks.write(localizer(_(u"<p><i>no sub pages</i></p>")))
return html % {u"blocks": blocks.getvalue()}
def printStructure(self, structure, table, fmt, db, localizer):
header = u"""
<h4>%(Table)s: %(tablename)s</h4>
<table class="table"><tbody>
<tr><td colspan="5">%(Db Columns)s</td> <td colspan="2">%(Configuration settings)s</td></tr>
<tr><td>%(ID)s</td><td>%(Type)s</td><td>%(Default)s</td><td>%(Settings)s</td> <td>%(Modify?)s</td><td></td></tr>
""" % {"tablename":table,
"Table": localizer.translate(_(u"Table")),
"Db Columns": localizer.translate(_(u"Database settings")),
"Configuration settings": localizer.translate(_(u"Configuration settings")),
"ID":localizer.translate(_(u"ID")),
"Type":localizer.translate(_(u"Type")),
"Default":localizer.translate(_(u"Default")),
"Settings":localizer.translate(_(u"Settings")),
"Modify?":localizer.translate(_(u"Modify?"))
}
row = u"""
<tr><td>%(id)s</td><td>%(type)s</td><td>%(default)s</td><td>Not null: %(null)s, Identity: %(identity)s</td> <td>%(Modify)s</td><td>%(Conf)s</td></tr>
"""
cb = u"""
<input type="checkbox" name="%s" value="%s">"""
footer = u"""
</tbody></table> <br/>"""
self.stream.write(header)
for col in structure:
id = col
col = structure[col].get("db")
if not col:
col = {"id":id, "type": u"", "default": u"", "null": u"", "identity": u""}
conf = u""
for d in fmt:
if col and d["id"].upper() == col["id"].upper():
conf = db.ConvertConfToColumnOptions(d)
break
col["Modify"] = cb % (table, id)
col["Conf"] = conf
self.stream.write(row % col)
self.stream.write(footer)
return
def Update(self, action, **kw):
"""
Form action: safely update a user
"""
user = self.view.User()
if not user:
raise Unauthorized, "User not found."
msgs = []
result,data,errors = self.Validate(self.request)
if result:
uobj = self.context.LookupUser(id=user.id)
result = uobj.SecureUpdate(data, user)
if result:
msgs.append(_(u"OK"))
return self._FinishFormProcessing(result, data, msgs, errors, **kw)
def SecureUpdate(self, data, user):
"""
Update existing user data.
name, groups, pool_state cannot be changed
"""
if data.has_key("name"):
del data["name"]
if data.has_key("groups"):
del data["groups"]
if data.has_key("pool_state"):
del data["pool_state"]
if not self.Update(data, user):
return False, [_(u"Update failed.")]
self.Commit(user)
return True, []
def Process(self, images=None, profiles=None):
"""
Process images and create versions from profiles. ::
images = list of image field ids to process. if none all images based on
selected profiles are processed.
profiles = list of profiles to process. if none all profiles are
processed
returns result, messages
Example: If `Process(images=['highres'],profiles=None)` all versions with
`source=highres` are updated.
Events:
updateImage(profile)
"""
if not PILloaded:
return False, [_(u"Python image library (PIL) not installed.")]
convert = []
if not images:
for p in self.configuration.imageProfiles:
if not self._CheckCondition(p):
continue
convert.append(p)
else:
for p in self.configuration.imageProfiles:
if not self._CheckCondition(p):
continue
if p.source in images:
convert.append(p)
if not convert:
return True
msgs = []
result = True
for profile in convert:
r, m = self._Convert(profile)
msgs += m
if not r:
result = False
else:
self.Signal("updateImage", profile=profile)
return result, msgs
def _Run(self, **values):
"""
"""
host = values.get("host")
port = values.get("port")
sender = values.get("sender")
user = values.get("user")
pass_ = values.get("pass_")
fromName = values.get("fromName")
fromMail = values.get("fromMail")
replyTo = values.get("replyTo")
recvids = values.get("recvids")
recvrole = values.get("recvrole")
recvmails = values.get("recvmails")
cc = values.get("cc")
bcc = values.get("bcc")
title = values.get("title")
body = values.get("body")
html = values.get("html")
utf8 = values.get("utf8")
ssl = values.get("ssl")
showToListInHeader = values.get("showToListInHeader")
force = values.get("force")
debug = values.get("debug")
maillog = values.get("maillog")
log = logging.getLogger(maillog or "sendMail")
# lookup receivers
recvs = []
if recvmails:
if isinstance(recvmails, basestring):
recvs.append((recvmails, u""))
else:
recvs.extend(recvmails)
if recvids or recvrole:
recvs.extend(self._GetRecv(recvids, recvrole, force, self.app))
if cc:
cc = self._GetRecv(cc, None, force, self.app)
if cc:
recvs.extend(cc)
if bcc:
bcc = self._GetRecv(bcc, None, force, self.app)
if bcc:
recvs.extend(bcc)
if len(recvs) == 0:
self.stream.write(_(u"No receiver for the e-mail! Aborting."))
return 0
temp = []
for r in recvs:
temp.append(self._GetMailStr(r))
to = temp
temp = []
for r in cc:
temp.append(self._GetMailStr(r))
cc = temp
temp = []
for r in bcc:
temp.append(self._GetMailStr(r))
bcc = temp
if fromMail and fromMail != u"":
senderMail = sender
else:
fromMail = sender
senderMail = u""
contentType = u"text/plain"
if html:
contentType = u"text/html"
if utf8:
contentType += u"; charset=utf-8"
if debug:
mails_original = u""
for m in recvs:
mails_original += m + u"\r\n<br>"
body += u"""\r\n<br><br>\r\nDEBUG\r\n<br> Original receiver: \r\n<br>""" + mails_original
# in debug mode use default receiver mail as receiving address for all mails
recvs = [(recvmails, u"")]
result = 1
if showToListInHeader:
self.stream.write((u", ").join(r))
else:
for recv in recvs:
self.stream.write(recv[0] + u" ok, ")
if maillog:
logdata = u"%s - %s - %s" % (recv[0], recv[1], title)
log.debug(u" %s", logdata)
return result
def _Run(self, **values):
result = 1
codepage = "utf-8"
app = self.app
datapool = app.db
conf = app.dbConfiguration
conn = datapool.connection
tree = values.get("tree")
filedata = values.get("filedata")
self.filename = app.configuration.id + ".json"
if not conn:
self.stream.write(
_(u"Database connection error (${name})\n",
mapping={u"name": app.dbConfiguration.context}))
return 0
if not conn.IsConnected():
self.stream.write(
_(u"Database connection error (${name})\n",
mapping={u"name": app.dbConfiguration.context}))
return 0
def mapfields(fields):
return [f.id for f in fields]
metaflds = mapfields(app.GetAllMetaFlds(ignoreSystem=False))
def exportObj(o):
values = {"__items__": []}
for field in metaflds:
values[field] = o.meta.get(field)
for field in o.configuration.data:
if field["datatype"] == "file":
file = o.files.get(field.id)
if not file:
continue
values[field.id] = {
"filename": file.filename,
"size": file.size
}
if filedata == "path":
values[field.id]["path"] = file.path
elif filedata == "data":
values[field.id]["data"] = base64.b64encode(
file.read())
else:
values[field.id] = o.data.get(field.id)
if IContainer.providedBy(o):
for child in o.GetObjs():
cv = exportObj(child)
values["__items__"].append(cv)
return values
root = app.root()
data = {"__items__": []}
for child in root.GetObjs():
cv = exportObj(child)
data["__items__"].append(cv)
if not tree:
def getlist(values, datalist):
for v in values["__items__"]:
datalist = getlist(v, datalist)
del values["__items__"]
datalist.append(values)
return datalist
data = getlist(data, [])
self.stream.write(ConfEncoder().encode(data))
return 1
from nive.i18n import _
from nive.definitions import StagPageElement, ObjectConf, FieldConf
from nive.components.objects.base import PageElementBase
class spacer(PageElementBase):
pass
# type definition ------------------------------------------------------------------
#@nive_module
configuration = ObjectConf(
id = "spacer",
name = _(u"Spacer"),
dbparam = "spacers",
context = "nive.cms.spacer.spacer",
template = "spacer.pt",
selectTag = StagPageElement,
icon = "nive.cms.cmsview:static/images/types/spacer.png",
description = _(u"Styling element to add line breaks and vertical space between elements.")
)
css =[ {'id': u'bo', 'name': _(u'Border')},
{'id': u'h0', 'name': _(u'Invisible')},
{'id': u'h1', 'name': _(u'1 line')},
{'id': u'h2', 'name': _(u'2 lines')},
{'id': u'h3', 'name': _(u'3 lines')},
{'id': u'h4', 'name': _(u'4 lines')},
]
continue
if isinstance(e, tuple):
e = list(e)
e.append(extension)
c.unlock()
c.extensions = tuple(e)
c.lock()
add(app.GetAllRootConfs())
add(app.GetAllObjectConfs())
toolconf = ToolConf(
id = "updatefulltext",
context = "nive_cms.extensions.fulltextpage.RewriteFulltext",
name = _(u"Rewrite fulltext index"),
description = _("Delete and rewrite the fulltext index."),
apply = (IApplication,),
mimetype = "text/html",
data = [],
views = [
ViewConf(name="", view=ToolView, attr="form", permission="system", context="nive_cms.extensions.fulltextpage.RewriteFulltext")
]
)
configuration = ModuleConf(
id = "pagefulltext",
name = u"Web page fulltext extension",
context = PageFulltext,
events = (Conf(event="startRegistration", callback=SetupFulltext),),
modules = [toolconf]
from nive.i18n import _
from nive.definitions import ViewConf, ViewModuleConf, FieldConf, WidgetConf, Conf
from nive.definitions import IApplication, IUser, IAdminWidgetConf, IUserDatabase, IPersistent, IModuleConf, IViewModuleConf
from nive.definitions import IWebsiteRoot, ICMSRoot
from nive.views import BaseView
from nive.forms import ValidationError, HTMLForm
from nive.extensions.persistentRoot import IPersistentRoot
from nive.utils.utils import SortConfigurationList, ConvertDictToStr
# view module definition ------------------------------------------------------------------
#@nive_module
configuration = ViewModuleConf(
id="administration",
name=_(u"Administration"),
context=IApplication,
view="nive.adminview.view.AdminView",
templates="nive.adminview:",
template="index.pt",
permission="administration",
adminLink=u"app_folder_url/admin",
static="nive.adminview:static",
assets=[
('bootstrap.min.css',
'nive.adminview:static/mods/bootstrap/css/bootstrap.min.css'),
('adminview.css', 'nive.adminview:static/adminview.css'), # nive css
('jquery.js', 'nive.adminview:static/mods/jquery.min.js'),
('bootstrap.min.js',
'nive.adminview:static/mods/bootstrap/js/bootstrap.min.js'),
],
from nive.workflow import WfProcessConf, WfStateConf, WfTransitionConf
from nive.i18n import _
# change pool_state to publish or revoke
def publish(transition, context, user, values):
context.meta.set("pool_state", 1)
def revoke(transition, context, user, values):
context.meta.set("pool_state", 0)
wfProcess = WfProcessConf(
id="default",
name=_(u"Simple Publishing Workflow"),
apply=(IPage, ),
states=(WfStateConf(id="start",
name=_(u"New object"),
actions=("delete", "duplicate", "edit", "add",
"remove")),
WfStateConf(id="edit",
name=_(u"Edit"),
actions=("delete", "duplicate", "edit", "add",
"remove")),
WfStateConf(id="public",
name=_(u"Public"),
actions=("delete", "duplicate", "edit", "add",
"remove"))),
transitions=(WfTransitionConf(id="create",
name=_(u"Create"),
from pyramid.renderers import get_renderer, render_to_response, render
from pyramid.httpexceptions import HTTPNotFound
from nive.i18n import _
from nive.definitions import ViewModuleConf, ViewConf, ConfigurationError
from nive.definitions import IWebsite, IWebsiteRoot, IRoot, ICMSRoot, IPage, IPageElement, IObject, IFile
from nive.definitions import IViewModuleConf
from nive.views import BaseView
from nive.helper import ResolveName
# view module definition ------------------------------------------------------------------
#@nive_module
configuration = ViewModuleConf(
id="design",
name=_(u"Website design and view"),
static="nive.cms.design:static",
templates="nive.cms.design:templates",
mainTemplate="index.pt",
permission="view",
view="nive.cms.design.view.Design",
views=[
ViewConf(id="appview", name="", attr="app", context=IWebsite),
ViewConf(id="search", name="search", attr="search", context=IRoot),
ViewConf(id="su", name="su", attr="open", context=IRoot),
ViewConf(id="rootview", name="", attr="view", context=IWebsiteRoot),
ViewConf(id="objview",
name="",
attr="view",
context=IPage,
containment=IWebsiteRoot),
def editdatabase(self):
dbtypes = [{
"id": "MySql",
"name": "MySql"
}, {
"id": "Sqlite3",
"name": "Sqlite3"
}]
fields = (
FieldConf(
id=u"context",
datatype="list",
size=20,
required=1,
name=_(u"Database type to be used"),
listItems=dbtypes,
description=
_(u"Supports 'Sqlite3' and 'MySql' by default. MySql requires python-mysqldb installed."
)),
FieldConf(
id=u"fileRoot",
datatype="string",
size=500,
required=0,
name=_(u"Relative or absolute root directory for files")),
FieldConf(id=u"dbName",
datatype="string",
size=500,
required=1,
name=_(u"Database file path or name"),
description=_(
u"Sqlite3=database file path, MySql=database name")),
FieldConf(id=u"host",
datatype="string",
size=100,
required=0,
name=_(u"Database server host")),
FieldConf(id=u"port",
datatype="number",
size=8,
required=0,
name=_(u"Database server port")),
FieldConf(id=u"user",
datatype="string",
size=100,
required=0,
name=_(u"Database server user")),
FieldConf(id=u"password",
datatype="password",
size=100,
required=0,
name=_(u"Database server password")),
)
form = ConfigurationForm(view=self,
context=self.context.dbConfiguration,
app=self.context)
form.fields = fields
form.Setup()
# process and render the form.
result, data, action = form.Process()
return {u"content": data, u"result": result, u"head": form.HTMLHead()}
def AdministrationLinks(self, context=None):
if context:
apps = (context,)
else:
apps = self.context.app.portal.GetApps()
links = []
for app in apps:
if not hasattr(app, "registry"):
continue
# search for cms editor
for root in app.GetRoots():
if ICMSRoot.providedBy(root):
links.append({"href":self.Url(root), "title":app.configuration.title + u": " + _(u"editor")})
elif IWebsiteRoot.providedBy(root):
links.append({"href":self.Url(root), "title":app.configuration.title + u": " + _(u"public")})
# administration
links.append({"href":self.FolderUrl(app)+u"admin", "title":app.configuration.title + u": " + _(u"administration")})
# user management
if IUserDatabase.providedBy(app):
links.append({"href":self.FolderUrl(app)+u"usermanagement", "title":app.configuration.title + u": " + _(u"user management")})
return links
from nive.definitions import ViewConf, ViewModuleConf, FieldConf, WidgetConf, Conf
from nive.definitions import IApplication, IUser, IAdminWidgetConf, IUserDatabase, IPersistent, IModuleConf
from nive.definitions import IWebsiteRoot, ICMSRoot
from nive.views import BaseView
from nive.forms import ValidationError, HTMLForm
from nive.utils.utils import SortConfigurationList, ConvertDictToStr
# view module definition ------------------------------------------------------------------
#@nive_module
configuration = ViewModuleConf(
id = "administration",
name = _(u"Administration"),
static = "",
context = IApplication,
view = "nive.adminview.view.AdminView",
templates = "nive.adminview:",
permission = "administration"
)
t = configuration.templates
configuration.views = [
# User Management Views
ViewConf(name = "admin", attr = "view", renderer = t+"root.pt"),
ViewConf(name = "basics", attr = "editbasics", renderer = t+"form.pt"),
#ViewConf(name = "portal", attr = "editportal", renderer = t+"form.pt"),
ViewConf(name = "tools", attr = "tools", renderer = t+"tools.pt"),
ViewConf(name = "modules", attr = "view", renderer = t+"modules.pt"),
ViewConf(name = "views", attr = "view", renderer = t+"views.pt"),
from pyramid.i18n import get_localizer
from pyramid.threadlocal import get_current_request
from nive.tool import Tool, ToolView
from nive.helper import FakeLocalizer
from nive.definitions import ToolConf, IApplication
from nive.definitions import ViewConf
from nive.i18n import _
from nive.utils.utils import FormatBytesForDisplay
configuration = ToolConf(
id="cmsstatistics",
context="nive.tools.cmsstatistics.cmsstatistics",
name=_(u"CMS Statistics"),
description=
_("This function provides a short summary of elements and data contained in the website."
),
apply=(IApplication, ),
mimetype="text/html",
data=[],
views=[
ViewConf(name="",
view=ToolView,
attr="run",
permission="system",
context="nive.tools.cmsstatistics.cmsstatistics")
])
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#----------------------------------------------------------------------
__doc__ = """
Root for context to run adminview
"""
from nive.definitions import RootConf
from nive.userdb.root import root
from nive.i18n import _
class adminroot(root):
"""
"""
# Root definition ------------------------------------------------------------------
#@nive_module
configuration = RootConf(id="usermanagement",
context="nive.userdb.useradmin.adminroot.adminroot",
default=False,
subtypes="*",
name=_(u"User listing"),
description="")
def LoadListItems(fieldconf, app=None, obj=None, pool_type=None, force=False):
"""
Load field list items for the given fieldconf.
If `force` is False and fieldconf already contains list items, the existing
`fieldconf.listItems` are returned. Set `force=True` to reload each time this
function is called.
`obj` and `pool_type` are only used for workflow lookup.
returns dict list
"""
values = []
if not fieldconf:
return values
if fieldconf.listItems and not force:
# skip loading if list filled
if hasattr(fieldconf.listItems, '__call__'):
return fieldconf.listItems(fieldconf, obj or app)
return fieldconf.listItems
if not app:
if fieldconf.settings:
# settings dyn list
dyn = fieldconf.settings.get("codelist")
if dyn in ("languages", "countries"):
# the only two lists not requiring 'app'
if dyn == "languages":
return LanguageExtension().Codelist()
else:
return CountryExtension().Codelist()
# abort here if app is not set
return fieldconf.listItems
# load list items from db, application or user database
if fieldconf.settings:
# settings dyn list
dyn = fieldconf.settings.get("codelist")
if not dyn:
pass
elif dyn == "users":
return GetUsers(app)
elif dyn == "groups":
portal = app.portal
if portal is None:
portal = app
return portal.GetGroups(sort="name", visibleOnly=True)
elif dyn == "localgroups":
return app.GetGroups(sort="name", visibleOnly=True)
elif dyn == "groups+auth":
portal = app.portal
if portal is None:
portal = app
return [
Conf(id=u"authenticated",
name=_(u"Authenticated"),
visible=True)
] + portal.GetGroups(sort="name", visibleOnly=True)
elif dyn == "types":
return app.GetAllObjectConfs()
elif dyn == "categories":
return app.GetAllCategories()
elif dyn[:5] == "type:":
type = dyn[5:]
return app.root().GetEntriesAsCodeList(type,
"title",
parameter={},
operators={},
sort="title")
elif dyn == "meta":
return app.root().GetEntriesAsCodeList2("title",
parameter={},
operators={},
sort="title")
elif dyn == "languages":
return LanguageExtension().Codelist()
elif dyn == "countries":
return CountryExtension().Codelist()
fld = fieldconf.id
if fld == "pool_type":
values = app.GetAllObjectConfs()
elif fld == "pool_category":
values = app.GetAllCategories()
elif fld == "pool_groups":
local = fieldconf.settings.get("local")
loader = app
if not local:
portal = app.portal
if portal:
loader = portal
values = loader.GetGroups(sort="name", visibleOnly=True)
elif fld == "pool_language":
values = app.GetLanguages()
elif fld == "pool_wfa":
# uses type object as param
if obj:
try:
aWfp = obj.meta.get("pool_wfp")
obj = app.GetWorkflow(aWfp)
if obj:
values = obj.GetActivities()
except:
pass
elif pool_type:
aWfp = app.GetObjectConf(pool_type).get("workflowID")
try:
obj = app.GetWorkflow(aWfp)
values = obj.GetActivities()
except:
pass
else:
values = []
elif fld == "pool_wfp":
values = app.GetAllWorkflowConfs()
return values
# Released under GPL3. See license.txt
#
import json
import base64
from nive.tool import Tool, ToolView
from nive.definitions import ToolConf, FieldConf, ViewConf
from nive.definitions import IApplication, MetaTbl, Structure, IContainer
from nive.helper import ConfEncoder
from nive.i18n import _
configuration = ToolConf(
id="exportJson",
context="nive.tools.exportJson.exportJson",
name=_(u"Json data export"),
description=
_("This function exports all objects in json format. Optionally as flat list or tree structure. This is not a simple database table dump. Object events will be triggered before exporting data."
),
apply=(IApplication, ),
mimetype="text/json",
data=[
FieldConf(
id="tree",
datatype="bool",
default=1,
listItems=[{
"id": "true",
"name": "Tree"
}, {
"id": "false",
__doc__ = """
Test version of nive.tools.sendMail. Use `sendMailTester` as a replacement for `sendMail` in tests
or to disable actual mail delivery
"""
import logging
from nive.utils.utils import ConvertToList
from nive.definitions import ToolConf
from nive.tools.sendMail import sendMail
from nive.i18n import _
configuration = ToolConf("nive.tools.sendMail",
context="nive.tools.sendMailTester.sendMailTester",
name=_(u"Fake Mailer"),
description=__doc__)
class sendMailTester(sendMail):
def _Run(self, **values):
"""
"""
host = values.get("host")
port = values.get("port")
sender = values.get("sender")
user = values.get("user")
pass_ = values.get("pass_")
fromName = values.get("fromName")
"""
from nive.i18n import _
from nive.components.objects.base import PageRootBase
from nive.definitions import IWebsiteRoot, implements
from nive.definitions import RootConf
class root(PageRootBase):
implements(IWebsiteRoot)
extension = u"html"
def Init(self):
self.queryRestraints = {"pool_state": 1}, {}
# Root definition ------------------------------------------------------------------
#@nive_module
configuration = RootConf(
id="root",
context="nive.cms.root.root",
template="root.pt",
default=True,
subtypes="*",
extensions=("nive.components.extensions.persistentRoot.Persistent", ),
name=_(u"Home"),
description=
_(u"The root is the home page of the website. All contained pages and elements are stored in the database."
))
def _Run(self, **values):
result = 1
codepage = "utf-8"
app = self.app
datapool = app.db
conf = app.dbConfiguration
conn = datapool.connection
system = values.get("excludeSystem")
self.filename = app.configuration.id + ".json"
if not conn:
self.stream.write(
_(u"Database connection error (${name})\n",
mapping={u"name": app.dbConfiguration.context}))
return 0
if not conn.IsConnected():
self.stream.write(
_(u"Database connection error (${name})\n",
mapping={u"name": app.dbConfiguration.context}))
return 0
def mapfields(fields):
a = []
for f in fields:
a.append(f.id)
return a
export = [(MetaTbl, mapfields(app.GetAllMetaFlds(ignoreSystem=False)))]
for t in app.GetAllObjectConfs():
export.append((t.dbparam, ["id"] + mapfields(t.data)))
for t in Structure.items():
export.append((t[0], mapfields(t[1]["fields"])))
data = {}
for table in export:
#tablename
tablename = table[0]
if system and tablename in system:
continue
#fields
fields = table[1]
columns = (",").join(fields)
sql = "select %s from %s" % (columns, tablename)
c = conn.cursor()
c.execute(sql)
tvalues = []
for rec in c.fetchall():
recvalue = {}
pos = 0
for col in rec:
recvalue[fields[pos]] = col
pos += 1
tvalues.append(recvalue)
data[tablename] = tvalues
self.stream.write(JsonDataEncoder().encode(data))
return 1
from nive.components.objects.base import PageElementFileBase
class media(PageElementFileBase):
def IsVideo(self):
return self.data.get("player") == u"video"
def IsAudio(self):
return self.data.get("player") == u"audio"
# media type definition ------------------------------------------------------------------
#@nive_module
configuration = ObjectConf(
id="media",
name=_(u"Media"),
dbparam="mediafile",
context="nive.cms.media.media",
template="media.pt",
selectTag=StagPageElement,
icon="nive.cms.cmsview:static/images/types/media.png",
description=_(
u"Element to insert audio or video files into the web page. Uses HTML 5 media"
u"and audio tags and the browser's default player."))
player = [{
"id": u"video",
"name": _(u"Video player")
}, {
"id": u"audio",
"name": _(u"Audio player")
::
configuration.admin = {"name": "admin", "password": "******", "email": "*****@*****.**"}
configuration.systemAdmin = (u"email", u"display name")
"""
from nive.definitions import implements, AppConf, FieldConf, GroupConf, IUserDatabase, ILocalGroups
from nive.security import Allow, Deny, Everyone, ALL_PERMISSIONS, remember, forget
from nive.components.objects.base import ApplicationBase
from nive.i18n import _
#@nive_module
configuration = AppConf()
configuration.id = "userdb"
configuration.title = _(u"Users")
configuration.context = "nive.userdb.app.UserDB"
configuration.loginByEmail = False
# configuration.systemAdmin = (u"email", u"display name")
# configuration.admin = {"name": "admin", "password": "******", "email": "*****@*****.**"}
configuration.modules = [
"nive.userdb.root",
"nive.userdb.user",
# session user cache
"nive.components.extensions.sessionuser",
# user administration
"nive.userdb.useradmin",
# tools
"nive.components.tools.dbStructureUpdater",
# return the current element container
return self.GetParent()
def GetElementContainer(self):
# return the current element container
return self #.GetParent()
def GetContainer(self):
# return the current element container
return self.GetParent()
#@nive_module
configuration = ObjectConf(
id="box",
name=_(u"Box"),
dbparam="box",
context="nive.cms.box.box",
template="box.pt",
selectTag=StagPageElement,
container=True,
icon="nive.cms.cmsview:static/images/types/box.png",
description=
_(u"A box is a container to group elements on a page. It can be used as an"
u"advanced styling element for web pages. The box itself only stores a title and styling selector."
))
# data definition ------------------------------------------------------------------
css = [
{
'id': u'span1',
# Released under GPL3. See license.txt
#
import json
import datetime
from nive.tool import Tool, ToolView
from nive.definitions import ToolConf, FieldConf, ViewConf
from nive.definitions import IApplication, MetaTbl, Structure
from nive.helper import JsonDataEncoder
from nive.i18n import _
configuration = ToolConf(
id="dbJsonDump",
context="nive.tools.dbJsonDump.dbJsonDump",
name=_(u"Database json dump"),
description=
_("This function dumps table contents the way records are stored in json format."
),
apply=(IApplication, ),
mimetype="text/json",
data=[
FieldConf(id="excludeSystem",
datatype="checkbox",
default=[],
listItems=[{
"id": "pool_sys",
"name": "pool_sys"
}, {
"id": "pool_fulltext",
"name": "pool_fulltext"
class image(PageElementFileBase):
def Span(self):
# css class span for the css selection
if self.data.cssClass == "teaserl":
return u"span4"
elif self.data.cssClass == "teasers":
return u"span2"
return u"span3"
# image type definition ------------------------------------------------------------------
#@nive_module
configuration = ObjectConf(
id="image",
name=_(u"Image"),
dbparam="images",
context="nive.cms.image.image",
template="image.pt",
selectTag=StagPageElement,
extensions=[],
icon="nive.cms.cmsview:static/images/types/image.png",
description=_(u"The image element inserts images into the web page."))
css = [
{
"id": u"default",
"name": _(u"Simple")
},
{
"id": u"left",
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#----------------------------------------------------------------------
__doc__ = ""
import types
from nive.tools import Tool
from nive.definitions import ToolConf, IApplication
from nive.i18n import _
configuration = ToolConf(
id="gcdump",
context="nive.components.tools.gcdump.gcdump",
name=_(u"Object dump"),
description=_(
"This function dumps a list of all objects found in memory."),
apply=(IApplication, ),
data=[],
mimetype="text/html")
import gc
from types import InstanceType
class gcdump(Tool):
"""
"""
def _Run(self, **values):
