def write_metadata_to_pdf(user_metadata, pdf_path):
"""
Writes user medatadata to pdf
:param user_metadata: dictionary containing all the
custom metadata we would like
to input to pdf
:param pdf_path: path of pdf we are editing
"""
# write metadata to pdf
with open(pdf_path, 'rb') as pdf_in:
reader = PdfFileReader(pdf_in)
writer = PdfFileWriter()
prev_metadata = reader.getDocumentInfo()
merger = PdfFileMerger()
merger.append(pdf_name)
merger.addMetadata(user_metadata)
# writer.appendPagesFromReader(reader)
# writer.addMetadata(prev_metadata)
#
# writer.addMetadata(metadata)
new_pdf = pdf_name.strip('.pdf') + '_edit.pdf'
with open(new_pdf, 'ab') as pdf_out:
pdf_merger.write(pdf_out)
# Delete old file and rename new file so that it is consistent with
# original pdf
os.remove(pdf_path)
os.rename(pdf_new, pdf_path)
def _mergepdf(self):
""" Performs the conversion from docx to pdf
"""
new_path = os.path.join(self.dirname, self.filename+'.pdf')
try:
merger = PdfFileMerger()
for fname in self.files:
print fname
fpath = os.path.abspath(fname)
ffile = PdfFileReader(open(fpath, 'rb'))
merger.append(ffile)
metadata = {
u'/Title': self.title,
u'/Author': self.author,
u'/Subject': self.subject,
u'/Keywords': self.keywords
}
merger.addMetadata(metadata)
merger.write(self.abspath)
except Exception as ex:
print ex
else:
str_new_path = new_path.decode('utf-8', 'ignore')
print u'New file %s has been written.' % str_new_path
def merge(pdfs, final, name=None):
pdf = PdfFileMerger()
pdf.addMetadata({'/Title': name}) if name != None else None
for p in pdfs:
if p != '':
pdf.append(p)
pdf.write(final)
pdf.close()
def generate_annual_calendar(tide_obj, sun_obj, moon_obj, file_name):
'''Take tide, sun, and moon objects and generate a PDF file named
`file_name`, which is a complete annual Sun * Moon * Tide calendar. File is
saved to current working directory. Verbose output since this is a slow
function.
Args:
tide_obj: tides.Tides object
sun_obj: astro.Astro object for 'Sun'
moon_obj: astro.Astro object for 'Moon'
file_name: string. ".pdf" will NOT be appended to the file_name so the .pdf
extension ought to be included in file_name.
'''
with PdfPages('temp.pdf') as pdf_out:
coverfig = cover(tide_obj)
coverfig.savefig(pdf_out, format='pdf')
print('Calendar cover saved.')
yearviewfig = yearview(tide_obj, sun_obj, moon_obj)
print('{} Overview created, now saving...'.format(tide_obj.year))
yearviewfig.savefig(pdf_out, format='pdf')
print('{} Overview saved.'.format(tide_obj.year))
for month in months_in_year(tide_obj.year):
monthfig = month_page(month, tide_obj, sun_obj, moon_obj)
print('{} figure created, now saving...'.format(month))
monthfig.savefig(pdf_out, format='pdf')
print('Saved {}'.format(month))
d = {}
d['/Title'] = 'Sun * Moon * Tide {} Calendar'.format(tide_obj.year)
d['/Author'] = 'Sara Hendrix, CruzViz'
d['/Subject'] = '{}, {}'.format(tide_obj.station_name, tide_obj.state)
d['/CreationDate'] = pd.Timestamp.now().to_pydatetime().strftime('%c')
print('Merging front and back matter into calendar... \
(ignore PdfReadWarnings)')
about_pdf = cal_pages.about('{}, {}'.format(tide_obj.station_name,
tide_obj.state))
tech_pdf = cal_pages.tech(tide_obj)
merger = PdfFileMerger(strict = False)
with open('temp.pdf','rb') as cal:
merger.append(PdfFileReader(cal))
with open(about_pdf,'rb') as about:
merger.merge(1, PdfFileReader(about))
with open(tech_pdf,'rb') as tech:
merger.append(PdfFileReader(tech))
merger.addMetadata(d)
merger.write(file_name)
print('Cleaning up temporary files...')
os.remove('temp.pdf')
os.remove(about_pdf)
os.remove(tech_pdf)
def generate_annual_calendar(tide_obj, sun_obj, moon_obj, file_name):
'''Take tide, sun, and moon objects and generate a PDF file named
`file_name`, which is a complete annual Sun * Moon * Tide calendar. File is
saved to current working directory. Verbose output since this is a slow
function.
Args:
tide_obj: tides.Tides object
sun_obj: astro.Astro object for 'Sun'
moon_obj: astro.Astro object for 'Moon'
file_name: string. ".pdf" will NOT be appended to the file_name so the .pdf
extension ought to be included in file_name.
'''
with PdfPages('temp.pdf') as pdf_out:
coverfig = cover(tide_obj)
coverfig.savefig(pdf_out, format='pdf')
print('Calendar cover saved.')
yearviewfig = yearview(tide_obj, sun_obj, moon_obj)
print('{} Overview created, now saving...'.format(tide_obj.year))
yearviewfig.savefig(pdf_out, format='pdf')
print('{} Overview saved.'.format(tide_obj.year))
for month in months_in_year(tide_obj.year):
monthfig = month_page(month, tide_obj, sun_obj, moon_obj)
print('{} figure created, now saving...'.format(month))
monthfig.savefig(pdf_out, format='pdf')
print('Saved {}'.format(month))
d = {}
d['/Title'] = 'Sun * Moon * Tide {} Calendar'.format(tide_obj.year)
d['/Author'] = 'Sara Hendrix, CruzViz'
d['/Subject'] = '{}, {}'.format(tide_obj.station_name, tide_obj.state)
d['/CreationDate'] = pd.Timestamp.now().to_pydatetime().strftime('%c')
print('Merging front and back matter into calendar... \
(ignore PdfReadWarnings)')
about_pdf = cal_pages.about('{}, {}'.format(tide_obj.station_name,
tide_obj.state))
tech_pdf = cal_pages.tech(tide_obj)
merger = PdfFileMerger(strict=False)
with open('temp.pdf', 'rb') as cal:
merger.append(PdfFileReader(cal))
with open(about_pdf, 'rb') as about:
merger.merge(1, PdfFileReader(about))
with open(tech_pdf, 'rb') as tech:
merger.append(PdfFileReader(tech))
merger.addMetadata(d)
merger.write(file_name)
print('Cleaning up temporary files...')
os.remove('temp.pdf')
os.remove(about_pdf)
os.remove(tech_pdf)
def mergerPDF(dir):
merger = PdfFileMerger()
files = [x for x in os.listdir(dir) if x.endswith('.pdf')]
print('File merged: ', files)
for fname in sorted(files):
merger.append(PdfFileReader(open(f'{dir}/{fname}', 'rb')))
metadata = {'/edited': 'Wonvin Kim'}
merger.addMetadata(metadata)
filePath = f"{dir}/output.pdf"
merger.write(filePath)
merger.close()
return filePath
def clean_PDF(submission):
"""
Strips out any personal information in the PDF.
"""
src = submission.file_upload.file.name
pdf1 = PdfFileReader(src)
merger = PdfFileMerger(strict=False, )
merger.append(pdf1, import_bookmarks=False)
merger.addMetadata({
'/Title': '',
'/Author': '',
'/Creator': '',
'/Producer': ''
})
fd, temp_file = tempfile.mkstemp(suffix='.pdf')
merger.write(temp_file)
merger.close()
os.close(fd)
shutil.move(temp_file, src) # replace the original PDF on the server
def add_bookmarks(pdf_in_filename, bookmarks_tree, pdf_out_filename=None):
"""Add bookmarks to existing PDF files
Home:
https://github.com/RussellLuo/pdfbookmarker
Some useful references:
[1] http://pybrary.net/pyPdf/
[2] http://stackoverflow.com/questions/18855907/adding-bookmarks-using-pypdf2
[3] http://stackoverflow.com/questions/3009935/looking-for-a-good-python-tree-data-structure
"""
pdf_in = PdfFileReader(pdf_in_filename)
# merge `pdf_in` into `pdf_out`, using PyPDF2.PdfFileMerger()
pdf_out = PdfFileMerger()
pdf_out.append(pdf_in, import_bookmarks=False)
# copy/preserve existing document info
doc_info = pdf_in.getDocumentInfo()
if doc_info:
pdf_out.addMetadata(doc_info)
def crawl_tree(tree, parent):
for title, page_num, subtree in tree:
current = pdf_out.addBookmark(title, page_num,
parent) # add parent bookmark
if subtree:
crawl_tree(subtree, current)
# add bookmarks into `pdf_out` by crawling `bookmarks_tree`
crawl_tree(bookmarks_tree, None)
# get `pdf_out_filename` if it's not specified
if not pdf_out_filename:
name_parts = os.path.splitext(pdf_in_filename)
pdf_out_filename = name_parts[0] + '-new' + name_parts[1]
# write all data to the given file
pdf_out.write(pdf_out_filename)
pdf_out.close()
return pdf_out_filename
def _set_pdf_signature(self,
input: str,
output: str = None,
signature: Signature = None) -> str:
"""Sets signature metadata using the given input file to new output file
Private method that should not be used directly, use add instead.
- Argument input: absolute path to input PDF that will be untouched
- Argument output: optional absolute path to the output file, creates new temp file if not set that should be cleaned
- Argument signature: optional signature to set, if empty, existing is removed
Returns absolute path to the output file.
"""
if output == None:
random_file_name = ''.join(
random.choices(string.ascii_uppercase + string.digits, k=8))
random_temp_path = path.join(tempfile.gettempdir(),
random_file_name)
output = random_temp_path
file_in = open(input, 'rb')
pdf_reader = PdfFileReader(file_in)
metadata = pdf_reader.getDocumentInfo().copy()
if signature == None:
if '/Signature' in metadata:
del metadata['/Signature']
else:
metadata['/Signature'] = signature.serialize()
pdf_merger = PdfFileMerger()
pdf_merger.append(file_in)
pdf_merger.addMetadata(metadata)
file_out = open(output, 'wb')
pdf_merger.write(file_out)
file_in.close()
file_out.close()
return output
def setpdfmetadataOLD(file,title, author, publisher, series, year):
newfname='new_'+file
file_in = open(file, 'rb')
pdf_reader = PdfFileReader(file_in)
metadata = pdf_reader.getDocumentInfo()
pprint.pprint(metadata)
pdf_merger = PdfFileMerger()
pdf_merger.append(file_in)
pdf_merger.addMetadata({
u'/Author': author,
u'/Title': title,
u'/Publisher':str(publisher),
u'/Series':str(series),
u'/Year':str(year)
})
file_out = open(newfname, 'wb')
pdf_merger.write(file_out)
file_in.close()
file_out.close()
def merge_all_cs_pdf_files(cs_pdf_files_paths,
merged_pdf_file_name="book.pdf"):
"""
Merge all CS pdf files in order to create the CS pdf book
:param cs_pdf_files_paths: List of PDF file to merge
:param merged_pdf_file_name: Name of the output file representing the result of the merge
"""
if cs_pdf_files_paths is None:
raise Exception("List of PDF files to merge cannot be NONE !")
merger = PdfFileMerger()
for cs_pdf_files_path in cs_pdf_files_paths:
merger.append(cs_pdf_files_path, import_bookmarks=False)
metadatas = {
"/Title":
"OWASP Cheat Sheet Series book",
"/Author":
"OWASP Cheat Sheet Series project",
"/Producer":
"Created on " + '{0:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now())
}
merger.addMetadata(metadatas)
merger.write(merged_pdf_file_name)
def add_metadata(file_name, metadata, directory_name):
title = my_slugify(metadata[TITLE_META_NAME]);
authors = my_slugify(metadata[AUTHOR_META_NAME]);
isbn = my_slugify(metadata[ISBN_META_NAME]);
new_file_name = directory_name + "processed/" + title
processed_file_name = directory_name + DEFAULT_OLD_FOLDER + title + FILE_DEFAULT_EXTENSION
print "-> Adding metadata to file... %s", new_file_name
merger = PdfFileMerger()
print "ADD METADATA 0"
print "::: ", file_name
merger.merge(position=0, fileobj=PdfFileReader(file_name, "rb"))
print "ADD METADATA 1"
merger.addMetadata(metadata)
print "ADD METADATA 2"
with open(new_file_name + DASH_SEPARATOR + authors + DASH_SEPARATOR + isbn
+ FILE_DEFAULT_EXTENSION, 'wb') as pdf_file_reference_updated:
merger.write(pdf_file_reference_updated)
print "ADD METADATA 3"
os.rename(file_name, processed_file_name);
print "File processed OK"
def merge_chapters(self):
logger.info('mering chapters ...')
dt = datetime.datetime.now().strftime("%Y%m%d%H%M%S%z")
merger = PdfFileMerger()
merger.addMetadata({
'/Author': 'Remzi Arpaci-Dusseau, Andrea Arpaci-Dusseau',
'/Creator': 'Eugene Kalinin',
'/Producer':
'https://github.com/ekalinin/operating-systems-three-easy-pieces',
'/Title': 'Operating Systems: Three Easy Pieces',
'/CreationDate': dt,
'/ModDate': dt,
})
for idx, pdf in enumerate(self.downloaded_chapters):
bookmark = self.get_title_from_pdf(idx, pdf)
logger.info(' ... idx=%d, pdf=%s, bookmark=%s', idx, pdf, bookmark)
merger.append(open(pdf, 'rb'), bookmark=bookmark)
with open(self.output_file, "wb") as book:
merger.write(book)
merger.close()
logger.info('mering chapters - done. (%s)', self.output_file)
if p.getContents():
output.addPage(p)
# Write contents for pages that are not empty
with open('myPdf_wo_blank.pdf', 'wb') as f:
output.write(f)
# Add metadata to your file
from PyPDF2 import PdfFileMerger, PdfFileReader
mergerObj = PdfFileMerger()
fp = open('myPdf.pdf', 'wb')
# Add edited neta attribute to the PDF file
metadata = {u'/edited':u'ByPdfFileMerger',}
mergerObj.addMetadata(metadata)
mergerObj.write(fp)
fp.close()
# Get the document information
pdf = open("myPdf.pdf", 'rb')
readerObj = PdfFileReader(pdf)
print("Document Info:", readerObj.getDocumentInfo())
pdf.close()
# Encrypt files
from PyPDF2 import PdfFileWriter, PdfFileReader
fp = open('Exercise.pdf', 'rb')
readerObj = PdfFileReader(fp)
# Create a PDFWriter object and add contents to the file
def add_pdf_did(path_batch, path_xml, path_pdf):
"""Adds metadata from Metadatadump XML to PDF Document Information Dict."""
with open(path_xml, 'rb') as mddump_xml:
dump = etree.parse(mddump_xml)
object_id = os.path.basename(path_pdf).replace('_pdf.pdf',
'').replace('_', '')
material = dump.xpath('/shipment/@material')[0]
try:
if material == 'tijdschriften' or material == 'kranten':
referredRecordID = dump.xpath(f'//issue[@ID="{object_id}"]\
/@referredRecordID')[0]
sourceProvider = dump.xpath(f'//issue[@ID="{object_id}"]\
/parent::entity/@sourceProvider'
)[0]
shelfmark = dump.xpath(f'//issue[@ID="{object_id}"]\
/parent::entity/@shelfmark')[0]
title = dump.xpath(f'//record[@ID="{referredRecordID}"]\
/@title')[0]
# issue_nr = dump.xpath(f'//issue[@ID="{object_id}"]/@issueNo')[0]
volumeNo = dump.xpath(f'//issue[@ID="{object_id}"]\
/@volumeNo')[0]
if material == 'tijdschriften':
sequenceNo = dump.xpath(f'//issue[@ID="{object_id}"]\
/@sequenceNo')[0]
volumeYear = dump.xpath(f'//issue[@ID="{object_id}"]\
/@volumeYear')[0]
if dump.xpath(f'//issue[@ID="{object_id}"]/@part'):
part = dump.xpath(f'//issue[@ID="{object_id}"]/@part')
else:
part = ''
publicationYear = dump.xpath(f'//issue[@ID="{object_id}"]\
/@publicationYear')[0]
if dump.xpath(f'//issue[@ID="{object_id}"]/@publicationMonth'):
publicationMonth = dump.xpath(f'//issue[@ID="{object_id}"]\
/@publicationMonth')[0]
else:
publicationMonth = ''
if dump.xpath(f'//issue[@ID="{object_id}"]/@publicationDay'):
publicationDay = dump.xpath(f'//issue[@ID="{object_id}"]\
/@publicationDay')[0]
else:
publicationDay = ''
publicationType = dump.xpath(f'//issue[@ID="{object_id}"]\
/@publicationType')[0]
if material == 'kranten':
publicationDate = dump.xpath(f'//issue[@ID="{object_id}"]\
/@publicationDate')[0]
edition = dump.xpath(f'//issue[@ID="{object_id}"]/@edition')[0]
issue_nr = dump.xpath(f'//issue[@ID="{object_id}"]\
/@issueNo')[0]
if material == 'boeken':
referredRecordID = dump.xpath(f'//entity[@ID="{object_id}"]\
/@referredRecordID')[0]
sourceProvider = dump.xpath(f'//entity[@ID="{object_id}"]\
/@sourceProvider')[0]
shelfmark = dump.xpath(f'//entity[@ID="{object_id}"]\
/@shelfmark')[0]
title = dump.xpath(f'//record[@ID="{referredRecordID}"]\
/@title')[0]
author = dump.xpath(f'//record[@ID="{referredRecordID}"]\
/@author')[0]
issued = dump.xpath(f'//record[@ID="{referredRecordID}"]\
/@issued')[0]
sequenceNo = dump.xpath(f'//entity[@ID="{object_id}"]\
/@sequenceNo')[0]
if dump.xpath(f'//entity[@ID="{object_id}]"/@part'):
part = dump.xpath(f'//entity[@ID="{object_id}]"/@part')[0]
else:
part = ''
except IndexError as e:
print(e)
# Material specific metadata.
if material == 'tijdschriften':
pdf_title = f'{title}, jrg. {volumeNo}, {volumeYear}, {part}, {publicationDay}, {publicationMonth}, {publicationYear}, [{publicationType}, volgnr. {sequenceNo}], {sourceProvider}, {shelfmark}'
keywords = 'Gedigitaliseerd door de Koninklijke Bibliotheek; Nederlandse geschiedenis; tijdschriften, historische tijdschriften, oude tijdschriften, archief tijdschriften, tijdschrift online, cultuur, letterkunde, religie, wetenschap, politiek, sport, economie'
elif material == 'kranten':
pdf_title = f'{title}, jrg. {volumeNo}, {issueNo}, {publicationDate}, editie {edition}, {sourceProvider}, {shelfmark}'
keywords = 'Gedigitaliseerd door de Koninklijke Bibliotheek; Nederlandse geschiedenis; kranten, historische kranten, oude kranten, archief kranten, krantenarchieven, krant online, familieberichten, stamboom familie, dagblad, overlijdensberichten, nieuwsberichten, Nederlandstalige kranten, namen familie, familie Nederland, oorlogskranten, kranten van toen, Surinaamse kranten, Indische kranten, Antilliaanse kranten, databank kranten'
elif material == 'boeken':
pdf_title = f'{title}, {part}, {sequenceNo}, {author}, {issued}, {sourceProvider}, {shelfmark}'
keywords = 'Gedigitaliseerd door de Koninklijke Bibliotheek; Nederlandse geschiedenis; boeken, oude drukken, Nederlands taalgebied, geschiedenis, politiek, theologie, letterkundige werken, naamlijsten, boeken online, historische teksten, oude boeken, bijzondere collecties, cultuur'
# Add metadata as Document Information to PDF.
now = datetime.now()
pdf_datestamp = now.strftime("D:%Y%m%d%H%M%S+01'00'")
merger = PdfFileMerger()
merger.append(path_pdf)
merger.addMetadata({
'/Title':
pdf_title,
'/Keywords':
keywords,
'/CreationDate':
pdf_datestamp,
'/ModDate':
pdf_datestamp,
'/Copyright-information':
'Gedigitaliseerd door de Koninklijke Bibliotheek, de Nationale Bibliotheek van Nederland / Digitised by the Koninklijke Bibliotheek, the National Library of the Netherlands'
})
if material == 'boeken':
merger.addNetadata({'/Author': author})
# Save final PDF in output_dir.
merger.write(os.path.join(output_dir, os.path.basename(path_pdf)))
merger.close()
print("found " + str(pdf))
for pdf in filelist:
try:
#opening the pdf and reading the metadata
file_in = open(pdf, 'rb+')
pdf_reader = PdfFileReader(file_in)
metadata = pdf_reader.getDocumentInfo()
#creating a new file, appending the pdf and adding custom metadata
pdf_merger = PdfFileMerger()
pdf_merger.append(file_in)
pdf_merger.addMetadata({
'/Author': "",
'/Title': "",
'/Subject': "",
'/Producer': "",
'/Creator': "",
'/Keywords': "",
})
#writing the the new pdf document to a new file
file_out = open('new.pdf', 'wb+')
pdf_merger.write(file_out)
file_in.close()
file_out.close()
#replacing the original file with the new one under the same name
name = str(pdf)
os.replace('new.pdf', name)
print("done with " + str(pdf))
except:
def student_downloads(request, course=None, learner=None, entry_point=None):
"""
Generates all the information needed for a student download of the keyterm
booklets
"""
# Create place to store and stage files
base_dir = settings.MEDIA_ROOT
base_file_dir = 'uploads/{0}/tmp/'.format(entry_point.id)
deepest_dir = base_dir + base_file_dir
try:
os.makedirs(deepest_dir)
except OSError:
if not os.path.isdir(deepest_dir):
logger.error(
'Cannot create directory for PDF download: {0}'.format(
deepest_dir))
raise
# Explicitly specify the variables we will use later
total_votes = student_votes_given = student_votes_received = 0
submitted_keyterms = draft_keyterms = maximum_keytermtasks = 0
total_votes = Thumbs.objects.filter(awarded=True).count()
n_persons = Person.objects.filter(course=course, role='Learn').count()
student_votes_given = learner.thumbs_set.all().count()
entry_points = course.entrypoint_set.all().order_by('order')
all_keyterms = []
for term in entry_points:
if term != entry_point:
all_keyterms.append(KeyTermSetting.objects.get(entry_point=term))
maximum_keytermtasks = len(all_keyterms)
# Settings for text placement
placement_y = 225
placement_offset_x = 16
fontsize = 50
image_W, image_H = (1900, 1600)
offset_y = 0
base_canvas_wh = (image_W, image_H)
color = "#FFF"
bgcolor = "#000"
# Set up the text and placement for the student's name in the template
student_name = learner.official_name or learner.display_name
fontfullpath = base_dir + 'keyterm/fonts/Lato-Regular.ttf'
img = Image.new("RGB", base_canvas_wh, bgcolor)
draw = ImageDraw.Draw(img)
cover_page = base_dir + 'keyterm-template-cover.jpg'
source = Image.open(cover_page)
img.paste(source, (0, 0))
font = ImageFont.truetype(fontfullpath, fontsize)
# The name is centered in the image
x, y = ((image_W - font.getsize(student_name)[0]) / 2, placement_y)
draw.text((x + placement_offset_x, y), student_name, color, font=font)
cover_page = deepest_dir + learner.display_name + '.pdf'
if not (os.path.isfile(cover_page)):
img.save(cover_page, 'PDF')
merger = PdfFileMerger(strict=False, )
merger.append(cover_page, import_bookmarks=False)
voting = defaultdict(dict)
for keyterm in all_keyterms:
this_task = learner.keytermtask_set.filter(keyterm=keyterm)
voting[keyterm.keyterm]['url'] = keyterm.entry_point.full_URL
all_tasks = keyterm.keytermtask_set.all()
all_votes = [kt.thumbs_set.all().count() for kt in all_tasks]
# Don't sort, unless you are debugging and want to preview the ties.
#all_votes.sort()
#print(all_votes)
max_votes = max(all_votes)
max_votes_idx = all_votes.index(max_votes)
voting[keyterm.keyterm]['top_task'] = all_tasks[max_votes_idx]
if not (this_task):
voting[keyterm.keyterm]['received_votes'] = ('You did not attempt '
'this key term.')
continue
else:
this_task = this_task[0]
if this_task.is_finalized:
submitted_keyterms += 1
voting[keyterm.keyterm]['received_votes'] = \
this_task.thumbs_set.all().count()
student_votes_received += this_task.thumbs_set.all().count()
outfile = this_task.image_modified.file.name.split('.' + \
OUTPUT_EXTENSION)[0]
outfile += '.pdf'
if not (os.path.isfile(outfile)):
img = Image.open(this_task.image_modified.file)
img.save(outfile, 'PDF')
# Append the PDF
merger.append(outfile, import_bookmarks=False)
elif this_task.is_in_draft:
# The keyterm was started, but not finalized
voting[keyterm.keyterm]['received_votes'] = ('You left this key '
'term as draft.')
draft_keyterms += 1
# All done
merger.addMetadata({
'/Title': 'Key terms for ' + course.name,
'/Author': learner.official_name or learner.display_name,
'/Creator': 'Keyterms Booklet',
'/Producer': 'Keyterms Booklet'
})
# First delete old files
for dirpath, dnames, fnames in os.walk(deepest_dir):
for f in fnames:
if f.startswith(learner.display_name + '--'):
os.remove(dirpath + f)
# Then save their latest version of the booklet
fd, temp_file_dst = tempfile.mkstemp(prefix=learner.display_name + '--',
suffix='.pdf',
dir=deepest_dir)
server_URI = '/{0}{1}'.format(settings.MEDIA_URL,
temp_file_dst.split(settings.MEDIA_ROOT)[1])
merger.write(temp_file_dst)
merger.close()
# Then close the temp file
try:
os.close(fd)
except OSError:
pass
merger = PdfFileMerger(strict=False, )
cover_page = base_dir + 'keyterm-template-most-votes.pdf'
# Only done once
if not (os.path.isfile(cover_page)):
img = Image.new("RGB", base_canvas_wh, bgcolor)
draw = ImageDraw.Draw(img)
source = Image.open(base_dir + 'keyterm-template-most-votes.jpg')
img.paste(source, (0, 0))
img.save(cover_page, 'PDF')
# Continue on
merger.append(cover_page, import_bookmarks=False)
for keyterm in all_keyterms:
this_task = voting[keyterm.keyterm]['top_task']
if this_task.is_finalized:
received_votes = this_task.thumbs_set.all().count()
outfile = this_task.image_modified.file.name.split('.' + \
OUTPUT_EXTENSION)[0]
outfile += '.pdf'
if not (os.path.isfile(outfile)):
img = Image.open(this_task.image_modified.file)
img.save(outfile, 'PDF')
# Append the PDF
merger.append(outfile, import_bookmarks=False)
# All done, finish up.
timestamp = timezone.now().strftime('%d-%m-%Y-%H-%M-%S')
fd, temp_file_dst = tempfile.mkstemp(prefix='Most-voted' + '-' +
timestamp + '-',
suffix='.pdf',
dir=deepest_dir)
most_voted_link = '/{0}{1}'.format(
settings.MEDIA_URL,
temp_file_dst.split(settings.MEDIA_ROOT)[1])
merger.write(temp_file_dst)
merger.close()
# Pick the last key term from the prior fot loop to figure out what the
# overall voting deadline is
show_most_voted_booklet = False
if datetime.datetime.now(
datetime.timezone.utc) > keyterm.deadline_for_voting:
show_most_voted_booklet = True
ctx = {
'learner_download_link': server_URI,
'total_votes': total_votes,
'n_persons': n_persons,
'student_votes_given': student_votes_given,
'student_votes_received': student_votes_received,
'submitted_keyterms': submitted_keyterms,
'draft_keyterms': draft_keyterms,
'maximum_keytermtasks': maximum_keytermtasks,
'maximum_votes_possible': submitted_keyterms * 3,
'voting': dict(voting), # defaultdict->dict, to avoid template issues
'most_voted_link': most_voted_link,
'show_most_voted_booklet': show_most_voted_booklet,
}
return render(request, 'keyterm/learner_download.html', ctx)
def download_term(request, learner_hash=''):
"""
POST request received from user to download a booklet of all the keyterms
for a particular page.
Creates a unique link, delay to compile the document and download it.
"""
'download_task'
learner = Person.objects.filter(hash_code=learner_hash)
if learner.count() != 1:
logger.error('Learner error hash={}; POST=[{}]'.format(
learner_hash, request.POST))
return JsonResponse({
'message': ('Error: could not identify who you '
'are. Please reload the page.')
})
else:
learner = learner[0]
lookup_id = request.POST.get('download_task', 'keyterm-0')
try:
lookup_id = int(lookup_id.split('keyterm-')[1])
except ValueError:
lookup_id = 0
keyterm = KeyTermSetting.objects.filter(id=lookup_id)
if keyterm.count() != 1:
logger.error('Keyterm not found={}; POST=[{}]'.format(
lookup_id, request.POST))
return JsonResponse({'message': ('Error: Key term not found.')})
else:
keyterm = keyterm[0]
merger = PdfFileMerger(strict=False, )
all_terms = keyterm.keytermtask_set.filter(
is_finalized=True).order_by('id')
append_images = []
for term in all_terms:
outfile = term.image_modified.file.name.split('.' +
OUTPUT_EXTENSION)[0]
outfile += '.pdf'
if not (os.path.isfile(outfile)):
img = Image.open(term.image_modified.file)
img.save(outfile, 'PDF')
# Append the PDF
merger.append(outfile, import_bookmarks=False)
# All done
merger.addMetadata({
'/Title': 'Key term: ' + keyterm.keyterm,
'/Author': 'All students in the course',
'/Creator': 'Keyterms Booklet',
'/Producer': 'Keyterms Booklet'
})
base_file_dir = 'uploads/{0}/tmp/'.format(keyterm.entry_point.id)
deepest_dir = settings.MEDIA_ROOT + base_file_dir
fd, temp_file_dst = tempfile.mkstemp(prefix=keyterm.keyterm + '--',
suffix='.pdf',
dir=deepest_dir)
server_URI = '/{0}{1}'.format(settings.MEDIA_URL,
temp_file_dst.split(settings.MEDIA_ROOT)[1])
merger.write(temp_file_dst)
merger.close()
try:
os.close(fd)
except OSError:
pass
message = ('Your download is ready now. <a href="{}" target="_blank">'
'Click here to open it.</a>').format(server_URI)
response = {'message': message}
return JsonResponse(response)
while len(file_out) == 0:
file_out = input("Fichier de sortie : ")
if len(file_out) > 2 and file_out[0] == '"' and file_out[-1] == '"':
file_out = file_out[1:-1]
overwrite = False
rename_file_out = file_out
if os.path.isfile(file_out):
answer = ""
while answer.lower() not in ("y", "yes", "o", "oui", "n", "no", "non",
"q", "quit"):
answer = input(f"Le fichier existe déjà. Ecraser [O/N] ? ")
if answer.lower() in ("n", "no", "non", "q", "quit"):
sys.exit()
overwrite = True
file_out = uuid.uuid4().hex[:8] + '.pdf'
pdf_merger = PdfFileMerger()
pdf_merger.append(pdf_file_in)
pdf_merger.addMetadata({'/Producer': ''})
pdf_file_out = open(file_out, 'wb')
pdf_merger.write(pdf_file_out)
pdf_file_out.close()
pdf_file_in.close()
if overwrite:
move(file_out, rename_file_out)
if console_mode == False:
print("Terminé !")
os.system("pause")
hoje = pd.datetime.today()
hoje_str = pd.datetime.strftime(hoje, "%Y%m%d%H%M%S")
# Metadata que será adicionado ao arquivo pdf - formato da data é tal que permite ser lido
# com clareza em documentos pdf.
metadata = {
"/Title": "Weekly Debentures Evolution",
"/Author": "Jarvis",
"/Subject": "Sumary of my boss' assets",
"/CreationDate": f"D:{hoje_str}",
"/Producer": "Why so Curious?",
"/Creator": "Python",
}
merger.addMetadata(metadata)
# Configurando o payload do email
person = {"name": "Thiago", "email": "*****@*****.**"}
msg = EmailMessage()
msg["From"] = email_address
msg["To"] = person["email"]
msg["Subject"] = f"Weekly Debentures Report"
content = f"""Hi Mr. {person['name']}.\n\nPlease find attatched your weekly debentures report.\n\nBest Regards, Jarvis."""
msg.set_content(content)
# Configurando o anexo: a ideia aqui foi escrever num buffer o pdf consolidado para evitar gravação em disco
with BytesIO() as file_data:
merger.write(file_data)
