'landscape-A4': PdfFileReader(file("{0}/blank.pdf".format(TEMPLATE_DIR), "rb")),

'landscape-letter': PdfFileReader(file("{0}/blank-letter.pdf".format(TEMPLATE_DIR), "rb")),

'portrait-A4': PdfFileReader(file("{0}/blank-portrait-A4.pdf".format(TEMPLATE_DIR), "rb")),

"""

Get pertinent date for display on cert

"""

locale = locale or settings.DEFAULT_LOCALE

timezone = timezone or settings.TIMEZONE

if force_date:

date = datetime.strptime(force_date, '%Y-%m-%d')

else:

from_zone = get_timezone(settings.TIMEZONE)

to_zone = get_timezone(timezone)

date = get_today()

date = date.replace(tzinfo=from_zone)

date = date.astimezone(to_zone)

date = date.date()

date = format_date(date, 'long', locale=locale)

date = unicode(date)

"""Manages the pdf, signatures, and S3 bucket for course certificates."""

def __init__(

self,

course_id,

template_pdf=None,

aws_id=None,

aws_key=None,

dir_prefix=None,

long_org=None,

long_course=None,

issued_date=None,

designation=None,

):

"""Load a pdf template and initialize

Multiple certificates can be generated and uploaded for a single course.

course_id - Full course_id (ex: course-v1:MITx+6.00x+1T2015)

course_name - Human readable course title (ex: Introduction to Curling)

dir_prefix - Temporary directory for file generation. Ceritificates

and signatures are copied here temporarily before they

are uploaded to S3

template_pdf - (optional) Template (filename.pdf) to use for the

certificate generation.

aws_id - necessary for S3 uploads

aws_key - necessary for S3 uploads

designation - user designation used for distiction on

certificate and to locate subtemplates in CERT_DATA

course_id is used to look up extra data from settings.CERT_DATA,

including (but not necessarily limited to):

* LONG_ORG - long name for the organization

* ISSUED_DATE - month, year that corresponds to the

run of the course

* TEMPLATEFILE - the template pdf filename to use, equivalent to

template_pdf parameter

"""

if dir_prefix is None:

self._ensure_dir(TMP_GEN_DIR)

dir_prefix = tempfile.mkdtemp(prefix=TMP_GEN_DIR)

self._ensure_dir(dir_prefix)

self.dir_prefix = dir_prefix

self.aws_id = str(aws_id)

self.aws_key = str(aws_key)

cert_data = settings.CERT_DATA.get(course_id, {})

# instantiate a new local dictionary instance

# so that any changes are not shared globally

cert_data = dict(cert_data)

self.course_id = course_id

self.designation = designation

subtemplates = cert_data.get('subtemplates', {})

if designation and designation in subtemplates:

subtemplate_id = subtemplates[designation]

subtemplate = settings.CERT_DATA.get(subtemplate_id, {})

cert_data.update(subtemplate)

self.cert_data = cert_data

def interstitial_factory():

""" Generate default values for interstitial_texts defaultdict """

return itertools.repeat(cert_data.get('interstitial', {}).get('Pass', u'').encode('utf-8')).next

# lookup long names from the course_id

try:

self.long_org = long_org or cert_data.get('LONG_ORG', '').encode('utf-8') or settings.DEFAULT_ORG

self.long_course = cert_data.get('LONG_COURSE', '').encode('utf-8') or long_course or ''

self.issued_date = issued_date or cert_data.get('ISSUED_DATE', '').encode('utf-8')

self.interstitial_texts = collections.defaultdict(interstitial_factory())

interstitial_dict = {

key.encode('utf8'): value.encode('utf8')

for key, value in cert_data.get('interstitial', {}).items()

}

self.interstitial_texts.update(interstitial_dict)

self.timezone = cert_data.get('timezone', settings.TIMEZONE)

self.locale = cert_data.get('locale', settings.DEFAULT_LOCALE).encode('utf-8')

self.course_translations = cert_data.get('translations', {})

except KeyError:

log.critical("Unable to lookup long names for course {0}".format(course_id))

raise

# if COURSE or ORG is set in the configuration attempt to parse.

# This supports both new and old style course keys.

course_key = CourseKey.from_string(course_id)

self.course = cert_data.get('COURSE', course_key.course)

self.org = cert_data.get('ORG', course_key.org)

# get the template version based on the course settings in the

# certificates repo, with sensible defaults so that we can generate

# pdfs differently for the different templates

self.template_version = cert_data.get('VERSION', '4_programmatic')

self.template_type = 'honor'

# Check for font definition in course yaml, default to 'OpenSans' and 'Light'

self.template_font = cert_data.get('font', {})

self.template_font_name = self.template_font.get('name', 'OpenSans')

self.template_font_type = self.template_font.get('type', 'Light')

# search for certain keywords in the file name, we'll probably want to

# be better at parsing this later

# If TEMPLATEFILE is set in cert-data.yml, this value has top priority.

# Else if a value is passed in to the constructor (eg, from xqueue), it is used,

# Else, the filename is calculated from the version and course_id.

template_pdf = cert_data.get('TEMPLATEFILE', template_pdf)

# template_pdf is allowed to be None and '' so we key exactly on False here

if template_pdf is not False:

template_prefix = "{template_dir}/v{template_version}-cert-templates".format(

template_dir=TEMPLATE_DIR,

template_version=self.template_version,

)

template_pdf_filename = "{template_prefix}/certificate-template-{org}-{course}.pdf".format(

template_prefix=template_prefix,

org=self.org,

course=self.course,

)

if template_pdf:

template_pdf_filename = "{template_prefix}/{template_pdf}".format(

template_prefix=template_prefix,

template_pdf=template_pdf,

)

if 'verified' in template_pdf:

self.template_type = 'verified'

try:

self.template_pdf = PdfFileReader(file(template_pdf_filename, 'rb'))

except IOError as e:

log.critical("I/O error (%s): %s opening %s", e.errno, e.strerror, template_pdf_filename)

raise

self.cert_label_singular = cert_data.get('CERTS_ARE_CALLED', CERTS_ARE_CALLED)

self.cert_label_plural = cert_data.get('CERTS_ARE_CALLED_PLURAL', CERTS_ARE_CALLED_PLURAL)

self.course_association_text = cert_data.get('COURSE_ASSOCIATION_TEXT', 'a course of study')

def create_and_upload(

self,

name,

upload=settings.S3_UPLOAD,

cleanup=True,

copy_to_webroot=settings.COPY_TO_WEB_ROOT,

cert_web_root=settings.CERT_WEB_ROOT,

grade=None,

):

"""

name - Full name that will be on the certificate

upload - Upload to S3 (defaults to True)

set upload to False if you do not want to upload to S3,

this will also keep temporary files that are created.

returns a tuple containing the UUIDs for download, verify and

the full download URL. If upload is set to False

download_url in the return will be None

return (download_uuid, verify_uuid, download_url)

verify_uuid will be None if there is no verification signature

"""

download_uuid = None

verify_uuid = None

download_url = None

s3_conn = None

bucket = None

certificates_path = os.path.join(self.dir_prefix, S3_CERT_PATH)

verify_path = os.path.join(self.dir_prefix, S3_VERIFY_PATH)

(download_uuid, verify_uuid, download_url) = self._generate_certificate(student_name=name,

download_dir=certificates_path,

verify_dir=verify_path,

grade=grade,

)

# upload generated certificate and verification files to S3,

# or copy them to the web root. Or both.

my_certs_path = os.path.join(certificates_path, download_uuid)

my_verify_path = os.path.join(verify_path, verify_uuid)

if upload: # pragma: no cover

s3_conn = boto.connect_s3(settings.CERT_AWS_ID, settings.CERT_AWS_KEY)

bucket = s3_conn.get_bucket(BUCKET)

if upload or copy_to_webroot:

for subtree in (my_certs_path, my_verify_path):

for dirpath, dirnames, filenames in os.walk(subtree):

for filename in filenames:

local_path = os.path.join(dirpath, filename)

dest_path = os.path.relpath(local_path, start=self.dir_prefix)

publish_dest = os.path.join(cert_web_root, dest_path)

if upload: # pragma: no cover

key = Key(bucket, name=dest_path)

key.set_contents_from_filename(local_path, policy='public-read')

log.info("uploaded {local} to {s3path}".format(local=local_path, s3path=dest_path))

if copy_to_webroot:

dirname = os.path.dirname(publish_dest)

if not os.path.exists(dirname):

os.makedirs(dirname)

shutil.copy(local_path, publish_dest)

log.info("published {local} to {web}".format(local=local_path, web=publish_dest))

if cleanup:

for working_dir in (certificates_path, verify_path):

if os.path.exists(working_dir):

shutil.rmtree(working_dir)

return (download_uuid, verify_uuid, download_url)

def _generate_verification_page(self, name, filename, output_dir, verify_uuid, download_url):

"""

This generates the gpg signature and the

verification files including

the static html files that will be seen when

the user clicks the verification link.

name - full name of the student

filename - path on the local filesystem to the certificate pdf

output_dir - where to write the verification files

verify_uuid - UUID for the verification files

download_url - link to the pdf download (for the verifcation page)"""

# Do not do anything if there isn't any GPG Key to sign with

if not CERT_KEY_ID:

return

valid_template = 'valid.html'

verify_template = 'verify.html'

# generate signature

signature_filename = os.path.basename(filename) + ".sig"

signature_filename = os.path.join(output_dir, verify_uuid, signature_filename)

self._ensure_dir(signature_filename)

gpg = gnupg.GPG(homedir=settings.CERT_GPG_DIR)

gpg.encoding = 'utf-8'

with open(filename) as f:

signed_data = gpg.sign(data=f, default_key=CERT_KEY_ID, clearsign=False, detach=True).data

with open(signature_filename, 'w') as f:

f.write(signed_data.encode('utf-8'))

# create the validation page

signature_download_url = "{verify_url}/{verify_path}/{verify_uuid}/{verify_filename}".format(

verify_url=settings.CERT_VERIFY_URL,

verify_path=S3_VERIFY_PATH,

verify_uuid=verify_uuid,

verify_filename=os.path.basename(signature_filename))

verify_page_url = "{verify_url}/{verify_path}/{verify_uuid}/verify.html".format(

verify_url=settings.CERT_VERIFY_URL,

verify_path=S3_VERIFY_PATH,

verify_uuid=verify_uuid)

type_map = {

'verified': {'type': 'idverified', 'type_name': 'Verified'},

'honor': {'type': 'honorcode', 'type_name': 'Honor Code'},

}

type_map['verified']['explanation'] = (

"An ID verified certificate signifies that an edX user has "

"agreed to abide by edX's honor code and completed all of the "

"required tasks of this course under its guidelines, as well "

"as having their photo ID checked to verify their identity."

)

type_map['verified']['img'] = '''

<div class="wrapper--img">

<img

class="img--idverified"

src="/v2/static/images/logo-idverified.png"

alt="ID Verified Certificate Logo"

/>

</div>

'''

type_map['honor']['explanation'] = (

"An honor code certificate signifies that an edX user has "

"agreed to abide by edX's honor code and completed all of the "

"required tasks of this course under its guidelines."

)

type_map['honor']['img'] = ""

with open("{0}/{1}".format(TEMPLATE_DIR, valid_template)) as f:

valid_page = f.read().decode('utf-8')

valid_page = valid_page.format(

COURSE=self.course.decode('utf-8'),

COURSE_LONG=self.long_course.decode('utf-8'),

ORG=self.org.decode('utf-8'),

ORG_LONG=self.long_org.decode('utf-8'),

NAME=name.decode('utf-8'),

CERTIFICATE_ID=verify_uuid,

SIGNATURE=signed_data,

SIG_URL=signature_download_url,

VERIFY_URL=verify_page_url,

TYPE=type_map[self.template_type]['type'],

TYPE_NAME=type_map[self.template_type]['type_name'],

ISSUE_DATE=self.issued_date,

IMG=type_map[self.template_type]['img'],

CERTS_ARE_CALLED=CERTS_ARE_CALLED.title(),

CERTS_ARE_CALLED_PLURAL=CERTS_ARE_CALLED_PLURAL.title(),

EXPLANATION=type_map[self.template_type]['explanation'],

)

with open(os.path.join(

output_dir, verify_uuid, "valid.html"), 'w') as f:

f.write(valid_page.encode('utf-8'))

with open("{0}/{1}".format(TEMPLATE_DIR, verify_template)) as f:

verify_page = f.read().decode('utf-8').format(

NAME=name.decode('utf-8'),

SIG_URL=signature_download_url,

SIG_FILE=os.path.basename(signature_download_url),

CERT_KEY_ID=CERT_KEY_ID,

CERTS_ARE_CALLED=CERTS_ARE_CALLED.title(),

CERTS_ARE_CALLED_PLURAL=CERTS_ARE_CALLED_PLURAL.title(),

VERIFY_URL=verify_page_url,

PDF_FILE=os.path.basename(download_url)

)

with open(os.path.join(

output_dir, verify_uuid, "verify.html"), 'w') as f:

f.write(verify_page.encode('utf-8'))

def _ensure_dir(self, f):

d = os.path.dirname(f)

if not os.path.exists(d):

os.makedirs(d)

def _generate_certificate(

self,

student_name,

download_dir,

verify_dir,

filename=TARGET_FILENAME,

grade=None,

):

"""Generate a PDF certificate, signature and html files for validation.

REQUIRED PARAMETERS:

student_name - specifies student name as it must appear on the cert.

download_dir -

verify_dir -

OPTIONAL PARAMETERS:

filename - the filename to write out, e.g., 'Statement.pdf'.

Defaults to settings.TARGET_FILENAME.

grade - the grade received by the student. Defaults to 'Pass'

CONFIGURATION PARAMETERS:

The following items are brought in from the cert-data.yml stanza for the

current course:

LONG_COURSE - (optional) The course title to be printed on the cert;

unset means to use the value passed in as part of the

certificate request.

ISSUED_DATE - (optional) If given, the date string which should be

stamped onto each and every certificate. The value

ROLLING is equivalent to leaving ISSUED_DATE unset, which

stamps the certificates with the current date.

HAS_DISCLAIMER - (optional) If given, the programmatic disclaimer that

is usually rendered at the bottom of the page, is not.

TEMPLATEFILE - (optional) If given, the filename referred to by

TEMPLATEFILE will be used as the template over which

to render.

RETURNS (download_uuid, verify_uuid, download_url)

"""

verification_paragraph = self.cert_data.get('VERIFY', True)

verify_uuid = uuid.uuid4().hex if verification_paragraph else ''

download_uuid = uuid.uuid4().hex

download_url = "{base_url}/{cert}/{uuid}/{file}".format(

base_url=settings.CERT_DOWNLOAD_URL,

cert=S3_CERT_PATH,

uuid=download_uuid,

file=filename,

)

filename = os.path.join(download_dir, download_uuid, filename)

# This file is overlaid on the template certificate

overlay_pdf_buffer = StringIO.StringIO()

page = canvas.Canvas(overlay_pdf_buffer, pagesize=landscape(A4))

# page width: 841.88976378 pts

# page height: 595.275590551 pts

# --- Fonts --- #

# 0 0 - normal

# 0 1 - italic

# 1 0 - bold

# 1 1 - italic and bold

font_string = self.template_font_name + '-' + self.template_font_type

font_file = font_string + '.ttf'

addMapping(font_string, 0, 0, font_string)

addMapping(font_string, 0, 1, self.template_font_name + '-Italic')

addMapping(font_string, 1, 0, self.template_font_name + '-Bold')

addMapping(font_string, 1, 1, self.template_font_name + '-BoldItalic')

# These are ordered by preference; cf. font_for_string() above

self.fontlist = [

(font_string, font_file, None),

('Arial Unicode', 'Arial Unicode.ttf', None),

]

fontlist = self.fontlist

# Process Translations

default_translation = settings.DEFAULT_TRANSLATIONS.get(settings.DEFAULT_LOCALE, {})

successfully_completed = default_translation.get('success_text', '')

grade_interstitial = default_translation.get('grade_interstitial', '')

disclaimer_text = default_translation.get('disclaimer_text', '')

verify_text = default_translation.get('verify_text', '')

if self.locale in self.course_translations:

successfully_completed = self.course_translations[self.locale].get('success_text', successfully_completed)

grade_interstitial = self.course_translations[self.locale].get('grade_interstitial', grade_interstitial)

disclaimer_text = self.course_translations[self.locale].get('disclaimer_text', disclaimer_text)

verify_text = self.course_translations[self.locale].get('verify_text', verify_text)

# calculate interstitial text

achievements_string = ""

achievements_description_string = self.interstitial_texts[grade].decode('utf-8')

if grade and grade.lower() != 'pass':

grade_html = u"<b>{grade}</b>".format(grade=grade.decode('utf-8'))

achievements_string = grade_interstitial.decode('utf-8').format(grade=grade_html) + '<br /><br />'

achievements_paragraph = u"{0}{1}".format(achievements_string, achievements_description_string)

# Overide achievements/interstitial strings with yaml designations info based on designation

designation = self.designation

designation_tag = ''

for key, value in self.cert_data.get('designations', {}).iteritems():

if designation in value['titles']:

# Add student name designation if not Other or None

if designation not in ['Other', 'None']:

student_name = "{name}, {designation}".format(

name=student_name,

designation=designation,

)

achievements_string = value['credits']

achievements_description_string = unicode(self.cert_data['CREDITS'])

designation_tag = key

break

# print disclaimer text if required

print_disclaimer = not self.cert_data.get('HAS_DISCLAIMER', False)

if not print_disclaimer:

disclaimer_text = ""

# print verify text if required

formatted_verify_text = ""

if verification_paragraph:

verify_link = (

u"<a href='{verify_url}/{verify_path}/{verify_uuid}'>"

u"<b>{verify_url}/{verify_path}/{verify_uuid}</b>"

u"</a>"

).encode('utf-8').format(

verify_url=settings.CERT_VERIFY_URL,

verify_path=S3_VERIFY_PATH,

verify_uuid=verify_uuid,

)

formatted_verify_text = verify_text.format(

verify_link=verify_link,

)

# Course Context

context = {

'date_string': get_cert_date(self.issued_date, self.locale, self.timezone),

'student_name': student_name.decode('utf-8'),

'successfully_completed': successfully_completed,

'course_title': self.long_course.decode('utf-8'),

'achievements_string': achievements_string,

'achievements_description_string': achievements_description_string,

'designation_tag': designation_tag,

'disclaimer_text': disclaimer_text,

'verify_text': formatted_verify_text,

}

# Render Certificate Theme

certificate_theme = self.cert_data.get('certificate_theme', [])

for step in certificate_theme:

for element, attributes in step.iteritems():

draw_template_element(self, element, attributes, page)

# Render any flair below Course Information & Instructor Signatures

flair = self.cert_data.get('flair', [])

draw_flair(self, flair, 'bottom', page, context)

# Render Instructor Signature Blocks

instructors = self.cert_data.get('instructors', [])

for _instructor in instructors:

for __, instructor in _instructor.iteritems():

x_position = instructor['x']

y_position = instructor['y']

for step in instructor['template']:

for element, _attributes in step.iteritems():

attributes = copy.deepcopy(_attributes)

if element == 'text':

value = attributes.get('string')

if not value:

key = attributes['key']

if key not in instructor:

continue

value = instructor[key]

attributes['string'] = value

attributes['x'] = x_position + attributes.get('x', 0)

attributes['y'] = y_position + attributes.get('y', 0)

y_position += attributes['height']

elif element == 'line':

attributes['x_start'] += x_position

attributes['y_start'] += y_position

attributes['x_end'] += x_position

attributes['y_end'] += y_position

elif element == 'image':

value = attributes.get('file')

y_offset = 0

if not value:

key = attributes['key']

value = instructor[key]

if key == 'signature_file':

y_offset = instructor.get('signature_y_offset', 0)

attributes['file'] = value

filepath = os.path.join(TEMPLATE_DIR, attributes['file'])

image = utils.ImageReader(filepath)

image_width, image_height = image.getSize()

aspect_ratio = image_height / float(image_width)

image_width = attributes.get('width', image_width)

image_height = int(image_width * aspect_ratio)

attributes['x'] = attributes.get('x', 0) + x_position

attributes['y'] = attributes.get('y', 0) + y_position + y_offset

attributes['height'] = image_height

attributes['width'] = image_width

y_position = y_position + y_offset + image_height

else:

continue

draw_template_element(self, element, attributes, page)

# Render Dynamic Course Information

course_information = self.cert_data.get('course_information', [])

for step in course_information:

for element, attributes in step.iteritems():

draw_template_element(self, element, attributes, page, context=context)

# Render any flair above Course Information & Instructor Signatures

draw_flair(self, flair, 'top', page, context)

# Render Page

page.showPage()

page.save()

# Merge the overlay with the template, then write it to file

output = PdfFileWriter()

overlay = PdfFileReader(overlay_pdf_buffer)

# We render the final certificate by merging several rendered pages.

# It is fastest if the bottom layer is blank and loaded from memory

final_certificate = copy.copy(BLANK_PDFS['landscape-A4']).getPage(0)

final_certificate.mergePage(overlay.getPage(0))

output.addPage(final_certificate)

self._ensure_dir(filename)

outputStream = file(filename, 'wb')

output.write(outputStream)

outputStream.close()

# have to create the verification page seperately from the above

# conditional because filename must have already been written.

if verification_paragraph:

self._generate_verification_page(

student_name,

filename,

verify_dir,

verify_uuid,

download_url,

)