def pvc1_show_imageh5(request): # Loads JPEG images from hdf5 file h5_image_file = 'pvc1/pvc1_movie_frames.h5' movie_id = int(request.matchdict['movie_id']) segment_id = int(request.matchdict['segment_id']) frame = int(request.matchdict['frame']) image_dir = 'movie%03u_%03u.images' % (movie_id, segment_id) image_name = 'movie%03u_%03u_%03u.jpeg' % (movie_id, segment_id, frame) path = image_dir + '/' + image_name response = Response(content_type='image/jpeg') h5f = h5py.File(h5_image_file, 'r') try: ds = h5f[path] except KeyError: # missing file, generate an image to return img = Image.new("RGB", (320, 220,), "#cccccc" ) draw = ImageDraw.Draw(img) draw.text((15, 60), image_name + ' missing', fill='#000') f = cStringIO.StringIO() img.save(f, "jpeg") f.seek(0) response.app_iter = f else: dsv = ds.value response.app_iter = dsv h5f.close() return response
def get_file_response(filename, document_root=None, accel_header=None): """helper the get a file response""" if not os.path.isfile(filename): return HTTPNotFound() resp = Response(content_type=get_mimetype(filename), conditional_response=True) resp.content_length = os.path.getsize(filename) resp.last_modified = os.path.getmtime(filename) resp.etag = '%s-%s-%s' % (os.path.getmtime(filename), os.path.getsize(filename), hash(filename)) if accel_header: if accel_header.lower() == "x-accel-redirect": # return full path filename = filename[len(os.path.dirname(document_root)):] filename = '/%s' % filename.strip('/') resp.headers[accel_header.title()] = filename elif accel_header.lower() == "x-sendfile": # return full path resp.headers[accel_header.title()] = filename else: raise RuntimeError( "Can't find a way to use your %s header" % accel_header) resp.app_iter = [b''] else: resp.app_iter = FileIterable(filename) return resp
def show_img(request): '''画像表示 ''' file_name = request.matchdict['file_name'] md = model(request.db) file = md.get_file(file_name) response = Response() if file is not None: response.content_type = file.content_type response.app_iter = file else: response.content_type = 'image/jpeg' response.app_iter = open('nopict.jpg', 'rb') return response
def download_backup(request): encoded_filename = request.matchdict['backup_id'] headers = [] try: filename = base64.b64decode(encoded_filename).decode('utf-8') except TypeError: return HTTPNotFound() backups_dir = get_backups_dir() all_backups = [x for x in os.listdir(backups_dir) if os.path.isfile(os.path.join(backups_dir, x))] if filename not in all_backups: return HTTPNotFound() full_path = os.path.join(backups_dir, filename) if not os.path.isfile(full_path): return HTTPNotFound() headers = [] content_length = os.path.getsize(full_path) headers.append(('Content-Length', str(content_length))) headers.append(('Content-Disposition', str('attachment; filename={0}'.format(filename)))) response = Response(content_type='application/octet-stream') try: response.app_iter = open(full_path, 'rb') except IOError: return HTTPNotFound() response.headerlist += headers return response
def cover(request): sbid = request.matchdict['sbid'] response_headers = {'content_type': 'image/jpeg',} try: monograph = request.db.get(sbid) if 'thumbnail' in request.path: img = request.db.fetch_attachment(monograph,monograph['cover_thumbnail']['filename'], stream=True) else: img = request.db.fetch_attachment(monograph,monograph['cover']['filename'], stream=True) response_headers['expires'] = datetime_rfc822(365) except (couchdbkit.ResourceNotFound, KeyError): img = urllib2.urlopen(static_url('scielobooks:static/images/fakecover.jpg', request)) response = Response(**response_headers) response.app_iter = img try: response.etag = str(hash(img)) except TypeError: #cannot generate a hash for the object, return it without the ETag pass return response
def dynamic_item_img(request): item = Item.from_id(request.matchdict['item_id']) response = Response(content_type='image/jpeg') class Hack(): def __init__(self, img): self.img = img self.idx = 0 def getattr(self, item): print("item {}".format(item)) raise AttributeError def __getattr(self, item): print("item {}".format(item)) raise AttributeError def read(self, block_size = None): if self.idx >= len(self.img): return '' if block_size is None: self.idx = len(self.img) return self.img if self.idx + block_size > len(self.img): r = self.img[self.idx:] self.idx = len(self.img) return r else: r = self.img[self.idx:block_size] self.idx += block_size return r def close(self): pass h = Hack(item.img.img) response.app_iter = FileIter(h) return response
def __call__(self): request = self.request user = request.user if not user: return make_401_error(u'Access Denied') if 'airsexport' not in user.cic.ExternalAPIs: return make_401_error(u'Insufficient Permissions') model_state = modelstate.ModelState(request) model_state.schema = AIRSExportOptionsSchema() model_state.form.method = None if not model_state.validate(): if model_state.is_error('DST'): msg = u"Invalid Distribution" elif model_state.is_error("version"): msg = u"Invalid Version" else: msg = u"An unknown error occurred." log.error('AIRS Export Errors: %s: %s', msg, model_state.form.errors) return make_internal_server_error(msg) res = Response(content_type='application/zip', charset=None) res.app_iter, res.length = _zip_stream(request, model_state) res.headers['Content-Disposition'] = 'attachment;filename=Export.zip' return res
def __call__(self): data, record_data = self._really_do_it() data = json.dumps(data) file = tempfile.TemporaryFile() zip = zipfile.ZipFile(file, 'w', zipfile.ZIP_DEFLATED) zip.writestr('export.json', data) if record_data: try: zip.write(record_data, 'record_data.xml') finally: try: os.unlink(record_data) except: pass zip.close() length = file.tell() file.seek(0) res = Response(content_type='application/zip', charset=None) res.app_iter = FileIterator(file) res.content_length = length res.headers['Content-Disposition'] = 'attachment;filename=Export.zip' return res
def translation_template(request): resp = Response() resp.content_disposition = 'attachment; filename=oscad.pot' resp.app_iter = resource_stream('oscad', 'locale/oscad.pot') # otherwise Firefox thinks its a PowerPoint resp.content_type = 'text/plain' return resp
def get_ticket(request): """ this view gives a user access to her ticket via URL with code the response is a PDF download """ _code = request.matchdict['code'] _email = request.matchdict['email'] _ticket = PartyTicket.get_by_code(_code) if isinstance(_ticket, NoneType): return HTTPFound(location=request.route_url('party')) if not (_ticket.email == _email): #print("no match!") return HTTPFound(location=request.route_url('party')) # prepare ticket URL with email & code # 'https://events.c3s.cc/ci/p1402/' + _ticket.email + _ticket.email_confirm_code # 'https://192.168.2.128:6544/ci/p1402/' + _ticket.email + _ticket.email_confirm_code _url = request.registry.settings[ 'c3spartyticketing.url'] + '/ci/p1402/' + _ticket.email_confirm_code # return a pdf file pdf_file = make_qr_code_pdf(_ticket, _url) response = Response(content_type='application/pdf') pdf_file.seek(0) # rewind to beginning response.app_iter = open(pdf_file.name, "r") return response
def view_download(request): req = request url_dict = req.matchdict id1 = url_dict['id'].isdigit() and url_dict['id'] or 0 dis = url_dict['disposisi_id'].isdigit() and url_dict['disposisi_id'] or 0 si = DBSession.query(Disposisi.surat_id).\ filter(Disposisi.id==dis, ) row = DBSession.query(SuratDetail ).filter(SuratDetail.id==id1 ).first() b = row.path c = row.name d = row.mime if not row: return {'success':False, "msg":self.id_not_found()} settings = get_settings() dir_path = os.path.realpath(settings['static_files']) filename = os.path.join(dir_path, b) headers = [('Content-Disposition', 'attachment; filename=' + str(c))] response = Response(content_type=d, headerlist=headers) f = open(filename) response.app_iter = FileIter(f) print "----------------path------------------",b print "--------------nama file---------------",c print "------------content type--------------",d return response
def xhr_filemgr(self): cmd = '' cmd_args = dict() for k in self.request.params: if k == '_': continue if k == 'cmd': cmd = self.request.params[k] else: if k.endswith("[]"): k2 = k.rstrip("[]") cmd_args[k2] = self.request.params.getall(k) else: cmd_args[k] = self.request.params[k] finder = create_finder(self.context, self.request) try: finder.run(cmd, cmd_args) except FinderError as e: L.exception(e) if e.status: self.request.response.status = e.status if 'file' in finder.response: resp = Response() resp.app_iter = finder.response['file'] if finder.headers: for k, v in finder.headers.items(): resp.headers[k] = v return resp else: if finder.headers: for k, v in finder.headers.items(): self.request.response.headers[k] = v return finder.response
def sponsor_image_small(request): """ return a smaller image depending on the amount given (see get_sponsorshipGrade) """ #print "this is sponsor image" _code = request.matchdict['linkcode'] _abo = Abo.get_by_linkcode(_code) if isinstance(_abo, NoneType): if request.locale_name == 'de': the_url = 'zabo:static/ungueltig_s.png' else: the_url = 'zabo:static/invalid_s.png' return HTTPFound(request.static_url(the_url)) #the_url = 'zabo:static/badge' + _abo.get_sponsorshipGrade() + '.png' #return HTTPFound(request.static_url(the_url)) # XXX TODO: spool the files, don't serve from static !!! # link must be unknown to outside! base_path = request.registry.settings['base_path'] or '' the_file = os.path.abspath( os.path.join( base_path, 'zabo/static_offline/badge' + _abo.get_sponsorshipGrade() + '_s.png') ) response = Response(content_type='image/png') response.app_iter = open(the_file, "r") return response # pragma: no cover
def pdf_file(request): sbid = request.matchdict['sbid'] req_part = request.matchdict['part'].split('-') monograph = Monograph.get(request.db, sbid) if len(req_part) == 2 and req_part[1] == monograph.isbn: try: pdf_file = request.db.fetch_attachment(monograph._id, monograph.pdf_file['filename'], stream=True) except (couchdbkit.ResourceNotFound, AttributeError): raise exceptions.NotFound() else: parts = get_book_parts(monograph._id, request) try: selected_part = parts[int(req_part[2])] except (IndexError, ValueError): raise exceptions.NotFound() part = Part.get(request.db, selected_part['part_sbid']) try: pdf_file = request.db.fetch_attachment(part._id, part.pdf_file['filename'], stream=True) except (couchdbkit.ResourceNotFound, AttributeError): raise exceptions.NotFound() response = Response(content_type='application/pdf', expires=datetime_rfc822(365)) response.app_iter = pdf_file try: response.etag = str(hash(pdf_file)) except TypeError: #cannot generate a hash for the object, return it without the ETag pass return response
def swf_file(request): sbid = request.matchdict["sbid"] req_part = request.matchdict["part"] monograph = Monograph.get(request.db, sbid) if req_part == monograph.isbn: try: pdf_file = request.db.fetch_attachment(monograph._id, monograph.pdf_file["filename"]) except (couchdbkit.ResourceNotFound, AttributeError): raise exceptions.NotFound() else: parts = get_book_parts(monograph._id, request) try: selected_part = parts[int(req_part)] except (IndexError, ValueError): raise exceptions.NotFound() part = Part.get(request.db, selected_part["part_sbid"]) try: pdf_file = request.db.fetch_attachment(part._id, part.pdf_file["filename"]) except (couchdbkit.ResourceNotFound, AttributeError): raise exceptions.NotFound() swf_file = functions.convert_pdf2swf(pdf_file) response = Response(content_type="application/x-shockwave-flash") response.app_iter = swf_file return response
def swf_file(request): sbid = request.matchdict['sbid'] req_part = request.matchdict['part'] monograph = Monograph.get(request.db, sbid) if req_part == monograph.isbn: try: pdf_file = request.db.fetch_attachment(monograph._id, monograph.pdf_file['filename']) except (couchdbkit.ResourceNotFound, AttributeError): raise exceptions.NotFound() else: parts = get_book_parts(monograph._id, request) try: selected_part = parts[int(req_part)] except (IndexError, ValueError): raise exceptions.NotFound() part = Part.get(request.db, selected_part['part_sbid']) try: pdf_file = request.db.fetch_attachment(part._id, part.pdf_file['filename']) except (couchdbkit.ResourceNotFound, AttributeError): raise exceptions.NotFound() swf_file = functions.convert_pdf2swf(pdf_file) response = Response(content_type='application/x-shockwave-flash', expires=datetime_rfc822(365)) response.app_iter = swf_file try: response.etag = str(hash(swf_file)) except TypeError: #cannot generate a hash for the object, return it without the ETag pass return response
def SendFile(self, file): """ Creates the response and sends the file back. Uses the FileIterator. #!date format """ if not file: return HTTPNotFound() last_mod = file.mtime() if not last_mod: last_mod = self.context.meta.pool_change r = Response(content_type=str(GetMimeTypeExtension(file.extension)), conditional_response=True) iterator = file.iterator() if iterator: r.app_iter = iterator else: try: r.body = file.read() except FileNotFound: raise NotFound r.content_length = file.size r.last_modified = last_mod r.etag = '%s-%s' % (last_mod, hash(file.path)) r.cache_expires(self.fileExpires) return r
def pdf_file(request): sbid = request.matchdict['sbid'] req_part = request.matchdict['part'] monograph = Monograph.get(request.db, sbid) if req_part == monograph.isbn: try: pdf_file = request.db.fetch_attachment(monograph._id, monograph.pdf_file['filename'], stream=True) except (couchdbkit.ResourceNotFound, AttributeError): raise exceptions.NotFound() else: parts = get_book_parts(monograph._id, request) try: selected_part = parts[int(req_part)] except (IndexError, ValueError): raise exceptions.NotFound() part = Part.get(request.db, selected_part['part_sbid']) try: pdf_file = request.db.fetch_attachment(part._id, part.pdf_file['filename'], stream=True) except (couchdbkit.ResourceNotFound, AttributeError): raise exceptions.NotFound() response = Response(content_type='application/pdf') response.app_iter = pdf_file return response
def get_dues18_invoice(invoice, request): """ Gets the invoice and returns a PDF response. Args: invoice: The invoice for which the PDF is requested. request: The pyramid.request.Request object. Returns: A PDF response in case the invoice exists. Otherwise a redirect to the error page. """ if invoice is None: request.session.flash( u'No invoice found!', 'danger' # message queue for user ) return HTTPFound(request.route_url('error')) if invoice.is_reversal: pdf_file = make_reversal_pdf_pdflatex(invoice) else: pdf_file = make_invoice_pdf_pdflatex(invoice) response = Response(content_type='application/pdf') pdf_file.seek(0) response.app_iter = open(pdf_file.name, "r") return response
def generate_contract_de_fdf_pdf(user): """ take user information and generate fdf """ if DEBUG: # pragma: no cover print "===== this is generate_fdf_pdf" from fdfgen import forge_fdf fields = [ ('surname', user.surname), ('lastname', user.lastname), ('street', user.street), ('number', user.number), ('postcode', user.postcode), ('city', user.city), ('email', user.email), ('user_id', user.id), ('username', user.username), ('date_registered', user.date_registered), ('date_generated', datetime.now()), ] #generate fdf string fdf = forge_fdf("", fields, [], [], []) # write to file my_fdf_filename = "fdf" + str(user.id) + ".fdf" fdf_file = open(my_fdf_filename, "w") fdf_file.write(fdf) fdf_file.close() if DEBUG: # pragma: no cover print "fdf file written." res = os.popen( 'pdftk pdftk/berechtigungsvertrag-2.2.pdf fill_form %s output' ' formoutput.pdf flatten' % my_fdf_filename).read() if DEBUG: # pragma: no cover print res print "done: put data into form and finalized it" # delete the fdf file res = os.popen('rm %s' % my_fdf_filename) if DEBUG: # pragma: no cover print res print "combining with bank account form" # combine res = os.popen( 'pdftk formoutput.pdf pdftk/bankaccount.pdf output output.pdf').read() if DEBUG: # pragma: no cover print res print "combined personal form and bank form" # delete the fdf file os.popen('rm formoutput.pdf').read() # return a pdf file from pyramid.response import Response response = Response(content_type='application/pdf') response.app_iter = open("output.pdf", "r") return response
def image(photo, request): """ Show full-size image """ response = Response(content_type=photo.content_type) response.app_iter = photo.get_image(request.fs).read() return response
def qrcode(request): ''' streams a qrcode image for the param 'content' (defaults to http://trimet.org) ''' response = Response(content_type='image/png') content = html_utils.get_first_param(request, 'content', 'http://trimet.org') img_io = qr_to_stream(content) response.app_iter = img_io return response
def thumbnail(photo, request): """ Renders the thumbnailed image of the photo. """ response = Response(content_type="image/jpeg") response.app_iter = photo.get_thumbnail(request.fs).read() return response
def site(request): path = unquote(request.path) s3file = request.s3.get_file(path) if s3file is None: return HTTPNotFound() response = Response(content_type=s3file.content_type) response.app_iter = s3file return response
def stream(request): response = Response() response.headers.update({'Access-Control-Allow-Origin': '*'}) response.content_type = 'text/event-stream' response.cache_expires(0) response.app_iter = produce() return response
def toolbar_handler(request): root_path = request.route_path("debugtoolbar.root") request.exc_history = exc_history remote_addr = request.remote_addr if request.path.startswith(root_path) or (not remote_addr in hosts): return handler(request) toolbar = DebugToolbar(request, panel_classes) request.debug_toolbar = toolbar _handler = handler for panel in toolbar.panels: _handler = panel.wrap_handler(_handler) try: response = _handler(request) except Exception: info = sys.exc_info() if exc_history is not None: tb = get_traceback(info=info, skip=1, show_hidden_frames=False, ignore_system_exceptions=True) for frame in tb.frames: exc_history.frames[frame.id] = frame exc_history.tracebacks[tb.id] = tb body = tb.render_full(request, evalex=True).encode("utf-8", "replace") response = Response(body, status=500) toolbar.process_response(response) return response raise else: if intercept_redirects: # Intercept http redirect codes and display an html page with a # link to the target. if response.status_int in redirect_codes: redirect_to = response.location redirect_code = response.status_int if redirect_to: content = render( "pyramid_debugtoolbar:templates/redirect.jinja2", {"redirect_to": redirect_to, "redirect_code": redirect_code}, ) content = content.encode(response.charset) response.content_length = len(content) response.location = None response.app_iter = [content] response.status_int = 200 toolbar.process_response(response) return response finally: # break circref del request.debug_toolbar
def wait(request): obs = Observer(obss=observers) observers.append(obs) r = Response() r.content_type = 'application/json' r.app_iter = obs return r
def member_list_date_pdf_view(request): """ The membership list *for a given date* for printout as PDF. The date is supplied in and parsed from the URL, e.g. http://0.0.0.0:6543/aml-2014-12-31.pdf The PDF is generated using pdflatex. If the date is not parseable, an error message is shown. """ effective_date_string = '' try: effective_date_string = request.matchdict['date'] effective_date = datetime.strptime(effective_date_string, '%Y-%m-%d') \ .date() except (KeyError, ValueError): request.session.flash( "Invalid date! '{}' does not compute! " "try again, please! (YYYY-MM-DD)".format( effective_date_string), 'danger' ) return HTTPFound(request.route_url('error')) # TODO: repositories are data layer and must only be used by the business # layer. Introduce business layer logic which uses the repositories and can # be accessed by this view via the request. members = request.registry.member_information.get_accepted_members_sorted( effective_date) membership_list_entries = [] for member in members: membership_list_entries.append({ 'lastname': member.lastname, 'firstname': member.firstname, 'membership_number': member.membership_number, 'address1': member.address1, 'address2': member.address2, 'postcode': member.postcode, 'city': member.city, 'country': member.country, 'membership_date': member.membership_date, 'membership_loss_date': member.membership_loss_date, 'membership_loss_type': member.membership_loss_type, 'membership_number': member.membership_number, 'shares_count': request.registry.share_information \ .get_member_share_count( member.membership_number, effective_date) }) response = Response(content_type='application/pdf') response.app_iter = generate_membership_list_pdf( effective_date, membership_list_entries) return response
def get_file_from_attempt(request): """ Get a portion of a package bound to an Attempt. Get a specific member, by name: `/api/:api_id/files/:attempt_id/:target.zip/?file=:member` Get more than one specific members, by name: `/api/:api_id/files/:attempt_id/:target.zip/?file=:member&file=:member2` Get the full package: `/api/:api_id/files/:attempt_id/:target.zip/?full=true` """ has_body = False attempt_id = request.matchdict.get('attempt_id', None) try: attempt = request.db.query(models.Attempt).get(attempt_id) except DataError: return HTTPNotFound() if attempt is None: return HTTPNotFound() response = Response(content_type='application/zip') # Get the full package. if asbool(request.GET.get('full', False)): response.app_iter = open(attempt.filepath, 'rb') has_body = True else: # Get partial portions of the package. files = [member for attr, member in request.GET.items() if attr == 'file'] try: if files: response.app_iter = attempt.analyzer.subzip(*files) has_body = True except ValueError: return HTTPBadRequest() return response if has_body else HTTPBadRequest()
def gb_all_nicks_view(request): tf = tempfile.NamedTemporaryFile(prefix='genbank_export_nick_%s' % request.job.key, suffix='.gb', delete=True) tf.write(genbank.all_nicks_to_GB(request.job.id)) tf.seek(0) response = Response(content_type='text/plain') response.app_iter = tf response.headers['Content-Disposition'] = ("attachment; filename=all_nickases.gb") return response
def evaluation_attachments(request): sbid = request.matchdict['sbid'] filename = request.matchdict['filename'] monograph = Monograph.get(request.db, sbid) try: attachment = request.db.fetch_attachment(monograph._id, filename, stream=True) except couchdbkit.ResourceNotFound: raise exceptions.NotFound() response = Response(content_type='application/octet-stream') response.app_iter = attachment return response
def csv_all_guides_view(request): tf = tempfile.NamedTemporaryFile(prefix='csv_export_all_guides_%s' % request.job.key, suffix='.csv', delete=True) # this is where I usually put stuff in the file job = request.job tf.write(genbank.all_spacers_to_CSV(job)) tf.seek(0) response = Response(content_type='application/csv') response.app_iter = tf response.headers['Content-Disposition'] = ( "attachment; filename=offtargets.csv") return response
def convert(req): """ Post request variables: css: [] # json encoded xml: "" doctype: auto | xml | html | html5(default html) """ css = json.loads(req.params['css']) xml = req.params['xml'] doctype = req.params.get('doctype', 'html') if req.keep_stats: pdf = _stats(req, prince.create_pdf, xml, css, doctype) else: pdf = prince.create_pdf(xml, css, doctype) resp = Response(content_type='application/pdf') resp.app_iter = BytesIO(pdf) return resp
def csv_one_spacer_view(request): tf = tempfile.NamedTemporaryFile(prefix='csv_export_one_spacer_%s' % request.job.key, suffix='.csv', delete=True) # this is where I usually put stuff in the file job = request.job spacer = Session.query(Spacer).get(request.matchdict["spacerid"]) tf.write(genbank.one_spacer_to_CSV(job, spacer)) tf.seek(0) response = Response(content_type='application/csv') response.app_iter = tf response.headers['Content-Disposition'] = ( "attachment; filename=offtargets.csv") return response
def epub_file(request): sbid = request.matchdict['sbid'] monograph = Monograph.get(request.db, sbid) try: epub_file = request.db.fetch_attachment( monograph._id, monograph.epub_file['filename'], stream=True) except (couchdbkit.ResourceNotFound, AttributeError, KeyError): raise exceptions.NotFound() response = Response(content_type='application/epub', expires=datetime_rfc822(365)) response.app_iter = epub_file try: response.etag = str(hash(epub_file)) except TypeError: #cannot generate a hash for the object, return it without the ETag pass return response
def gb_one_nick_view(request): #response = Response(content_type='application/csv') tf = tempfile.NamedTemporaryFile(prefix='genbank_export_one_nick_%s' % request.job.key, suffix='.gb', delete=True) # this is where I usually put stuff in the file job = request.job sf = Session.query(Spacer).get(request.matchdict["spacerfwdid"]) sr = Session.query(Spacer).get(request.matchdict["spacerrevid"]) tf.write(genbank.one_nick_to_GB(job, sf, sr)) tf.seek(0) #response = Response(content_type='application/csv') response = Response(content_type='text/plain') response.app_iter = tf #response.headers['Content-Disposition'] = ("attachment; filename=nickase_export.gb") # a target=_blank return response
def search_handler(request): match = request.params.get('q', request.params.get('query', None)) entity_filter = request.params.get('entity_filter', '{http://pyff.io/role}idp') log.debug("match={}".format(match)) load_icon = request.params.get('load_icon', False) store = request.registry.md.store #import pdb; pdb.set_trace() def _response(): yield b('[') in_loop = False for e in store.search(query=match.lower(), entity_filter=entity_filter): if in_loop: yield b(',') yield b(dumps(e)) in_loop = True yield b(']') response = Response(content_type='application/json') response.app_iter = _response() return response
def cog(resource, request): request.resource_permission(PERM_READ) fn = env.raster_layer.workdir_filename(resource.fileobj) filesize = os.path.getsize(fn) if request.method == "HEAD": return Response( accept_ranges="bytes", content_length=filesize, content_type="image/geo+tiff" ) if request.method == "GET": if not resource.cog: raise ValidationError(_("Requested raster is not COG.")) range = request.range if range is None: raise ValidationError(_("Range header is missed or invalid.")) content_range = range.content_range(filesize) if content_range is None: raise ValidationError(_("Range %s can not be read." % range)) content_length = content_range.stop - content_range.start response = Response( status_code=206, content_range=content_range, content_type="image/geo+tiff" ) response.app_iter = RangeFileWrapper( open(fn, "rb"), offset=content_range.start, length=content_length ) response.content_length = content_length return response
def echo(request): """ Echo an uploaded file back to the client as an text/html document so it can be handled by Ext. The response is JSON-wrapped and base64-encoded to ensure that there are no special HTML characters or charset problems and so that braindead ext doesn't barf on it. See: http://docs.sencha.com/ext-js/3-4/#!/api/Ext.form.BasicForm-cfg-fileUpload """ if request.method != 'POST': return HTTPBadRequest() try: file = request.POST['file'] except KeyError: return HTTPBadRequest() response = Response() response.app_iter = json_base64_encode(file.filename, file.file) response.content_type = 'text/html' return response
def dynamic_item_img(request): item = Item.from_id(request.matchdict['item_id']) response = Response(content_type='image/jpeg') class Hack(): def __init__(self, img): self.img = img self.idx = 0 def getattr(self, item): print("item {}".format(item)) raise AttributeError def __getattr(self, item): print("item {}".format(item)) raise AttributeError def read(self, block_size=None): if self.idx >= len(self.img): return '' if block_size is None: self.idx = len(self.img) return self.img if self.idx + block_size > len(self.img): r = self.img[self.idx:] self.idx = len(self.img) return r else: r = self.img[self.idx:block_size] self.idx += block_size return r def close(self): pass h = Hack(item.img.img) response.app_iter = FileIter(h) return response
def echo(request): """ Echo an uploaded file back to the client as an text/html document so it can be handled by Ext. The response is JSON-wrapped and base64-encoded to ensure that there are no special HTML characters or charset problems and so that braindead ext does not barf on it. See: http://docs.sencha.com/ext-js/3-4/#!/api/Ext.form.BasicForm-cfg-fileUpload """ try: file_ = request.POST["file"] except KeyError: return HTTPBadRequest() response = Response() response.app_iter = json_base64_encode(file_.filename, file_.file) return set_common_headers(request, "echo", NO_CACHE, response=response, content_type="text/html")
def __call__(self): request = self.request user = request.user if not user: return make_401_error("Access Denied", "Export") if "clbcexport" not in user.cic.ExternalAPIs: return make_401_error("Insufficient Permissions", "Export") with request.connmgr.get_connection("admin") as conn: cursor = conn.execute( "SELECT CAST(Vendor AS nvarchar(max)) AS Vendor FROM CLBC_VENDOR_EXPORT" ) data = [x[0] for x in cursor.fetchall()] cursor.close() data.insert(0, '<?xml version="1.0" encoding="UTF-8"?>\r\n<Vendors>') data.append("</Vendors>") data = "\r\n".join(data).encode("utf8") file = tempfile.TemporaryFile() zip = zipfile.ZipFile(file, "w", zipfile.ZIP_DEFLATED) zip.writestr("export.xml", data) zip.close() length = file.tell() file.seek(0) res = Response(content_type="application/zip", charset=None) res.app_iter = FileIterator(file) res.content_length = length res.headers["Content-Disposition"] = "attachment;filename=Export.zip" return res
def phonology(request): """ Computes phonology of a specified perspective. Perspective is specified by request parameters 'perspective_client_id' and 'perspective_object_id', example of a request: /phonology?perspective_client_id=345&perspective_object_id=2. """ perspective_cid = request.params.get('perspective_client_id') perspective_oid = request.params.get('perspective_object_id') # Checking if we have limits on number of computed results. limit = (None if 'limit' not in request.params else int(request.params.get('limit'))) limit_exception = (None if 'limit_exception' not in request.params else int(request.params.get('limit_exception'))) limit_no_vowel = (None if 'limit_no_vowel' not in request.params else int(request.params.get('limit_no_vowel'))) limit_result = (None if 'limit_result' not in request.params else int(request.params.get('limit_result'))) # TODO: get perspective's translation and language it belongs to. # We get lexical entries of this perspective with markup'ed sounds. Sound = aliased(Entity, name = "Sound") PublishingSound = aliased(PublishingEntity, name = "PublishingSound") query = DBSession.query(LexicalEntry, Entity, Sound, PublishingEntity, PublishingSound).filter(and_( LexicalEntry.parent_client_id == perspective_cid, LexicalEntry.parent_object_id == perspective_oid, LexicalEntry.marked_for_deletion == False, Entity.parent_client_id == LexicalEntry.client_id, Entity.parent_object_id == LexicalEntry.object_id, Entity.marked_for_deletion == False, Entity.additional_metadata.contains({"data_type": "praat markup"}), PublishingEntity.client_id == Entity.client_id, PublishingEntity.object_id == Entity.object_id, PublishingEntity.published == True, PublishingEntity.accepted == True, Sound.client_id == Entity.self_client_id, Sound.object_id == Entity.self_object_id, Sound.marked_for_deletion == False, PublishingSound.client_id == Sound.client_id, PublishingSound.object_id == Sound.object_id, PublishingSound.published == True, PublishingSound.accepted == True)) # We process these lexical entries in batches. Just in case, it seems that perspectives rarely have more # then several hundred such lexical entries. exception_counter = 0 no_vowel_counter = 0 result_list = list() for index, row in enumerate(query.yield_per(100)): markup_url = row.Entity.content sound_url = row.Sound.content cache_key = 'phonology:{0}:{1}:{2}:{3}'.format( row.Sound.client_id, row.Sound.object_id, row.Entity.client_id, row.Entity.object_id) # Checking if we have cached result for this pair of sound/markup. cache_result = CACHE.get(cache_key) if cache_result == 'no_vowel': log.debug( '{0} (LexicalEntry {1}/{2}, sound-Entity {3}/{4}, markup-Entity {5}/{6}) ' '[CACHE {7}]: no vowels\n{8}\n{9}'.format( index, row.LexicalEntry.client_id, row.LexicalEntry.object_id, row.Sound.client_id, row.Sound.object_id, row.Entity.client_id, row.Entity.object_id, cache_key, markup_url, sound_url)) no_vowel_counter += 1 if (limit_no_vowel and no_vowel_counter >= limit_no_vowel or limit and index + 1 >= limit): break continue # If we have cached exception, we do the same as with absence of vowels, show its info and # continue. elif isinstance(cache_result, tuple) and cache_result[0] == 'exception': exception, traceback_string = cache_result[1:3] log.debug( '{0} (LexicalEntry {1}/{2}, sound-Entity {3}/{4}, markup-Entity {5}/{6}): ' '[CACHE {7}]: exception\n{8}\n{9}'.format( index, row.LexicalEntry.client_id, row.LexicalEntry.object_id, row.Sound.client_id, row.Sound.object_id, row.Entity.client_id, row.Entity.object_id, cache_key, markup_url, sound_url)) log.debug(traceback_string) exception_counter += 1 if (limit_exception and exception_counter >= limit_exception or limit and index + 1 >= limit): break continue # If we actually have the result, we use it and continue. elif cache_result: result_string = '\n'.join( 'tier {0} \'{1}\': {2}'.format(tier_number, tier_name, tier_result_seq_list if not isinstance(tier_result_seq_list, list) else tier_result_seq_list[0] if len(tier_result_seq_list) <= 1 else ''.join('\n {0}'.format(tier_result) for tier_result in tier_result_seq_list)) for tier_number, tier_name, tier_result_seq_list in cache_result) log.debug( '{0} (LexicalEntry {1}/{2}, sound-Entity {3}/{4}, markup-Entity {5}/{6}) ' '[CACHE {7}]:\n{8}\n{9}\n{10}'.format( index, row.LexicalEntry.client_id, row.LexicalEntry.object_id, row.Sound.client_id, row.Sound.object_id, row.Entity.client_id, row.Entity.object_id, cache_key, markup_url, sound_url, result_string)) result_list.append(cache_result) if (limit_result and len(result_list) >= limit_result or limit and index + 1 >= limit): break continue try: # Getting markup, checking for each tier if it needs to be processed. markup_bytes = urllib.request.urlopen(urllib.parse.quote(markup_url, safe = '/:')).read() textgrid = pympi.Praat.TextGrid(xmax = 0) textgrid.from_file( io.BytesIO(markup_bytes), codec = chardet.detect(markup_bytes)['encoding']) tier_data_list = [] vowel_flag = False for tier_number, tier_name in textgrid.get_tier_name_num(): raw_interval_list = textgrid.get_tier(tier_number).get_all_intervals() raw_interval_seq_list = [[]] # Splitting interval sequence on empty intervals. for raw_index, interval in enumerate(raw_interval_list): if len(interval[2].strip()) <= 0: if len(raw_interval_seq_list[-1]) > 0: raw_interval_seq_list.append([]) else: raw_interval_seq_list[-1].append((raw_index, interval)) if len(raw_interval_seq_list[-1]) <= 0: del raw_interval_seq_list[-1] # Selecting interval sequences for analysis, checking if we have unusual markup. interval_seq_list = [] interval_idx_to_raw_idx = dict() unusual_markup_flag = False unusual_markup_list = [] for raw_interval_seq in raw_interval_seq_list: interval_seq_list.append([]) interval_idx_to_raw_idx[len(interval_seq_list) - 1] = {} for partial_raw_index, (raw_index, interval) in enumerate(raw_interval_seq): interval_text = interval[2].strip() # Accepting interval if its text contains at least one vowel, and is short enough or # is a valid phonetic transcription. transcription_check = re.fullmatch(transcription_re, interval_text) if (len(interval_text) > 0 and any(character in vowel_set for character in interval_text) and (len(interval_text) <= 2 or transcription_check)): interval_seq_list[-1].append(interval) sequence_index = len(interval_seq_list) - 1 interval_index = len(interval_seq_list[-1]) - 1 interval_idx_to_raw_idx[(sequence_index, interval_index)] = raw_index interval_idx_to_raw_idx[sequence_index][interval_index] = partial_raw_index # Noting if the interval contains unusual (i.e. non-transcription) markup. elif not transcription_check: unusual_markup_flag = True unusual_markup_list.append((raw_index, interval)) transcription_list = [text for begin, end, text in raw_interval_list] transcription = ''.join(transcription_list) selected_list = [text for interval_list in interval_seq_list for begin, end, text in interval_list] selected = ''.join(selected_list) # If we have intervals with unusual markup, we report them. if unusual_markup_flag: log.debug( '{0} (LexicalEntry {1}/{2}, sound-Entity {3}/{4}, markup-Entity {5}/{6}): ' 'tier {7} \'{8}\' has interval(s) with unusual transcription text: ' '{9} / {10}'.format( index, row.LexicalEntry.client_id, row.LexicalEntry.object_id, row.Sound.client_id, row.Sound.object_id, row.Entity.client_id, row.Entity.object_id, tier_number, tier_name, transcription, dict(unusual_markup_list))) # If the markup does not have any vowels, we note it and also report it. if all(character not in vowel_set for character in transcription): tier_data_list.append((tier_number, tier_name, 'no_vowel')) log.debug( '{0} (LexicalEntry {1}/{2}, sound-Entity {3}/{4}, markup-Entity {5}/{6}): ' 'tier {7} \'{8}\' doesn\'t have any vowel markup: {9}'.format( index, row.LexicalEntry.client_id, row.LexicalEntry.object_id, row.Sound.client_id, row.Sound.object_id, row.Entity.client_id, row.Entity.object_id, tier_number, tier_name, transcription_list)) # It is also possible that while full transcription has vowels, intervals selected for # analysis do not. In that case we also note it and report it. elif not any(character in vowel_set for character in selected): tier_data_list.append((tier_number, tier_name, 'no_vowel_selected')) log.debug( '{0} (LexicalEntry {1}/{2}, sound-Entity {3}/{4}, markup-Entity {5}/{6}): ' 'tier {7} \'{8}\' intervals to be processed don\'t have any vowel markup: ' 'markup {9}, selected {10}'.format( index, row.LexicalEntry.client_id, row.LexicalEntry.object_id, row.Sound.client_id, row.Sound.object_id, row.Entity.client_id, row.Entity.object_id, tier_number, tier_name, transcription_list, selected_list)) # Otherwise we store tier data to be used during processing of the sound file. else: tier_data_list.append((tier_number, tier_name, (raw_interval_list, raw_interval_seq_list, interval_seq_list, interval_idx_to_raw_idx, transcription))) vowel_flag = True # If there are no tiers with vowel markup, we skip this sound-markup file altogether. if not vowel_flag: CACHE.set(cache_key, 'no_vowel') no_vowel_counter += 1 if (limit_no_vowel and no_vowel_counter >= limit_no_vowel or limit and index + 1 >= limit): break continue # Otherwise we retrieve the sound file and analyse each vowel-containing markup. # Partially inspired by source code at scripts/convert_five_tiers.py:307. sound = None with tempfile.NamedTemporaryFile() as temp_file: sound_file = urllib.request.urlopen(urllib.parse.quote(sound_url, safe = '/:')) temp_file.write(sound_file.read()) temp_file.flush() sound = AudioPraatLike(pydub.AudioSegment.from_wav(temp_file.name)) tier_result_list = [] for tier_number, tier_name, tier_data in tier_data_list: if tier_data == 'no_vowel' or tier_data == 'no_vowel_selected': tier_result_list.append((tier_number, tier_name, tier_data)) continue # Analyzing vowel sounds of each interval sequence. (raw_interval_list, raw_interval_seq_list, interval_seq_list, interval_idx_to_raw_idx, transcription) = tier_data tier_result_list.append((tier_number, tier_name, [])) for seq_index, (raw_interval_list, interval_list) in enumerate(zip( raw_interval_seq_list, interval_seq_list)): if len(interval_list) <= 0: continue (max_intensity_index, max_intensity, max_length_index, max_length) = \ find_max_interval_praat(sound, interval_list) max_intensity_interval = interval_list[max_intensity_index] max_length_interval = interval_list[max_length_index] max_intensity_f1_f2 = sound.get_interval_formants(*max_intensity_interval[:2]) max_length_f1_f2 = sound.get_interval_formants(*max_length_interval[:2]) # Compiling results. max_length_str = '{0} {1:.3f} [{2}]'.format( max_length_interval[2], max_length, len(''.join(text for index, (begin, end, text) in raw_interval_list[:interval_idx_to_raw_idx[seq_index][max_length_index]]))) max_intensity_str = '{0} {1:.3f} [{2}]'.format( max_intensity_interval[2], max_intensity, len(''.join(text for index, (begin, end, text) in raw_interval_list[:interval_idx_to_raw_idx[seq_index][max_intensity_index]]))) tier_result_list[-1][2].append([ ''.join(text for index, (begin, end, text) in raw_interval_list), max_length_str, '{0:.3f}'.format(max_length_f1_f2[0]), '{0:.3f}'.format(max_length_f1_f2[1]), max_intensity_str, '{0:.3f}'.format(max_intensity_f1_f2[0]), '{0:.3f}'.format(max_intensity_f1_f2[1]), '+' if max_intensity_index == max_length_index else '-']) # Saving result. result_list.append(tier_result_list) CACHE.set(cache_key, tier_result_list) result_string = '\n'.join( 'tier {0} \'{1}\': {2}'.format(tier_number, tier_name, tier_result_seq_list if not isinstance(tier_result_seq_list, list) else tier_result_seq_list[0] if len(tier_result_seq_list) <= 1 else ''.join('\n {0}'.format(tier_result) for tier_result in tier_result_seq_list)) for tier_number, tier_name, tier_result_seq_list in tier_result_list) log.debug( '{0} (LexicalEntry {1}/{2}, sound-Entity {3}/{4}, markup-Entity {5}/{6}):' '\n{7}\n{8}\n{9}'.format( index, row.LexicalEntry.client_id, row.LexicalEntry.object_id, row.Sound.client_id, row.Sound.object_id, row.Entity.client_id, row.Entity.object_id, markup_url, sound_url, result_string)) # Stopping earlier, if required. if (limit_result and len(result_list) >= limit_result or limit and index + 1 >= limit): break except Exception as exception: # # NOTE # # Exceptional situations encountered so far: # # 1. TextGrid file actually contains sound, and wav file actually contains textgrid markup. # # Perspective 330/4, LexicalEntry 330/7, sound-Entity 330/2328, markup-Entity 330/6934 # # 2. Markup for one of the intervals contains a newline "\n", and pympi fails to parse it. # Praat parses such files without problems. # # Perspective 330/4, LexicalEntry 330/20, sound-Entity 330/6297, markup-Entity 330/6967 # log.debug( '{0} (LexicalEntry {1}/{2}, sound-Entity {3}/{4}, markup-Entity {5}/{6}): ' 'exception\n{7}\n{8}'.format( index, row.LexicalEntry.client_id, row.LexicalEntry.object_id, row.Sound.client_id, row.Sound.object_id, row.Entity.client_id, row.Entity.object_id, markup_url, sound_url)) # if we encountered an exception, we show its info and remember not to try offending # sound/markup pair again. traceback_string = ''.join(traceback.format_exception( exception, exception, exception.__traceback__))[:-1] log.debug(traceback_string) CACHE.set(cache_key, ('exception', exception, traceback_string.replace('Traceback', 'CACHEd traceback'))) exception_counter += 1 if (limit_exception and exception_counter >= limit_exception or limit and index + 1 >= limit): break log.debug('phonology {0}/{1}: {2} result{3}, {4} no vowels, {5} exceptions'.format( perspective_cid, perspective_oid, len(result_list), '' if len(result_list) == 1 else 's', no_vowel_counter, exception_counter)) # If we have no results, we indicate the situation and also show number of failures and number of # markups with no vowels. if not result_list: request.response.status = HTTPPreconditionFailed.code return { "error": "no markups for this query", "exception_counter": exception_counter, "no_vowel_counter": no_vowel_counter} # Otherwise we create and then serve Excel file. excel_book = xlwt.Workbook(encoding = "utf-8") sheet = excel_book.add_sheet("Sheet 1") sheet.write(0, 0, 'Transcription') sheet.write(0, 1, 'Longest (seconds) interval') sheet.write(0, 2, 'F1 (Hz)') sheet.write(0, 3, 'F2 (Hz)') sheet.write(0, 4, 'Highest intensity (dB) interval') sheet.write(0, 5, 'F1 (Hz)') sheet.write(0, 6, 'F2 (Hz)') sheet.write(0, 7, 'Coincidence') row_counter = 1 for tier_result_list in result_list: for tier_number, tier_name, tier_result_seq_list in tier_result_list: if tier_result_seq_list == 'no_vowel': continue for tier_data in tier_result_seq_list: for index, tier_data_str in enumerate(tier_data): sheet.write(row_counter, index, tier_data_str) row_counter += 1 # Formatting column widths. sheet.col(0).width = 24 * 256 sheet.col(1).width = 24 * 256 sheet.col(2).width = 12 * 256 sheet.col(3).width = 12 * 256 sheet.col(4).width = 24 * 256 sheet.col(5).width = 12 * 256 sheet.col(6).width = 12 * 256 sheet.col(7).width = 12 * 256 excel_stream = io.BytesIO() excel_book.save(excel_stream) excel_stream.seek(0) # See http://stackoverflow.com/questions/2937465/what-is-correct-content-type-for-excel-files for Excel # content-type. response = Response(content_type = 'application/vnd.ms-excel') response.app_iter = FileIter(excel_stream) response.headers['Content-Disposition'] = "attachment; filename=phonology.xls" return response
def toolbar_tween(request): root_path = request.route_path(ROOT_ROUTE_NAME) request.exc_history = exc_history remote_addr = request.remote_addr if (request.path.startswith(root_path) or (not remote_addr in hosts)): return handler(request) toolbar = DebugToolbar(request, panel_classes) request.debug_toolbar = toolbar _handler = handler for panel in toolbar.panels: _handler = panel.wrap_handler(_handler) try: response = _handler(request) except Exception: if exc_history is not None: tb = get_traceback(info=sys.exc_info(), skip=1, show_hidden_frames=False, ignore_system_exceptions=True) for frame in tb.frames: exc_history.frames[frame.id] = frame exc_history.tracebacks[tb.id] = tb body = tb.render_full(request).encode('utf-8', 'replace') response = Response(body, status=500) toolbar.process_response(response) qs = {'token': exc_history.token, 'tb': str(tb.id)} msg = 'Exception at %s\ntraceback url: %s' exc_url = request.route_url(EXC_ROUTE_NAME, _query=qs) exc_msg = msg % (request.url, exc_url) logger.exception(exc_msg) return response else: logger.exception('Exception at %s' % request.url) raise else: if intercept_redirects: # Intercept http redirect codes and display an html page with a # link to the target. if response.status_int in redirect_codes: redirect_to = response.location redirect_code = response.status_int if redirect_to: content = render( 'pyramid_debugtoolbar:templates/redirect.mako', { 'redirect_to': redirect_to, 'redirect_code': redirect_code }, request=request) content = content.encode(response.charset) response.content_length = len(content) response.location = None response.app_iter = [content] response.status_int = 200 toolbar.process_response(response) return response finally: # break circref del request.debug_toolbar
def events(request): headers = [('Content-Type', 'text/event-stream'), ('Cache-Control', 'no-cache')] response = Response(headerlist=headers) response.app_iter = message_generator() return response
def generate_pdf(appstruct): """ this function receives an appstruct (a datastructure received via formsubmission) and prepares and returns a PDF using pdftk """ DEBUG = False fdf_file = tempfile.NamedTemporaryFile() pdf_file = tempfile.NamedTemporaryFile() # import logging # log = logging.getLogger(__name__) # log.info("test ...! ") import os here = os.path.dirname(__file__) registration_form_template = os.path.join(here, "../customization/registrationForm/current-{}.pdf") try: pdf_to_be_used =registration_form_template.format(appstruct['locale']) open(pdf_to_be_used) except IOError: # deliberatly error out if fallback does not exist pdf_to_be_used = registration_form_template.format(customization.default_language) open(pdf_to_be_used) # convert the date in date_of_birth # print( # "generate_pdf: appstruct: date of birth: %s") % ( # appstruct['date_of_birth']) # print( # "generate_pdf: type of appstruct: date of birth: %s") % type( # appstruct['date_of_birth']) # print( # "generate_pdf: str of appstruct: date of birth: %s") % str( # appstruct['date_of_birth']) # print("appstruct: date of birth: %s") % appstruct['date_of_birth'] # print("appstruct: date of submission: %s") % appstruct[ # 'date_of_submission'] dob_ = time.strptime(str(appstruct['date_of_birth']), '%Y-%m-%d') # print("generate_pdf: date of birth: %s") % dob_ dob = time.strftime("%d.%m.%Y", dob_) # print("generate_pdf: date of birth: %s") % dob # dos_ = time.strptime( # str(appstruct['date_of_submission']), # '%Y-%m-%d %H:%M:%S' # ) # print("generate_pdf: date of submission: %s") % dos_ dos = str(appstruct['date_of_submission']) # print("generate_pdf: date of submission: %s") % dos # print("generate_pdf: type of date of birth: %s") % type(dob) # print("generate_pdf: date of birth: %s") % dob # membership_type # FieldType: Button # FieldName: MembershipType # FieldFlags: 49152 # FieldValue: 2 # FieldJustification: Left # FieldStateOption: 1 # FieldStateOption: 2 # FieldStateOption: Off # print("the membership type: %s" % appstruct['membership_type']) # calculate the amount to be transferred # print("the amount: %s" % (appstruct['num_shares'] * 50)) amount = str(appstruct['num_shares'] * 50) # here we gather all information from the supplied data to prepare pdf-filling from datetime import datetime fields = [ ('firstname', appstruct['firstname']), ('lastname', appstruct['lastname']), ('streetNo', appstruct['address1']), ('address2', appstruct['address2']), ('postcode', appstruct['postcode']), ('town', appstruct['city']), ('email', appstruct['email']), ('country', appstruct['country']), ('MembershipType', '1' if appstruct[ 'membership_type'] == u'normal' else '2'), ('numshares', str(appstruct['num_shares'])), ('dateofbirth', dob), ('submitted', dos), ('generated', str(datetime.now())), ('code', appstruct['email_confirm_code']), ('code2', appstruct['email_confirm_code']), # for page 2 ('amount', amount), # for page 2 ] # generate fdf string fdf = forge_fdf("", fields, [], [], []) # write it to a file if DEBUG: # pragma: no cover print("== prepare: write fdf") fdf_file.write(fdf) fdf_file.seek(0) # rewind to beginning # process the PDF, fill in prepared data if DEBUG: # pragma: no cover print("== PDFTK: fill_form & flatten") print("running pdftk...") pdftk_output = subprocess.call( [ 'pdftk', pdf_to_be_used, # input pdf with form fields 'fill_form', fdf_file.name, # fill in values 'output', pdf_file.name, # output file 'flatten', # make form read-only # 'verbose' # be verbose? ] ) if DEBUG: # pragma: no cover print(pdf_file.name) pdf_file.seek(0) if DEBUG: # pragma: no cover print("===== pdftk output ======") print(pdftk_output) # return a pdf file from pyramid.response import Response response = Response(content_type='application/pdf') pdf_file.seek(0) # rewind to beginning response.app_iter = open(pdf_file.name, "r") return response
def generate_pdf(appstruct): """ this function receives an appstruct (a datastructure received via formsubmission) and prepares and returns a PDF using pdftk """ DEBUG = False fdf_file = tempfile.NamedTemporaryFile() pdf_file = tempfile.NamedTemporaryFile() #import logging #log = logging.getLogger(__name__) #log.info("test ...! ") import os here = os.path.dirname(__file__) declaration_pdf_de = os.path.join( here, "../pdftk/C3S-SCE-AFM-de-v01-20131029.pdf") declaration_pdf_en = os.path.join( here, "../pdftk/C3S-SCE-AFM-en-v01-20130909.pdf") # check for _LOCALE_, decide which language to use #print(appstruct['_LOCALE_']) if appstruct['_LOCALE_'] == "de": pdf_to_be_used = declaration_pdf_de elif appstruct['_LOCALE_'] == "en": pdf_to_be_used = declaration_pdf_en else: # pragma: no cover # default fallback: english pdf_to_be_used = declaration_pdf_en # convert the date in date_of_birth #print( # "generate_pdf: appstruct: date of birth: %s") % ( # appstruct['date_of_birth']) #print( # "generate_pdf: type of appstruct: date of birth: %s") % type( # appstruct['date_of_birth']) #print( # "generate_pdf: str of appstruct: date of birth: %s") % str( # appstruct['date_of_birth']) #print("appstruct: date of birth: %s") % appstruct['date_of_birth'] #print("appstruct: date of submission: %s") % appstruct['date_of_submission'] dob_ = time.strptime(str(appstruct['date_of_birth']), '%Y-%m-%d') #print("generate_pdf: date of birth: %s") % dob_ dob = time.strftime("%d.%m.%Y", dob_) #print("generate_pdf: date of birth: %s") % dob #dos_ = time.strptime( # str(appstruct['date_of_submission']), # '%Y-%m-%d %H:%M:%S' #) #print("generate_pdf: date of submission: %s") % dos_ dos = str(appstruct['date_of_submission']) #print("generate_pdf: date of submission: %s") % dos #print("generate_pdf: type of date of birth: %s") % type(dob) #print("generate_pdf: date of birth: %s") % dob # here we gather all information from the supplied data to prepare pdf-filling from datetime import datetime fields = [ ('firstname', appstruct['firstname']), ('lastname', appstruct['lastname']), ('streetNo', appstruct['address1']), ('address2', appstruct['address2']), ('postcode', appstruct['postcode']), ('town', appstruct['city']), ('email', appstruct['email']), ('country', appstruct['country']), ('numshares', str(appstruct['num_shares'])), # ('composer', # 'Yes' if appstruct['activity'].issuperset(['composer']) else 'Off'), # ('lyricist', # 'Yes' if appstruct['activity'].issuperset(['lyricist']) else 'Off'), # ('producer', 'Yes' if appstruct['activity'].issuperset( # ['music producer']) else 'Off'), # ('remixer', # 'Yes' if appstruct['activity'].issuperset(['remixer']) else 'Off'), # ('dj', # 'Yes' if appstruct['activity'].issuperset(['dj']) else 'Off'), #('YesDataProtection', #'Yes' if appstruct[ # #'noticed_dataProtection'] == u"(u'yes',)" else 'Off'), # ('inColSoc', '1' if appstruct['member_of_colsoc'] == u'yes' else '2'), # ('inColSocName', # appstruct['name_of_colsoc'] if appstruct['member_of_colsoc'] == u'yes' else ''), # ('URL', appstruct['opt_URL']), # ('bandPseudonym', appstruct['opt_band']), # ('investMmbr', '1' if appstruct['invest_member'] == u'yes' else '2'), ('dateofbirth', dob), ('submitted', dos), ('generated', str(datetime.now())) ] # generate fdf string fdf = forge_fdf("", fields, [], [], []) # write it to a file if DEBUG: # pragma: no cover print("== prepare: write fdf") fdf_file.write(fdf) fdf_file.seek(0) # rewind to beginning # process the PDF, fill in prepared data if DEBUG: # pragma: no cover print("== PDFTK: fill_form & flatten") print("running pdftk...") pdftk_output = subprocess.call([ 'pdftk', pdf_to_be_used, # input pdf with form fields 'fill_form', fdf_file.name, # fill in values 'output', pdf_file.name, # output file 'flatten', # make form read-only #'verbose' # be verbose? ]) if DEBUG: # pragma: no cover print(pdf_file.name) pdf_file.seek(0) if DEBUG: # pragma: no cover print("===== pdftk output ======") print(pdftk_output) # return a pdf file from pyramid.response import Response response = Response(content_type='application/pdf') pdf_file.seek(0) # rewind to beginning response.app_iter = open(pdf_file.name, "r") return response
def join_membership(request): locale = get_localizer(request) print "-- locale: " + str(locale) #print "-- dir(locale): " + str(dir(locale)) #print "-- help(locale): " + str(help(locale)) print "-- locale.locale_name: " + locale.locale_name locale_name = get_locale_name(request) print "-- locale_name: " + str(locale_name) #print "-- dir(locale_name): " + str(dir(locale_name)) #print "-- help(locale): " + str(help(locale)) #print "-- locale_name.locale_name: " + locale.locale_name form = Form(request, schema = MembershipSchema) if form.validate(): print "the form validated OK" if 'form.submitted' in request.POST and form.validate(): print "form was submitted and validated OK." #print "membership_type: " + str(form.data['membership_type']) #if 'supporter' in form.data['membership_type']: # print "found 'supporter'" # membership_fee = 42 # FoerderMitglied = True # OrdentlichesMitglied = False #else: # print "'supporter' not found" # membership_fee = 23 # FoerderMitglied = 'Off' # OrdentlichesMitglied = 'On' #print "request.POST: " + str(request.POST) fields = [ ('Name', form.data['lastname']), ('Surname', form.data['surname']), ('Street', form.data['address1']), ('PostCodeCity', form.data['address2']), ('Telephone', form.data['phone']), ('Email', form.data['email']), ('OrdentlichesMitglied', 'OrdentlichesMitglied'), # not working ('FoerderMitglied', 'FoerderMitglied'), # not working. < ToDo ^ ] #generate fdf string fdf = forge_fdf("", fields, [], [], []) # write to file my_fdf_filename = "fdf.fdf" import os fdf_file = open(my_fdf_filename , "w") # fdf_file.write(fdf.encode('utf8')) fdf_file.write(fdf) fdf_file.close() print os.popen('pdftk pdftk/beitrittserklaerung.pdf fill_form %s output formoutput.pdf flatten'% (my_fdf_filename)).read() #print os.popen('pwd').read() #print os.popen('ls').read() # combine print "combining with bank account form" print os.popen('pdftk formoutput.pdf pdftk/bankaccount.pdf output combined.pdf').read() print "combined personal form and bank form" # return a pdf file from pyramid.response import Response response = Response(content_type='application/pdf') response.app_iter = open("combined.pdf", "r") return response return { 'form': FormRenderer(form) }
def stdout(self): """Returns file object of stdout.txt file of job""" response = Response(content_type='text/plain') response.app_iter = self.job.stdout() return response
def get_file_from_attempt(request): """ Get a portion of a package bound to an Attempt. Get a specific member, by name (raw): `/api/:api_id/files/:attempt_id/:target?file=:member&raw=true` Get a specific member, by name: `/api/:api_id/files/:attempt_id/:target.zip?file=:member` Get more than one specific members, by name: `/api/:api_id/files/:attempt_id/:target.zip?file=:member&file=:member2` Get the full package: `/api/:api_id/files/:attempt_id/:target.zip?full=true` """ has_body = False attempt_id = request.matchdict.get('attempt_id', None) target = request.matchdict.get('target', None) try: attempt = request.db.query(models.Attempt).get(attempt_id) except DataError: return HTTPNotFound() if attempt is None: return HTTPNotFound() is_full = asbool(request.GET.get('full', False)) is_raw = asbool(request.GET.get('raw', False)) if is_full and is_raw: return HTTPBadRequest() response = Response(status_code=200) # Get the full package. if is_full: response.content_type = 'application/zip' response.app_iter = open(attempt.filepath, 'rb') has_body = True elif is_raw: member_name = request.GET.get('file') response.content_type = 'text/xml' response.app_iter = attempt.analyzer.get_fp(member_name) has_body = True else: response.content_type = 'application/zip' # Get partial portions of the package. files = [member for attr, member in request.GET.items() if attr == 'file'] try: if files: response.app_iter = attempt.analyzer.subzip(*files) has_body = True except ValueError: return HTTPBadRequest() return response if has_body else HTTPBadRequest()
def toolbar_tween(request): root_path = request.route_path(ROOT_ROUTE_NAME) exclude = [root_path] + exclude_prefixes request.exc_history = exc_history last_proxy_addr = None try: p = request.path except UnicodeDecodeError as e: raise URLDecodeError(e.encoding, e.object, e.start, e.end, e.reason) starts_with_excluded = list(filter(None, map(p.startswith, exclude))) if request.remote_addr: last_proxy_addr = last_proxy(request.remote_addr) if last_proxy_addr is None \ or starts_with_excluded \ or not addr_in(last_proxy_addr, hosts) \ or auth_check and not auth_check(request): return handler(request) toolbar = DebugToolbar(request, panel_classes) request.debug_toolbar = toolbar _handler = handler for panel in toolbar.panels: _handler = panel.wrap_handler(_handler) try: response = _handler(request) except Exception: if exc_history is not None: tb = get_traceback(info=sys.exc_info(), skip=1, show_hidden_frames=False, ignore_system_exceptions=True) for frame in tb.frames: exc_history.frames[frame.id] = frame exc_history.tracebacks[tb.id] = tb body = tb.render_full(request).encode('utf-8', 'replace') response = Response(body, status=500) toolbar.process_response(response) qs = {'token': exc_history.token, 'tb': str(tb.id)} msg = 'Exception at %s\ntraceback url: %s' exc_url = request.route_url(EXC_ROUTE_NAME, _query=qs) exc_msg = msg % (request.url, exc_url) _logger.exception(exc_msg) return response else: _logger.exception('Exception at %s' % request.url) raise else: if intercept_redirects: # Intercept http redirect codes and display an html page with a # link to the target. if response.status_int in redirect_codes: redirect_to = response.location redirect_code = response.status_int if redirect_to: content = render( 'pyramid_debugtoolbar:templates/redirect.dbtmako', { 'redirect_to': redirect_to, 'redirect_code': redirect_code }, request=request) content = content.encode(response.charset) response.content_length = len(content) response.location = None response.app_iter = [content] response.status_int = 200 if not show_on_exc_only: toolbar.process_response(response) return response finally: # break circref del request.debug_toolbar
def pdf_file(request): sbid = request.matchdict['sbid'] req_part = request.matchdict['part'].split('-') monograph = Monograph.get(request.db, sbid) if len(req_part) == 2: if req_part[1] != getattr(monograph, 'isbn', None) and req_part[1] != getattr( monograph, 'eisbn', None): raise exceptions.NotFound() try: url = static_url( 'scielobooks:fileserver/{0}/pdf/{1}.pdf'.format( sbid, request.matchdict['part']), request) u = urllib2.urlopen(url) return HTTPFound(location=url) except (urllib2.HTTPError, urllib2.URLError): #cannot find in static file server, fetch from db try: pdf_file = request.db.fetch_attachment( monograph._id, monograph.pdf_file['filename'], stream=True) except (couchdbkit.ResourceNotFound, AttributeError): raise exceptions.NotFound() else: if asbool( request.registry.settings.get('fileserver_sync_enable', False)): if req_part[1] == getattr(monograph, 'eisbn', None) and getattr( monograph, 'isbn', None): #when the eisbn is registered at an already published book. The eisbn takes #precedence when generating the shortname. source_filename = '-'.join([ monograph.shortname.split('-')[0], monograph.isbn ]) try: url = static_url( 'scielobooks:fileserver/{0}/pdf/{1}.pdf'. format(sbid, source_filename), request) u = urllib2.urlopen(url) except (urllib2.HTTPError, urllib2.URLError): # there are no static files available for this book. fresh_pdf_file = request.db.fetch_attachment( monograph._id, monograph.pdf_file['filename'], stream=True) functions.transfer_static_file( request, fresh_pdf_file, monograph._id, monograph.shortname, 'pdf', request.registry. settings['fileserver_remotebase']) else: dest_filename = monograph.shortname functions.symlink_static_file( request, monograph._id, source_filename, dest_filename, 'pdf', request.registry. settings['fileserver_remotebase']) else: fresh_pdf_file = request.db.fetch_attachment( monograph._id, monograph.pdf_file['filename'], stream=True) functions.transfer_static_file( request, fresh_pdf_file, monograph._id, monograph.shortname, 'pdf', request.registry.settings['fileserver_remotebase']) else: parts = get_book_parts(monograph._id, request) try: selected_part = parts[int(req_part[2])] except (IndexError, ValueError): raise exceptions.NotFound() part = Part.get(request.db, selected_part['part_sbid']) try: pdf_file = request.db.fetch_attachment(part._id, part.pdf_file['filename'], stream=True) except (couchdbkit.ResourceNotFound, AttributeError): raise exceptions.NotFound() response = Response(content_type='application/pdf', expires=datetime_rfc822(365)) response.app_iter = pdf_file try: response.etag = str(hash(pdf_file)) except TypeError: #cannot generate a hash for the object, return it without the ETag pass return response
def gen_cert(member): ''' Utility function: create a membership certificate PDF file using pdflatex ''' here = os.path.dirname(__file__) if 'de' in member.locale: latex_background_image = os.path.abspath( os.path.join(here, '../certificate/Urkunde_Hintergrund_blank.pdf')) # latex header and footer latex_header_tex = os.path.abspath( os.path.join(here, '../certificate/urkunde_header_de.tex')) latex_footer_tex = os.path.abspath( os.path.join(here, '../certificate/urkunde_footer_de.tex')) else: latex_background_image = os.path.abspath( os.path.join(here, '../certificate/Urkunde_Hintergrund_blank.pdf')) # latex header and footer latex_header_tex = os.path.abspath( os.path.join(here, '../certificate/urkunde_header_en.tex')) latex_footer_tex = os.path.abspath( os.path.join(here, '../certificate/urkunde_footer_en.tex')) sign_meik = os.path.abspath( os.path.join(here, '../certificate/sign_meik.png')) sign_julian = os.path.abspath( os.path.join(here, '../certificate/sign_julian.png')) # a temporary directory for the latex run tempdir = tempfile.mkdtemp() latex_file = tempfile.NamedTemporaryFile( suffix='.tex', dir=tempdir, delete=False, # directory will be deleted anyways ) # using tempfile pdf_file = tempfile.NamedTemporaryFile( dir=tempdir, delete=False, # directory will be deleted anyways ) pdf_file.name = latex_file.name.replace('.tex', '.pdf') is_founder = True if 'dungHH_' in member.email_confirm_code else False # prepare the certificate text if member.locale == 'de': # german hereby_confirmed = u'Hiermit wird bestätigt, dass' is_member = u'Mitglied der Cultural Commons Collecting Society SCE ' \ u'mit beschränkter Haftung (C3S SCE) ist' one_more_share = u' und einen weiteren Geschäftsanteil übernommen hat' several_shares = u' weitere Geschäftsanteile übernommen hat' and_block = u' und ' if is_founder: confirm_date = ( u'Der Beitritt erfolgte im Rahmen der Gründung am 25.09.2013') else: confirm_date = u'Der Beitritt wurde am {} zugelassen'.format( datetime.strftime(member.membership_date, '%d.%m.%Y')) mship_num = u'Die Mitgliedsnummer lautet {}.'.format( member.membership_number) mship_num_text = u'Mitgliedsnummer {}'.format(member.membership_number) exec_dir = u'Geschäftsführender Direktor' else: # default fallback is english hereby_confirmed = u'This is to certify that' is_member = u'is a member of the >>Cultural Commons Collecting ' \ u'Society SCE mit beschränkter Haftung (C3S SCE)<<' one_more_share = u' and has subscribed to one additional share' several_shares = u'additional shares' and_block = u' and has subscribed to' if is_founder: confirm_date = (u'Membership was acquired as a founding member ' 'on the 25th of September 2013') else: confirm_date = u'Registered on the {}'.format( datetime.strftime(member.membership_date, '%Y-%m-%d')) mship_num = u'The membership number is {}.'.format( member.membership_number) mship_num_text = u'membership number {}'.format( member.membership_number) exec_dir = 'Executive Director' # construct latex_file latex_data = ''' \\input{%s} \\def\\backgroundImage{%s} \\def\\txtBlkHerebyConfirmed{%s} \\def\\firstName{%s} \\def\\lastName{%s} \\def\\addressOne{%s} \\def\\postCode{%s} \\def\\city{%s} \\def\\numShares{%s} \\def\\numAddShares{%s} \\def\\txtBlkIsMember{%s} \\def\\txtBlkMembershipNumber{%s} \\def\\txtBlkConfirmDate{%s} \\def\\signDate{%s} \\def\\signMeik{%s} \\def\\signJulian{%s} \\def\\txtBlkCEO{%s} \\def\\txtBlkMembershipNum{%s} ''' % (latex_header_tex, latex_background_image, hereby_confirmed, TexTools.escape(member.firstname), TexTools.escape(member.lastname), TexTools.escape(member.address1), TexTools.escape(member.postcode), TexTools.escape(member.city), member.num_shares, member.num_shares - 1, is_member, TexTools.escape(mship_num), confirm_date, (datetime.strftime(date.today(), "%d.%m.%Y") if member.locale == 'de' else date.today()), sign_meik, sign_julian, exec_dir, mship_num_text) if DEBUG: # pragma: no cover print('#' * 60) print(member.is_legalentity) print(member.lastname) print('#' * 60) if member.is_legalentity: latex_data += '\n\\def\\company{%s}' % TexTools.escape(member.lastname) if member.address2 is not u'': # add address part 2 iff exists latex_data += '\n\\def\\addressTwo{%s}' % TexTools.escape( member.address2) if member.num_shares > 1: # how many shares? if member.num_shares == 2: # iff member has exactely two shares... latex_data += '\n\\def\\txtBlkAddShares{%s.}' % one_more_share if member.num_shares > 2: # iff more than two latex_data += '\n\\def\\txtBlkAddShares{%s %s %s.}' % ( and_block, member.num_shares - 1, several_shares) else: # iff member has exactely one share.. latex_data += '\n\\def\\txtBlkAddShares{.}' # finish the latex document latex_data += '\n\\input{%s}' % latex_footer_tex if DEBUG: # pragma: no cover print '*' * 70 print('*' * 30, 'latex data: ', '*' * 30) print '*' * 70 print latex_data print '*' * 70 latex_file.write(latex_data.encode('utf-8')) latex_file.seek(0) # rewind # pdflatex latex_file to pdf_file # pdflatex_output = subprocess.call( ['pdflatex', '-output-directory=%s' % tempdir, latex_file.name], stdout=open(os.devnull, 'w'), stderr=subprocess.STDOUT # hide output ) # return a pdf file response = Response(content_type='application/pdf') response.app_iter = open(pdf_file.name, "r") shutil.rmtree(tempdir, ignore_errors=True) # delete temporary directory return response
def __call__(self): request = self.request user = request.user if not user: return make_401_error("Access Denied") if "o211export" not in user.cic.ExternalAPIs: return make_401_error("Insufficient Permissions") model_state = modelstate.ModelState(request) model_state.schema = O211ExportOptionsSchema() model_state.form.method = None if not model_state.validate(): if model_state.is_error("date"): msg = "Invalid date" elif model_state.is_error("feed"): msg = "Invalid feed." else: msg = "An unknown error occurred." return make_internal_server_error(msg) feed = model_state.value("feed") date = model_state.value("date") args = [] if not feed: sql = [ "SELECT CAST(record AS nvarchar(max)) AS record FROM O211SC_RECORD_EXPORT btd" ] if request.viewdata.cic.PB_ID: args.append(request.viewdata.cic.PB_ID) sql.append( " INNER JOIN CIC_BT_PB pb ON btd.NUM=pb.NUM AND pb.PB_ID=?" ) if date: args.append(date) sql.append(""" WHERE EXISTS (SELECT * FROM GBL_BaseTable_History h INNER JOIN GBL_FieldOption fo ON h.FieldID=fo.FieldID WHERE h.NUM=btd.NUM AND h.LangID=btd.LangID AND h.MODIFIED_DATE >= ? AND fo.FieldName IN ('ORG_LEVEL_1','ORG_LEVEL_2','ORG_LEVEL_3','ORG_LEVEL_4','ORG_LEVEL_5', 'ACCESSIBILITY','AFTER_HRS_PHONE','ALT_ORG','APPLICATION','AREAS_SERVED', 'CONTACT_1','CONTACT_2','EXEC_1','EXEC_2','VOLCONTACT', 'CRISIS_PHONE','ELIGIBILITY','E_MAIL','FAX','FORMER_ORG','HOURS','INTERSECTION', 'LANGUAGES','LOCATED_IN_CM','MAIL_ADDRESS','PUBLIC_COMMENTS', 'OFFICE_PHONE','SERVICE_LEVEL','RECORD_OWNER','DESCRIPTION','SITE_ADDRESS','SUBJECTS', 'TDD_PHONE','TOLL_FREE_PHONE','WWW_ADDRESS', 'UPDATE_DATE', 'NUM', 'SUBMIT_CHANGES_TO', 'SOURCE_DB') )""") sql = " ".join(sql) elif feed == "recordids": sql = [ "SELECT CAST((SELECT id=btd.NUM, language=btd.Culture FROM O211SC_RECORD_EXPORT btd" ] if request.viewdata.cic.PB_ID: args.append(request.viewdata.cic.PB_ID) sql.append( " INNER JOIN CIC_BT_PB pb ON btd.NUM=pb.NUM AND pb.PB_ID=?" ) sql.append( "FOR XML PATH('record'), TYPE) AS nvarchar(max)) AS data ") sql = " ".join(sql) elif feed == "taxonomy": sql = "SELECT CAST(record AS nvarchar(max)) AS record from O211SC_TAXONOMY_EXPORT" elif feed == "community": sql = "SELECT CAST(record AS nvarchar(max)) AS record from O211SC_COMMUNITY_EXPORT" else: # XXX we should never get here return make_internal_server_error("Invalid feed.") log.debug("sql: %s", sql) with request.connmgr.get_connection("admin") as conn: cursor = conn.execute(sql, *args) data = [x[0] for x in cursor.fetchall()] cursor.close() data.insert(0, '<?xml version="1.0" encoding="UTF-8"?>\r\n<records>') data.append("</records>") data = "\r\n".join(data).encode("utf8") file = tempfile.TemporaryFile() zip = zipfile.ZipFile(file, "w", zipfile.ZIP_DEFLATED) zip.writestr("export.xml", data) zip.close() length = file.tell() file.seek(0) res = Response(content_type="application/zip", charset=None) res.app_iter = FileIterator(file) res.content_length = length res.headers["Content-Disposition"] = "attachment;filename=Export.zip" return res
def __call__(self): request = self.request user = request.user if not user.vol.SuperUser: self._security_failure() sql = ( "SELECT * FROM VOL_SHARE_VIEW_EN vo WHERE " + request.viewdata.WhereClauseVOL.replace("NON_PUBLIC", "XNP") .replace("DELETION_DATE", "XDEL") .replace("UPDATE_DATE", "XUPD") .replace("vod.", "vo.") .replace("vo.MemberID=1", "1=1") ) log.debug("SQL: %s", sql) log.debug("sql: %s", sql) data = [ b'<?xml version="1.0" encoding="UTF-8"?>\r\n<ROOT xmlns="urn:ciocshare-schema-vol">' ] with request.connmgr.get_connection("admin") as conn: cursor = conn.execute(sql) data.extend( "".join( [ '<RECORD VNUM="', str(x.VNUM), '" RECORD_OWNER="', str(x.RECORD_OWNER), '" HAS_ENGLISH="', str(x.HAS_ENGLISH), '" HAS_FRENCH="', str(x.HAS_FRENCH), '">', ] + list(map(str, x[7:])) + ["</RECORD>"] ).encode("utf8") for x in cursor.fetchall() ) cursor.close() data.append(b"</ROOT>") data = b"\r\n".join(data) file = tempfile.TemporaryFile() zip = zipfile.ZipFile(file, "w", zipfile.ZIP_DEFLATED) zip.writestr("export.xml", data) zip.close() length = file.tell() file.seek(0) res = Response(content_type="application/zip", charset=None) res.app_iter = FileIterator(file) res.content_length = length res.headers["Content-Disposition"] = "attachment;filename=Export.zip" return res
def generate_pdf(appstruct): """ this function receives an appstruct (a datastructure received via formsubmission) and prepares and returns a PDF using pdftk """ DEBUG = False fdf_file = tempfile.NamedTemporaryFile() pdf_file = tempfile.NamedTemporaryFile() declaration_pdf_de = "pdftk/absichtserklaerung.pdf" declaration_pdf_en = "pdftk/declaration-of-intent.pdf" # check for _LOCALE_, decide which language to use #print(appstruct['_LOCALE_']) if appstruct['_LOCALE_'] == "de": pdf_to_be_used = declaration_pdf_de elif appstruct['_LOCALE_'] == "en": pdf_to_be_used = declaration_pdf_en else: # pragma: no cover # default fallback: english pdf_to_be_used = declaration_pdf_en # here we gather all information from the supplied data to prepare pdf-filling fields = [ ('FirstName', appstruct['firstname']), ('LastName', appstruct['lastname']), ('streetNo', appstruct['address1']), ('address2', appstruct['address2']), ('postCode', appstruct['postCode']), ('city', appstruct['city']), ('email', appstruct['email']), ('country', appstruct['country']), ('region', appstruct['region']), ('composer', 'Yes' if appstruct['activity'].issuperset(['composer']) else 'Off'), ('lyricist', 'Yes' if appstruct['activity'].issuperset(['lyricist']) else 'Off'), ('musician', 'Yes' if appstruct['activity'].issuperset(['musician']) else 'Off'), ('producer', 'Yes' if appstruct['activity'].issuperset(['music producer']) else 'Off'), ('remixer', 'Yes' if appstruct['activity'].issuperset(['remixer']) else 'Off'), ('dj', 'Yes' if appstruct['activity'].issuperset(['dj']) else 'Off'), ('YesDataProtection', 'Yes' if appstruct['noticed_dataProtection'] == u"(u'yes',)" else 'Off'), ('YesDeclaration', 'Yes' if appstruct['understood_declaration'] == u"(u'yes',)" else 'Off'), ('YesNotification', 'Yes' if appstruct['consider_joining'] == u"(u'yes',)" else 'Off'), ('created3', 1 if appstruct['at_least_three_works'] == u'yes' else 2), ('inColSoc', 1 if appstruct['member_of_colsoc'] == u'yes' else 2), ] # generate fdf string fdf = forge_fdf("", fields, [], [], []) # write it to a file if DEBUG: # pragma: no cover print("== prepare: write fdf") fdf_file.write(fdf) fdf_file.seek(0) # rewind to beginning # process the PDF, fill in prepared data if DEBUG: # pragma: no cover print("== PDFTK: fill_form & flatten") print("running pdftk...") pdftk_output = subprocess.call([ 'pdftk', pdf_to_be_used, # input pdf with form fields 'fill_form', fdf_file.name, # fill in values 'output', pdf_file.name, # output file 'flatten', # make form read-only # 'verbose' # be verbose? ]) if DEBUG: # pragma: no cover print(pdf_file.name) pdf_file.seek(0) if DEBUG: # pragma: no cover print("===== pdftk output ======") print(pdftk_output) # return a pdf file from pyramid.response import Response response = Response(content_type='application/pdf') pdf_file.seek(0) # rewind to beginning response.app_iter = open(pdf_file.name, "r") return response
def member_list_date_pdf_view(request): """ The membership list *for a given date* for printout as PDF. The date is supplied in and parsed from the URL, e.g. http://0.0.0.0:6543/aml-2014-12-31.pdf The PDF is generated using pdflatex. If the date is not parseable, an error message is shown. """ effective_date_string = '' try: effective_date_string = request.matchdict['date'] effective_date = datetime.strptime(effective_date_string, '%Y-%m-%d') \ .date() except (KeyError, ValueError): request.session.flash( "Invalid date! '{}' does not compute! " "try again, please! (YYYY-MM-DD)".format( effective_date_string), 'message_to_user' ) return HTTPFound(request.route_url('error_page')) shares_count_printed = 0 # TODO: repositories are data layer and must only be used by the business # layer. Introduce business layer logic which uses the repositories and can # be accessed by this view via the request. shares_count = request.registry.share_information.get_share_count( effective_date) member_information = request.registry.member_information members_count = member_information.get_accepted_members_count( effective_date) members = member_information.get_accepted_members_sorted( effective_date) """ Then a LaTeX file is constructed... """ here = os.path.dirname(__file__) latex_header_tex = os.path.abspath( os.path.join(here, '../membership_list_pdflatex/header')) latex_footer_tex = os.path.abspath( os.path.join(here, '../membership_list_pdflatex/footer')) # a temporary directory for the latex run tempdir = tempfile.mkdtemp() # now we prepare a .tex file to be pdflatex'ed latex_file = tempfile.NamedTemporaryFile( suffix='.tex', dir=tempdir, delete=False, # directory will be deleted anyways ) # and where to store the output pdf_file = tempfile.NamedTemporaryFile( dir=tempdir, delete=False, # directory will be deleted anyways ) pdf_file.name = latex_file.name.replace('.tex', '.pdf') # construct latex data: header + variables latex_data = ''' \\input{%s} \\def\\numMembers{%s} \\def\\numShares{%s} \\def\\sumShares{%s} \\def\\today{%s} ''' % ( latex_header_tex, members_count, shares_count, shares_count * 50, effective_date.strftime('%d.%m.%Y'), ) # add to the latex document latex_data += ''' \\input{%s}''' % latex_footer_tex # print '*' * 70 # print latex_data # print '*' * 70 latex_file.write(latex_data.encode('utf-8')) # make table rows per member for member in members: address = '''\\scriptsize{}''' address += '''{}'''.format( unicode(TexTools.escape(member.address1)).encode('utf-8')) # check for contents of address2: if len(member.address2) > 0: address += '''\\linebreak {}'''.format( unicode(TexTools.escape(member.address2)).encode('utf-8')) # add more... address += ''' \\linebreak {} '''.format( unicode(TexTools.escape(member.postcode)).encode('utf-8')) address += '''{}'''.format( unicode(TexTools.escape(member.city)).encode('utf-8')) address += ''' ({})'''.format( unicode(TexTools.escape(member.country)).encode('utf-8')) member_share_count = \ request.registry.share_information.get_member_share_count( member.membership_number, effective_date) shares_count_printed += member_share_count membership_loss = u'' if member.membership_loss_date is not None: membership_loss += \ member.membership_loss_date.strftime('%d.%m.%Y') + \ '\\linebreak ' if member.membership_loss_type is not None: membership_loss += unicode(TexTools.escape( member.membership_loss_type)).encode('utf-8') latex_file.write( ''' {0} & {1} & {2} & {3} & {4} & {5} & {6} \\\\\\hline % '''.format( TexTools.escape(member.lastname).encode('utf-8'), # 0 ' \\footnotesize ' + TexTools.escape( member.firstname).encode('utf-8'), # 1 ' \\footnotesize ' + TexTools.escape( str(member.membership_number)), # 2 address, # 3 ' \\footnotesize ' + member.membership_date.strftime( '%d.%m.%Y'), # 4 ' \\footnotesize ' + membership_loss + ' ', # 5 ' \\footnotesize ' + str(member_share_count) # 6 )) latex_file.write(''' %\\end{tabular}% \\end{longtable}% \\label{LastPage} \\end{document} ''') latex_file.seek(0) # rewind # pdflatex latex_file to pdf_file fnull = open(os.devnull, 'w') # hide output pdflatex_output = subprocess.call( [ 'pdflatex', '-output-directory=%s' % tempdir, latex_file.name ], stdout=fnull, stderr=subprocess.STDOUT # hide output ) if DEBUG: # pragma: no cover print("the output of pdflatex run: %s" % pdflatex_output) # if run was a success, run X times more... if pdflatex_output == 0: for i in range(2): pdflatex_output = subprocess.call( [ 'pdflatex', '-output-directory=%s' % tempdir, latex_file.name ], stdout=fnull, stderr=subprocess.STDOUT # hide output ) if DEBUG: # pragma: no cover print("run #{} finished.".format(i+1)) # sanity check: did we print exactly as many shares as calculated? assert(shares_count == shares_count_printed) # return a pdf file response = Response(content_type='application/pdf') response.app_iter = open(pdf_file.name, "r") shutil.rmtree(tempdir, ignore_errors=True) # delete temporary directory return response
def make_dues17_invoice_no_pdf(request): """ Create invoice PDFs on-the-fly. This view checks supplied information (in URL) against info in database and returns - an error message OR - a PDF as receipt === =========================================================== URL http://app:port/dues_invoice_no/EMAIL/CAQJGCGUFW/C3S-dues17-0001.pdf === =========================================================== """ token = request.matchdict['code'] invoice_number = request.matchdict['i'] try: member = C3sMember.get_by_dues17_token(token) assert member is not None assert member.dues17_token == token except AssertionError: request.session.flash( u"This member and token did not match!", 'message_to_user' # message queue for user ) return HTTPFound(request.route_url('error_page')) try: invoice = Dues17Invoice.get_by_invoice_no(invoice_number.lstrip('0')) assert invoice is not None except AssertionError: request.session.flash( u"No invoice found!", 'message_to_user' # message queue for user ) return HTTPFound(request.route_url('error_page')) # sanity check: invoice token must match with token try: assert (invoice.token == token) except AssertionError: request.session.flash( u"Token did not match!", 'message_to_user' # message queue for user ) return HTTPFound(request.route_url('error_page')) # sanity check: invoice must not be reversal try: assert (not invoice.is_reversal) except AssertionError: request.session.flash( u"Token did not match!", 'message_to_user' # message queue for user ) return HTTPFound(request.route_url('error_page')) # return a pdf file pdf_file = make_invoice_pdf_pdflatex(member, invoice) response = Response(content_type='application/pdf') pdf_file.seek(0) # rewind to beginning response.app_iter = open(pdf_file.name, "r") return response
def __call__(self): make_zip = False request = self.request user = request.user filename = request.context.filename download_dir = os.path.join(const._app_path, "download") fnamelower = filename.lower() need_super = False user_dom = None if fnamelower.endswith("cic.zip"): need_super = True user_dom = user.cic elif fnamelower.endswith("vol.zip"): need_super = True user_dom = user.vol if need_super: if not user_dom.SuperUser: self._security_failure() else: username = filename.rsplit("_", 1) if len(username) != 2 or username[0] != user.Login.replace( " ", "_"): self._security_failure() if "/" in filename or "\\" in filename or ".." in filename or ":" in filename: self._security_failure() root, ext = os.path.splitext(filename) root2, ext2 = os.path.splitext(root) if ext.lower() == ".zip" and ext2: make_zip = True filename = root fullpath = None if fnamelower.endswith("cic.zip") or fnamelower.endswith("vol.zip"): fullpath = os.path.join( download_dir, str(request.dboptions.MemberID).join( os.path.splitext(filename)), ) else: fullpath = os.path.join(download_dir, filename) relativepath = os.path.relpath(fullpath, download_dir) if (".." in relativepath or "/" in relativepath or "\\" in relativepath or ":" in relativepath): self._security_failure() if not os.path.exists(fullpath): raise NotFound(_("File not found", request)) if make_zip: file = tempfile.TemporaryFile() zip = zipfile.ZipFile(file, "w", zipfile.ZIP_DEFLATED) zip.write(fullpath, strip_accents(filename)) zip.close() length = file.tell() file.seek(0) res = Response(content_type="application/zip", charset=None) res.app_iter = FileIterator(file) res.content_length = length res.last_modified = os.path.getmtime(fullpath) else: res = Response(content_type=get_mimetype(ext), conditional_response=True) res.app_iter = FileIterable(fullpath) res.content_length = os.path.getsize(fullpath) res.last_modified = os.path.getmtime(fullpath) res.etag = "{}-{}-{}".format( os.path.getmtime(fullpath), os.path.getsize(fullpath), hash(fullpath), ) res.headers[ "Content-Disposition"] = "attachment;filename=" + strip_accents( request.context.filename) return res