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)