def handle (self) :
self.request = templating.HTMLRequest (self.client)
assert (self.client.nodeid)
klass = self.db.classes [self.request.classname]
id = self.client.nodeid
attr = self.form ['@attr'].value.strip ()
if '@frm' in self.form :
frm = self.form ['@frm'].value.strip ()
node = self.db.address.getnode (self.db.cust_supp.get (id, frm))
attributes = dict \
((k, node [k]) for k in self.copy_attributes
if node [k] is not None
)
else :
attributes = dict \
( function = klass.get (id, 'name')
, country = ' '
)
newvalue = newid = self.db.address.create (** attributes)
if isinstance (klass.properties [attr], Multilink) :
newvalue = klass.get (id, attr) [:]
newvalue.append (newid)
newvalue = dict.fromkeys (newvalue).keys ()
klass.set (id, ** {attr : newvalue})
self.db.commit ()
raise Redirect, "%s%s" % (self.request.classname, id)
def handle(self):
''' Dial the given number -- for expect a snom with URL dialling. '''
# figure the request
request = self.request = templating.HTMLRequest(self.client)
filterspec = request.filterspec
sort = request.sort
group = request.group
klass = self.klass = self.db.getclass(request.classname)
assert (request.classname == 'contact')
id = self.client.nodeid
contact = klass.getnode(id)
cids = self.db.callerid.filter(None, dict(contact=id))
callerid = self.db.callerid.getnode(cids[0])
user = self.db.user.getnode(self.db.getuid())
sipdev = self.db.sip_device.getnode(user.sip_device)
url = 'http://%s:%s@%s:80/command.htm?number=%s&outgoing_uri=%s@%s' % \
( sipdev.http_username
, sipdev.http_password
, sipdev.name
, callerid.number
, sipdev.pbx_username
, sipdev.pbx_hostname
)
#print url
#print callerid.number
try:
f = urlopen(url)
f.read()
f.close()
except EOFError:
pass
raise Redirect, "address%s" % contact.address
def handle (self) :
self.request = templating.HTMLRequest (self.client)
assert \
( self.request.classname
and self.request.classname == 'user_dynamic'
and self.client.nodeid
)
id = self.client.nodeid
dyn = self.db.user_dynamic.getnode (id)
perm = self.db.security.hasPermission
if not common.user_has_role (self.db, self.db.getuid (), 'HR') :
raise Reject, "Not allowed"
fields = user_dynamic.dynuser_copyfields + ['valid_to']
param = dict ((i, dyn [i]) for i in fields)
if dyn.valid_to :
date = common.pretty_range \
(dyn.valid_from, dyn.valid_to - common.day)
else :
date = dyn.valid_from.pretty (common.ymd) + ';'
frozen = self.db.daily_record_freeze.filter \
( None
, dict (user = dyn.user, date = date, frozen = True)
, group = [('-', 'date')]
)
assert (frozen)
frozen = self.db.daily_record_freeze.getnode (frozen [0])
splitdate = frozen.date + common.day
self.db.user_dynamic.set (id, valid_to = splitdate)
param ['valid_from'] = splitdate
newid = self.db.user_dynamic.create (** param)
self.db.commit ()
raise Redirect, 'user_dynamic%s' % newid
def get_user (self) :
self.request = templating.HTMLRequest (self.client)
user = self.request.form ['user'].value
if not user :
raise Reject, self._ (self.user_required_msg)
try :
self.user = self.db.user.lookup (user)
except KeyError :
raise Reject, self._ (self.user_invalid_msg)
return self.user
def handle(self):
''' Perform some action. No return value is required.
'''
if self.client.env['REQUEST_METHOD'] != 'POST':
raise Reject(self._('Invalid request'))
# parse the props from the form
try:
props, links = self.client.parsePropsFromForm(create=1)
except (ValueError, KeyError) as message:
self.client.add_error_message(self._('Error: %s') % str(message))
return
print props
print props[('project', self.form['projectid'].value)]['supplier']
try:
message = self._editnodes(props, links)
except (ValueError, KeyError, IndexError, Reject) as message:
escape = not isinstance(message, RejectRaw)
self.client.add_error_message(self._('Edit Error: %s') %
str(message),
escape=escape)
return
self.db.project.set(self.form['projectid'].value,
status='5') # Set project status to 'in-progress'
#insert task(s)
for task in self.db.workflow.filter(None,
filterspec={
'workflowname': '1',
'trg_type': None,
'trg_state': None
}):
t = self.db.issue.create(
project=self.form['projectid'].value,
tasktype=self.db.workflow.get(task, 'new_type'),
status='new',
supplier=self.db.workflow.get(task, 'new_resp')
if self.db.workflow.get(task, 'new_resp') else
props[('project', self.form['projectid'].value)]['supplier'])
# commit now that all the tricky stuff is done
self.db.commit()
# redirect to the item's edit page
# redirect to finish off
url = self.base + self.classname
# note that this action might have been called by an index page, so
# we will want to include index-page args in this URL too
if self.nodeid is not None:
url += self.nodeid
url += '?@ok_message=%s&@template=%s' % (urllib_.quote(
'Project%s launched.' %
(self.form['projectid'].value)), urllib_.quote(self.template))
if self.nodeid is None:
req = templating.HTMLRequest(self.client)
print self.form['projectid'].value
url += '&' + req.indexargs_url('', {})[1:]
raise exceptions.Redirect(url)
def handle(self):
''' Export the specified search query as CSV. '''
# figure the request
request = self.request = templating.HTMLRequest(self.client)
filterspec = request.filterspec
sort = request.sort
group = request.group
klass = self.klass = self.db.getclass(request.classname)
assert (request.classname == 'query')
id = self.client.nodeid
query = klass.getnode(id)
raise Redirect, "%s?%s&@old-queryname=%s&@queryname=%s" \
% (query.klass, query.url, query.name, query.name)
def handle(self):
# figure the request
request = templating.HTMLRequest(self.client)
filterspec = request.filterspec
if request.classname != 'invoice':
raise Reject, self.db._('You can only mark invoices')
# get invoice_group -- if existing:
self.invoice_group = None
try:
self.invoice_group = filterspec['invoice_group'][0]
except KeyError:
pass
def handle(self):
# figure the request
request = self.request = templating.HTMLRequest(self.client)
klass = self.klass = self.db.getclass(request.classname)
id = self.client.nodeid
if not id:
ids = klass.getnodeids()
if ids:
id = ids[0]
if id:
raise Redirect, '%s%s' % (request.classname, id)
add = ''
if request.classname == 'dyndns':
add = '&local_hostname=localhost'
raise Redirect, '%s?@template=item%s' % (request.classname, add)
def _setup_request(self, setup_filter=False):
""" figure the request """
if setup_filter:
self.fakeFilterVars()
request = self.request = templating.HTMLRequest(self.client)
self.utils = templating.TemplatingUtils(self.client)
filterspec = self.filterspec = request.filterspec
self.sort = request.sort
self.group = request.group
self.klass = self.klass = self.db.getclass(request.classname)
self.props = self.klass.getprops()
self.htcls = templating.HTMLClass(self.client, request.classname)
if self.db.user.properties.get('csv_delimiter'):
d = self.db.user.get(self.db.getuid(), 'csv_delimiter')
if d and len(d) == 1:
self.delimiter = d
global locale
locale = get_num_locale(self.client, self.db)
def handle(self):
''' Export the specified search query as CSV. '''
# figure the request
request = templating.HTMLRequest(self.client)
filterspec = request.filterspec
sort = request.sort
group = request.group
columns = request.columns
klass = self.db.getclass(request.classname)
# full-text search
if request.search_text:
matches = self.db.indexer.search(
re.findall(r'\b\w{2,25}\b', request.search_text), klass)
else:
matches = None
h = self.client.additional_headers
h['Content-Type'] = 'text/csv; charset=%s' % self.client.charset
# some browsers will honor the filename here...
h['Content-Disposition'] = 'inline; filename=query.csv'
self.client.header()
if self.client.env['REQUEST_METHOD'] == 'HEAD':
# all done, return a dummy string
return 'dummy'
wfile = self.client.request.wfile
if self.client.charset != self.client.STORAGE_CHARSET:
wfile = codecs.EncodedFile(wfile, self.client.STORAGE_CHARSET,
self.client.charset, 'replace')
writer = csv.writer(wfile)
writer.writerow(columns)
# and search
for itemid in klass.filter(matches, filterspec, sort, group):
writer.writerow([str(klass.get(itemid, col)) for col in columns])
return '\n'
def handle(self):
request = templating.HTMLRequest(self.client)
filterspec = request.filterspec
_ = self.db._
if request.classname != 'address':
raise Reject, _('You can only download templates for an address')
try:
template = request.form['tmplate'].value
except KeyError:
template = filterspec['tmplate'][0]
template = self.db.tmplate.getnode(template)
address = self.db.address.getnode(self.context['context'].id)
files = template.files
if not files:
raise Reject, _('No files for %(tmplate)s' % template.name)
return self.create_file \
( self.db.file.getnode (files [0])
, None
, Date ('.')
, address
)
def handle(self):
request = templating.HTMLRequest(self.client)
filterspec = request.filterspec
if request.classname != 'letter':
raise Reject, self.db._('You can only download letters')
# get id:
try:
self.id = request.form['id'].value
except KeyError:
self.id = filterspec['id'][0]
letter = self.db.letter.getnode(str(self.id))
files = letter.files
if not files:
raise Redirect, 'letter%s' % self.id
invoice = letter.invoice
if invoice:
invoice = self.db.invoice.getnode(invoice)
return self.create_file \
( self.db.file.getnode (files [0])
, invoice
, letter.date
, self.db.address.getnode (letter.address)
)
class EditItemAction(EditCommon):
def lastUserActivity(self):
if self.form.has_key(':lastactivity'):
d = date.Date(self.form[':lastactivity'].value)
elif self.form.has_key('@lastactivity'):
d = date.Date(self.form['@lastactivity'].value)
else:
return None
d.second = int(d.second)
return d
def lastNodeActivity(self):
cl = getattr(self.client.db, self.classname)
activity = cl.get(self.nodeid, 'activity').local(0)
activity.second = int(activity.second)
return activity
def detectCollision(self, user_activity, node_activity):
'''Check for a collision and return the list of props we edited
that conflict.'''
if user_activity and user_activity < node_activity:
props, links = self.client.parsePropsFromForm()
key = (self.classname, self.nodeid)
# we really only collide for direct prop edit conflicts
return props[key].keys()
else:
return []
def handleCollision(self, props):
message = self._(
'Edit Error: someone else has edited this %s (%s). '
'View <a target="new" href="%s%s">their changes</a> '
'in a new window.') % (self.classname, ', '.join(props),
self.classname, self.nodeid)
self.client.error_message.append(message)
return
def handle(self):
"""Perform an edit of an item in the database.
See parsePropsFromForm and _editnodes for special variables.
"""
user_activity = self.lastUserActivity()
if user_activity:
props = self.detectCollision(user_activity,
self.lastNodeActivity())
if props:
self.handleCollision(props)
return
props, links = self.client.parsePropsFromForm()
# handle the props
try:
message = self._editnodes(props, links)
except (ValueError, KeyError, IndexError,
roundup.exceptions.Reject), message:
self.client.error_message.append(
self._('Edit Error: %s') % str(message))
return
# commit now that all the tricky stuff is done
self.db.commit()
# redirect to the item's edit page
# redirect to finish off
url = self.base + self.classname
# note that this action might have been called by an index page, so
# we will want to include index-page args in this URL too
if self.nodeid is not None:
url += self.nodeid
url += '?@ok_message=%s&@template=%s' % (urllib.quote(message),
urllib.quote(self.template))
if self.nodeid is None:
req = templating.HTMLRequest(self.client)
url += '&' + req.indexargs_url('', {})[1:]
raise exceptions.Redirect, url
def handle(self):
"""Mangle some of the form variables.
Set the form ":filter" variable based on the values of the filter
variables - if they're set to anything other than "dontcare" then add
them to :filter.
Handle the ":queryname" variable and save off the query to the user's
query list.
Split any String query values on whitespace and comma.
"""
self.fakeFilterVars()
queryname = self.getQueryName()
# editing existing query name?
old_queryname = self.getFromForm('old-queryname')
# handle saving the query params
if queryname:
# parse the environment and figure what the query _is_
req = templating.HTMLRequest(self.client)
url = self.getCurrentURL(req)
key = self.db.query.getkey()
if key:
# edit the old way, only one query per name
try:
qid = self.db.query.lookup(old_queryname)
if not self.hasPermission('Edit', 'query', itemid=qid):
raise exceptions.Unauthorised, self._(
"You do not have permission to edit queries")
self.db.query.set(qid, klass=self.classname, url=url)
except KeyError:
# create a query
if not self.hasPermission('Create', 'query'):
raise exceptions.Unauthorised, self._(
"You do not have permission to store queries")
qid = self.db.query.create(name=queryname,
klass=self.classname,
url=url)
else:
# edit the new way, query name not a key any more
# see if we match an existing private query
uid = self.db.getuid()
qids = self.db.query.filter(None, {
'name': old_queryname,
'private_for': uid
})
if not qids:
# ok, so there's not a private query for the current user
# - see if there's one created by them
qids = self.db.query.filter(None, {
'name': old_queryname,
'creator': uid
})
if qids and old_queryname:
# edit query - make sure we get an exact match on the name
for qid in qids:
if old_queryname != self.db.query.get(qid, 'name'):
continue
if not self.hasPermission('Edit', 'query', itemid=qid):
raise exceptions.Unauthorised, self._(
"You do not have permission to edit queries")
self.db.query.set(qid,
klass=self.classname,
url=url,
name=queryname)
else:
# create a query
if not self.hasPermission('Create', 'query'):
raise exceptions.Unauthorised, self._(
"You do not have permission to store queries")
qid = self.db.query.create(name=queryname,
klass=self.classname,
url=url,
private_for=uid)
# and add it to the user's query multilink
queries = self.db.user.get(self.userid, 'queries')
if qid not in queries:
queries.append(qid)
self.db.user.set(self.userid, queries=queries)
# commit the query change to the database
self.db.commit()
def handle(self):
''' Export the specified search query as CSV. '''
# figure the request
request = templating.HTMLRequest(self.client)
filterspec = request.filterspec
sort = request.sort
group = request.group
columns = request.columns
klass = self.db.getclass(request.classname)
# check if all columns exist on class
# the exception must be raised before sending header
props = klass.getprops()
for cname in columns:
if cname not in props:
# TODO raise exceptions.NotFound(.....) does not give message
# so using SeriousError instead
self.client.response_code = 404
raise exceptions.SeriousError(
self._('Column "%(column)s" not found on %(class)s') % {
'column': cgi.escape(cname),
'class': request.classname
})
# full-text search
if request.search_text:
matches = self.db.indexer.search(
re.findall(r'\b\w{2,25}\b', request.search_text), klass)
else:
matches = None
h = self.client.additional_headers
h['Content-Type'] = 'text/csv; charset=%s' % self.client.charset
# some browsers will honor the filename here...
h['Content-Disposition'] = 'inline; filename=query.csv'
self.client.header()
if self.client.env['REQUEST_METHOD'] == 'HEAD':
# all done, return a dummy string
return 'dummy'
wfile = self.client.request.wfile
if self.client.charset != self.client.STORAGE_CHARSET:
wfile = codecs.EncodedFile(wfile, self.client.STORAGE_CHARSET,
self.client.charset, 'replace')
writer = csv.writer(wfile)
self.client._socket_op(writer.writerow, columns)
# and search
for itemid in klass.filter(matches, filterspec, sort, group):
row = []
for name in columns:
# check permission to view this property on this item
if not self.hasPermission('View',
itemid=itemid,
classname=request.classname,
property=name):
raise exceptions.Unauthorised(
self._('You do not have permission to view %(class)s')
% {'class': request.classname})
row.append(str(klass.get(itemid, name)))
self.client._socket_op(writer.writerow, row)
return '\n'
def handle (self) :
self.request = templating.HTMLRequest (self.client)
if 'user' in self.request.form and self.request.form ['user'].value :
raise Reject, self._ ('''Don't specify a user for "Freeze all"''')
self.users = self.db.user.getnodeids ()
return self.__super.handle ()
def redirect(self):
url = templating.HTMLRequest (self.client).indexargs_url \
('' , { '@template' : 'send' })
raise Redirect, url
def set_request (self) :
""" figure the request """
if not hasattr (self, 'request') :
self.request = templating.HTMLRequest (self.client)
