def getNoAccessIds(attr, trans):
lstNoAccess = []
for sID in attr.value:
oItem = db.getItem(sID, trans)
if not(oItem):
lstNoAccess.append(sID)
return lstNoAccess
def get_response(self, raw_request):
response = HttpResponse()
request = HttpRequest(raw_request)
item = None
registration = None
try:
try:
self.context = HttpContext(request, response)
sPath = request.serverVariables['PATH_INFO']
try:
item = db.getItem(sPath)
except exceptions.ObjectNotFound:
# dir request
lstPath = sPath.split('/')
dirName = lstPath[1]
# remove blank entry & app name to get the requested path
sDirPath = '/'.join(lstPath[2:])
webApp = pubdirs.dirs.setdefault(dirName, None)
if webApp:
registration = webApp.getRegistration(
sDirPath,
request.serverVariables['REQUEST_METHOD'],
request.serverVariables['HTTP_USER_AGENT'],
request.getLang())
if not registration:
raise exceptions.NotFound, \
'The resource "%s" does not exist' % sPath
# apply pre-processing filters
[filter[0].apply(self.context, registration, **filter[1])
for filter in registration.filters
if filter[0].type == 'pre']
rtype = registration.type
if rtype == 1: # psp page
ServerPage.execute(self.context, registration.context)
elif rtype == 0: # static file
response.loadFromFile(registration.context)
if registration.encoding:
response.charset = registration.encoding
else:
# db request
if (item == None):
raise exceptions.PermissionDenied
self.dispatch_method(item)
except exceptions.ResponseEnd, e:
pass
if registration != None:
# do we have caching directive?
if registration.max_age:
response.setExpiration(registration.max_age)
# apply post-processing filters
[filter[0].apply(self.context, registration, **filter[1])
for filter in registration.filters
if filter[0].type == 'post']
def getNoAccessIds(cls, attr, trans):
lstNoAccess = []
for sID in attr.value:
oItem = db.getItem(sID, trans)
# do not replay in case of txn abort
del trans.actions[-1]
if not(oItem):
lstNoAccess.append(sID)
return lstNoAccess
def login(self, username, password):
"Remote method for authenticating users"
http_context = HttpContext.current()
users_container = db.getItem("users")
user = users_container.getChildByName(username)
if user and hasattr(user, "authenticate"):
if user.authenticate(password):
http_context.session.user = user
return True
return False
def getParent(self, trans=None):
"""
Returns the parent container.
@param trans: A valid transaction handle
@return: the parent container object
@rtype: type
"""
return(db.getItem(self._parentid, trans))
def getSecurity(self):
"Returns information about the object's security descriptor"
l = []
for sID in self.security:
oUser = db.getItem(sID)
l.append({
'id': sID,
'displayName': oUser.displayName.value,
'role': str(self.security[sID])
})
return l
def getChildByName(self, name, trans=None):
"""
This method returns the child with the specified name.
@param name: The name of the child
@type name: str
@param trans: A valid transaction handle
@return: The child object if a child with the given name exists
else None.
@rtype: type
"""
if (self._items.has_key(name)):
oChild = db.getItem(self._items[name], trans)
return(oChild)
elif (self._subfolders.has_key(name)):
oChild = db.getItem(self._subfolders[name], trans)
return(oChild)
else:
return(None)
def __loadcache(self, istart):
if self._resolved:
self.__cache = [
_db.getItem(id, self._txn)
for id in self._list[istart:istart + self._cachesize]]
else:
if self._safe:
self.__cache = filter(None,
[db.getItem(id, self._txn)
for id in self._list[istart:istart + self._cachesize]])
else:
self.__cache = filter(None,
[self.__getItemSafe(id)
for id in self._list[istart:istart + self._cachesize]])
def getSecurity(self):
"Returns information about the object's security descriptor"
l = []
for sID in self.security:
try:
oUser = db.getItem(sID)
dn = oUser.displayName.value
except exceptions.ObjectNotFound:
dn = sID
l.append({
'id': sID,
'displayName': dn,
'role': str(self.security[sID])
})
return l
def selectcontainer(self):
"Displays a dialog for selecting the destination container"
context = HttpContext.current()
rootFolder = db.getItem('')
params = {
'ROOT_ID': '/',
'ROOT_IMG': rootFolder.__image__,
'ROOT_DN': rootFolder.displayName.value,
'ID': self.id,
}
sAction = context.request.queryString['action'][0]
params['TITLE'] = '@@%s@@' % sAction.upper()
if sAction != 'select_folder':
params['TITLE'] += ' "%s"' % self.displayName.value
return params
def getItem(self, trans=None):
"""
This method returns the object that this data type
instance references. If the current user has no read
permission on the referenced item or it has been deleted
then it returns None.
@param trans: A valid transaction handle
@rtype: type
@return: The referenced object, otherwise None
"""
oItem = None
if self.value:
try:
oItem = db.getItem(self.value, trans)
except exceptions.ObjectNotFound:
pass
return(oItem)
def select(deep, children, fields, condition, variables):
results = []
for child in [db.getItem(child_id) for child_id in children]:
if child:
if condition:
res = evaluateStack(condition[:], variables, child)
else:
res = True
if res:
fieldlist = [evaluateStack(expr[1], variables, child) for expr in fields]
results.append(tuple(fieldlist))
if deep and child.isCollection:
children_ids = child._subfolders.values() + child._items.values()
results1 = select(deep, children_ids, fields, condition, variables)
results.extend(results1)
return (results)
def h_200(params, variables, forObject = None):
select_fields = params[0]
# get aliases
aliases = []
for expr, alias, aggr in select_fields:
if expr != alias:
variables[alias] = (expr, None, None)
aliases.append(alias)
field_names = [ x[1] for x in select_fields ]
expressions = [ tuple(x[0::2]) for x in select_fields ]
select_from = params[1]
where_condition = params[2]
if params[3]:
sort_order, order_by = params[3]
for ind, order_field in enumerate(order_by):
expr, alias, aggr = order_field
if alias in aliases:
order_by[ind] = select_fields[ field_names.index(alias) ]
elif expr != alias:
if (expr, aggr) in expressions:
order_by[ind] = select_fields[ expressions.index((expr, aggr)) ]
else:
variables[alias] = (expr, None, None)
aliases.append(alias)
else:
order_by = []
group_by = params[4]
if group_by:
for ind, group_field in enumerate(group_by):
expr, alias, aggr = group_field
if alias in aliases:
group_by[ind] = select_fields[ field_names.index(alias) ]
elif expr != alias:
if (expr, aggr) in expressions:
group_by[ind] = select_fields[ expressions.index((expr, aggr)) ]
else:
variables[alias] = (expr, None, None)
aliases.append(alias)
if select_fields:
all_fields = select_fields + order_by + group_by
else:
all_fields = [['id','id', '']] + order_by + group_by
aggregates = [x[2] for x in all_fields]
results = []
for deep, object_id in select_from:
if deep==2:
# this:attr
if not forObject:
raise TypeError, 'Inner scopes using "this:" are valid only in sub-queries'
if hasattr(forObject, object_id):
refObjects = getattr(forObject, object_id).value
if type(refObjects) == str:
refObjects = [refObjects]
r = select(False, refObjects, all_fields, where_condition, variables)
results.extend(r)
else:
# swallow-deep
obj = db.getItem(object_id)
if obj != None and obj.isCollection:
children = obj._subfolders.values() + obj._items.values()
r = select(deep, children, all_fields,
where_condition, variables)
results.extend(r)
# print results
if results:
if group_by:
if select_fields:
#construct groups
group_dict = {}
igrpstart = len(select_fields) + len(order_by)
igrpend = igrpstart + len(group_by)
for rec in results:
group_value = tuple(rec[igrpstart:igrpend])
group_dict[group_value] = group_dict.setdefault(group_value, [])
group_dict[group_value].append(rec)
groups = [tuple(g) for g in group_dict.values()]
else:
raise TypeError, 'GROUP BY clause is incompatible with SELECT *'
else:
groups = [results]
# print len(groups)
results = []
if aggregates != [''] * len(aggregates) or group_by:
for ind, group in enumerate(groups):
group_sum = []
for aggr_index, aggr_type in enumerate(aggregates):
# aggregates exclude None values
group_sum.append( computeAggregate(aggr_type, [x[aggr_index] for x in group if x[aggr_index] != None]) )
groups[ind] = (tuple(group_sum),)
for group in groups:
results.extend(group)
if order_by:
# extract sort values
istart = 1
if select_fields:
istart = len(select_fields)
sortlist = tuple([x[istart:istart + len(order_by)] for x in results])
results = sortList(sortlist, results)
# if it is descending reverse the result list
if not sort_order: results.reverse()
# remove aliases
for alias in aliases:
del variables[alias]
if select_fields:
schema = field_names
# truncate to keep only select fields
iend = len(select_fields)
results = tuple([x[:iend] for x in results])
else:
schema = None
results = tuple([x[:1][0] for x in results])
# print results
return objectSet.ObjectSet(tuple(results), schema)
def __blank__(self):
"Displays the desktop"
context = HttpContext.current()
context.response.setHeader("cache-control", "no-cache")
oUser = context.session.user
params = {
"USER": oUser.displayName.value,
"AUTO_RUN": "",
"RUN_MAXIMIZED": 0,
"SETTINGS_DISABLED": "",
"LOGOFF_DISABLED": "",
}
if hasattr(oUser, "authenticate"):
settings = oUser.settings
params["AUTO_RUN"] = settings.value.setdefault("AUTO_RUN", "")
params["RUN_MAXIMIZED"] = int(settings.value.setdefault("RUN_MAXIMIZED", False))
taskbar_position = settings.value.setdefault("TASK_BAR_POS", "bottom")
else:
taskbar_position = "bottom"
params["SETTINGS_DISABLED"] = "true"
params["LOGOFF_DISABLED"] = "true"
params["REPOSITORY_DISABLED"] = "true"
params["PERSONAL_FOLDER"] = ""
if hasattr(oUser, "personalFolder"):
params["REPOSITORY_DISABLED"] = "false"
params["PERSONAL_FOLDER"] = oUser.personalFolder.value
# has the user access to recycle bin?
rb_icon = ""
rb = db.getItem("rb")
if rb:
rb_icon = (
"""
<icon top="80" left="10" width="80" height="80"
imgalign="top" ondblclick="generic.openContainer"
img="desktop/images/trashcan_full.gif" color="white"
caption="%s">
<prop name="folderID" value="rb"></prop>
</icon>
"""
% rb.displayName.value
)
desktop_pane = DESKSTOP_PANE % (self.displayName.value, rb_icon)
if taskbar_position == "bottom":
params["TOP"] = desktop_pane
params["BOTTOM"] = ""
else:
params["TOP"] = ""
params["BOTTOM"] = desktop_pane
# get applications
oCmd = OqlCommand()
sOql = "select launchUrl,displayName,icon from 'apps' " + "order by displayName asc"
apps = oCmd.execute(sOql)
sApps = ""
if len(apps) > 0:
for app in apps:
sApps += """<menuoption img="%s" caption="%s"
onclick="generic.runApp">
<prop name="url" value="%s"></prop>
</menuoption>""" % (
app["icon"],
app["displayName"],
app["launchUrl"],
)
params["APPS"] = sApps
else:
params["APPS"] = '<menuoption caption="@@EMPTY@@"' + ' disabled="true"></menuoption>'
return params
def __getItemSafe(self, id):
try:
return db.getItem(id, self._txn)
except exceptions.ObjectNotFound:
return None
def __blank__(self):
"Displays the desktop"
context = HttpContext.current()
context.response.setHeader('cache-control', 'no-cache')
oUser = context.user
params = {
'USER' : oUser.displayName.value,
'AUTO_RUN' : '',
'RUN_MAXIMIZED' : 0,
'SETTINGS_DISABLED' : '',
'LOGOFF_DISABLED' : ''
}
if hasattr(oUser, 'authenticate'):
settings = oUser.settings
params['AUTO_RUN'] = \
settings.value.setdefault('AUTO_RUN', '')
params['RUN_MAXIMIZED'] = \
int(settings.value.setdefault('RUN_MAXIMIZED', False))
taskbar_position = \
settings.value.setdefault('TASK_BAR_POS', 'bottom')
else:
taskbar_position = 'bottom'
params['SETTINGS_DISABLED'] = 'true'
params['LOGOFF_DISABLED'] = 'true'
params['REPOSITORY_DISABLED'] = 'true'
params['PERSONAL_FOLDER'] = ''
if hasattr(oUser, 'personalFolder'):
params['REPOSITORY_DISABLED'] = 'false'
params['PERSONAL_FOLDER'] = oUser.personalFolder.value
# has the user access to recycle bin?
rb_icon = ''
rb = db.getItem('rb')
if rb:
rb_icon = '''
<icon top="80" left="10" width="80" height="80"
imgalign="top" ondblclick="generic.openContainer"
img="desktop/images/trashcan_full.gif" color="white"
caption="%s">
<prop name="folderID" value="rb"></prop>
</icon>
''' % rb.displayName.value
desktop_pane = DESKSTOP_PANE % (self.displayName.value, rb_icon)
if taskbar_position == 'bottom':
params['TOP'] = desktop_pane
params['BOTTOM'] = ''
else:
params['TOP'] = ''
params['BOTTOM'] = desktop_pane
# get applications
oCmd = OqlCommand()
sOql = "select launchUrl,displayName,icon from 'apps' " + \
"order by displayName asc"
apps = oCmd.execute(sOql)
sApps = ''
if len(apps) > 0:
for app in apps:
sApps += '''<menuoption img="%s" caption="%s"
onclick="generic.runApp">
<prop name="url" value="%s"></prop>
</menuoption>''' % \
(app['icon'], app['displayName'], app['launchUrl'])
params['APPS'] = sApps
else:
params['APPS'] = '<menuoption caption="@@EMPTY@@"' + \
' disabled="true"></menuoption>'
return params
