Hi! Welcome to RecordTrac's technical documentation. Here you'll find the source code for the Flask application. A good place to start is by browsing views.py, models.py and prr.py. All of the templates referenced can be found here. A full table of contents is below.

• Jump to db_helpers.py docs
• Jump to csv_export.py docs
• Jump to notifications.py docs
• Jump to prflask.py docs
• Jump to prr.py docs
• Jump to RequestPresenter.py docs
• Jump to ResponsePresenter.py docs
• Jump to scribd_helpers.py docs
• Jump to spam.py docs
• Jump to views.py docs
• Jump to models.py docs

db_helpers.py

""" 
.. module:: db_helpers
	:synopsis: Functions that interact with the Postgres database via Flask-SQLAlchemy
.. modlueauthor:: Richa Agarwal <richa@codeforamerica.org>
"""


from public_records_portal import db, app
from models import *
from datetime import datetime, timedelta
from sqlalchemy.exc import IntegrityError, InvalidRequestError
from sqlalchemy import func, not_, and_, or_
from sqlalchemy.dialects import postgresql
import uuid
import json
import os
import logging 


### @export "get_subscriber"
def get_subscriber(request_id, user_id):
# Returns the subscriber for a given request by user ID
	if request_id and user_id:
		return Subscriber.query.filter_by(user_id = user_id).filter_by(request_id = request_id).first()
	return None

### @export "get_count"
def get_count(obj_type):
	return db.session.query(func.count(eval(obj_type).id)).scalar()

### @export "get_obj"
def get_obj(obj_type, obj_id):
	""" Query the database for an object via its class/type (defined in models.py) and ID and return the object. """
	if not obj_id:
		return None
	return eval(obj_type).query.get(obj_id)

### @export "get_objs"
def get_objs(obj_type):
	""" Query the database for all objects of a certain class/type (defined in models.py) and return queryset. """
	# There has to be a better way of doing this
	if obj_type == "User":
		return User.query.all()
	elif obj_type == "Request":
		return Request.query.all()
	elif obj_type == "Owner":
		return Owner.query.all()
	elif obj_type == "Note":
		return Note.query.all()
	elif obj_type == "QA":
		return QA.query.all()
	elif obj_type == "Subscriber":
		return Subscriber.query.all()
	elif obj_type == "Record":
		return Record.query.all()
	return None

### @export "get_avg_response_time"
def get_avg_response_time(department):
	app.logger.info("\n\nCalculating average response time for department: %s" % department)
	d = Department.query.filter_by(name = department).first()
	response_time = None
	num_closed = 0
	for request in d.requests:
		date_created = request.date_received or request.date_created
		if request.status and 'Closed' in request.status:
			if response_time:
				response_time = response_time + (request.status_updated - date_created).total_seconds()
			else:
				response_time = (request.status_updated - date_created).total_seconds()
			num_closed = num_closed + 1
	if num_closed > 0:
		avg = response_time / num_closed
		return avg
	return None

### @export "get_request_by_owner"
def get_request_by_owner(owner_id):
	""" Return the request that a particular owner belongs to """
	if not owner_id:
		return None
	return Owner.query.get(owner_id).request

### @export "get_owners_by_user_id"
def get_owners_by_user_id(user_id):
	""" Return the queryset of owners for a particular user. (A user can be associated with multiple owners)."""
	if not user_id:
		return None
	return Owner.query.filter_by(user_id = user_id)

### @export "get_prr_liaison_by_dept"
def get_contact_by_dept(dept):
	""" Return the contact for a given department. """
	q = db.session.query(User).filter(func.lower(User.contact_for).like("%%%s%%" % dept.lower()))
	if len(q.all()) > 0:
		return q[0].email
	app.logger.debug("Department: %s" % dept)
	return None

### @export "get_backup_by_dept"
def get_backup_by_dept(dept):
	""" Return the contact for a given department. """
	q = db.session.query(User).filter(func.lower(User.backup_for).like("%%%s%%" % dept.lower()))
	if len(q.all()) > 0:
		return q[0].email
	app.logger.debug("Department: %s" % dept)
	return None

### @export "put_obj"
def put_obj(obj):
	""" Add and commit the object to the database. Return true if successful. """
	if obj:
		db.session.add(obj)
		db.session.commit()
		app.logger.info("\n\nCommitted object to database: %s" % obj)
		return True
	return False

### @export "get_attribute"
def get_attribute(attribute, obj_id = None, obj_type = None, obj = None):
	""" Obtain the object by obj_id and obj_type if obj is not provided, and return the specified attribute for that object. """
	if obj_id and obj_type:
		obj = get_obj(obj_type, obj_id)
	if obj:
		try:
			return getattr(obj, attribute)
		except:
			return None
	return None

### @export "update_obj"
def update_obj(attribute, val, obj_type = None, obj_id = None, obj = None):
	""" Obtain the object by obj_id and obj_type if obj is not provided, and update the specified attribute for that object. Return true if successful. """
	app.logger.info("\n\nUpdating attribute: %s with value: %s for obj_type: %s, obj_id: %s, obj: %s"%(attribute, val,obj_type, obj_id, obj))
	if obj_id and obj_type:
		obj = get_obj(obj_type, obj_id)
	if obj:
		try:
			setattr(obj, attribute, val)
			db.session.add(obj)
			db.session.commit()
			return True
		except:
			return False
	return False

### @export "create_QA"
def create_QA(request_id, question, user_id):
	""" Create a QA object and return the ID. """
	qa = QA(request_id = request_id, question = question, user_id = user_id)
	db.session.add(qa)
	db.session.commit()
	return qa.id

### @export "create_request"
def create_request(text, user_id, offline_submission_type = None, date_received = None):
	""" Create a Request object and return the ID. """
	req = Request(text = text, creator_id = user_id, offline_submission_type = offline_submission_type, date_received = date_received)
	db.session.add(req)
	db.session.commit()
	req.set_due_date()
	return req.id

### @export "create_subscriber"
def create_subscriber(request_id, user_id):
	""" Create a Subscriber object and return the ID. """
	subscriber = Subscriber.query.filter_by(request_id = request_id, user_id = user_id).first()
	if not subscriber:
		subscriber = Subscriber(request_id = request_id, user_id = user_id)
		db.session.add(subscriber)
		db.session.commit()
		return subscriber.id, True
	return subscriber.id, False

### @export "create_note"
def create_note(request_id, text, user_id):
	""" Create a Note object and return the ID. """
	try:
		note = Note(request_id = request_id, text = text, user_id = user_id)
		put_obj(note)
		return note.id
	except Exception, e:
		app.logger.info("\n\nThere was an issue with creating a note with text: %s %s" % (text, e))
		return None

### @export "create_record"
def create_record(request_id, user_id, description, doc_id = None, filename = None, access = None, url = None):
	try:
		record = Record(doc_id = doc_id, request_id = request_id, user_id = user_id, description = description, filename = filename, url = url, access = access)
		put_obj(record)
		return record.id
	except Exception, e:
		app.logger.info("\n\nThere was an issue with creating a record: %s" % e)
		return None

def remove_obj(obj_type, obj_id):
	obj = get_obj(obj_type, obj_id)
	db.session.delete(obj)
	db.session.commit()

### @export "create_answer"
def create_answer(qa_id, subscriber_id, answer):
	qa = get_obj("QA", qa_id)
	if not qa:
		app.logger.info("\n\nQA with id: %s does not exist" % (qa_id))
		return None
	qa.subscriber_id = subscriber_id
	qa.answer = answer
	db.session.add(qa)
	db.session.commit()
	return qa.request_id

# Following three functions are for integration with Mozilla Persona

### @export "get_user"
def get_user(kwargs):
    return User.query.filter(User.email == kwargs.get('email')).filter(User.is_staff == True).first()

### @export "get_user_by_id"
def get_user_by_id(id):
    return User.query.get(id)

### @export "create_or_return_user"
def create_or_return_user(email=None, alias = None, phone = None, department = None, contact_for = None, backup_for = None, not_id = False, is_staff = None):
	app.logger.info("\n\nCreating or returning user...")
	if email:
		user = User.query.filter(User.email == func.lower(email)).first()
		if department and type(department) != int and not department.isdigit():
			d = Department.query.filter_by(name = department).first()
			if d:
				department = d.id
			else:
				d = Department(name = department)
				db.session.add(d)
				db.session.commit()
				department = d.id
		if not user:
			user = create_user(email = email.lower(), alias = alias, phone = phone, department = department, contact_for = contact_for, backup_for = backup_for, is_staff = is_staff)
		else:
			if alias or phone or department or contact_for or backup_for: # Update user if fields to update are provided
				user = update_user(user = user, alias = alias, phone = phone, department = department, contact_for = contact_for, backup_for = backup_for, is_staff = is_staff)
		if not_id:
			return user
		return user.id
	else:
		user = create_user(alias = alias, phone = phone, is_staff = is_staff)
		return user.id

### @export "create_user"
def create_user(email=None, alias = None, phone = None, department = None, contact_for = None, backup_for = None, is_staff = None):
	user = User(email = email, alias = alias, phone = phone, department = department, contact_for = contact_for, backup_for = backup_for, is_staff = is_staff)
	db.session.add(user)
	db.session.commit()
	app.logger.info("\n\nCreated new user, alias: %s id: %s" % (user.alias, user.id))
	return user

### @export "update_user"
def update_user(user, alias = None, phone = None, department = None, contact_for = None, backup_for = None, is_staff = None):
	if alias:
		user.alias = alias
	if phone:
		user.phone = phone
	if department:
		if type(department) != int and not department.isdigit():
			d = Department.query.filter_by(name = department).first()
			if d:
				user.department = d.id
		else:
			user.department = department
	if contact_for:
		if user.contact_for and contact_for not in user.contact_for:
			contact_for = user.contact_for + "," + contact_for
		user.contact_for = contact_for
	if backup_for:
		if user.backup_for and backup_for not in user.backup_for:
			backup_for = user.backup_for + "," + backup_for
		user.backup_for = backup_for
	if is_staff:
		user.is_staff = is_staff
	db.session.add(user)
	db.session.commit()
	app.logger.info("\n\nUpdated user %s, alias: %s phone: %s department: %s" % (user.id, alias, phone, department))
	return user

### @export "create_owner"
def create_owner(request_id, reason, email = None, user_id = None):
	""" Adds a staff member to the request without assigning them as current owner. (i.e. "participant")
	Useful for multidepartmental requests."""
	if not user_id:
		user_id = create_or_return_user(email = email)
	participant = Owner(request_id = request_id, user_id = user_id, reason = reason)
	db.session.add(participant)
	db.session.commit()
	app.logger.info("\n\nCreated owner with id: %s" % participant.id)
	return participant.id

### @export "change_request_status"
def change_request_status(request_id, status):
	req = get_obj("Request", request_id)
	req.status = status
	req.status_updated = datetime.now().isoformat()
	db.session.add(req)
	app.logger.info("\n\nChanged status for request: %s to %s" % (request_id, status))
	db.session.commit()

### @export "find_request"
def find_request(text):
	req = Request.query.filter_by(text = text).first()
	if req:
		return req.id
	return None


### @export "add_staff_participant"
def add_staff_participant(request_id, is_point_person = False, email = None, user_id = None, reason = None):
	""" Creates an owner for the request if it doesn't exist, and returns the owner ID and True if a new one was created. Returns the owner ID and False if existing."""
	is_new = True
	if not user_id:
		user_id = create_or_return_user(email = email)
	participant = Owner.query.filter_by(request_id = request_id, user_id = user_id, active = True).first()
	if not participant:
		if not reason:
			reason = "Added a response"
		participant = Owner(request_id = request_id, user_id = user_id, reason = reason, is_point_person = is_point_person)
		app.logger.info("\n\nStaff participant with owner ID: %s added to request %s. Is point of contact: %s" %(participant.id, request_id, is_point_person))
	else:
		if is_point_person and not participant.is_point_person:
			participant.is_point_person = True
			participant.date_updated = datetime.now().isoformat()
			if reason: # Update the reason
				participant.reason = reason 
			app.logger.info("\n\nStaff participant with owner ID: %s is now the point of contact for request %s" %(participant.id, request_id))
		else:
			is_new = False
			app.logger.info("\n\nStaff participant with owner ID: %s already active on request %s" %(participant.id, request_id))
	db.session.add(participant)
	db.session.commit()
	return participant.id, is_new


### @export "remove_staff_participant"
def remove_staff_participant(owner_id, reason = None):
	participant = Owner.query.get(owner_id)
	participant.active = False
	participant.date_updated = datetime.now().isoformat()
	participant.reason_unassigned = reason
	db.session.add(participant)
	db.session.commit()
	app.logger.info("\n\n Staff participant with owner ID: %s has been removed for following reason %s" %(owner_id, reason))
	return owner_id


### @export "update_subscriber"
def update_subscriber(request_id, alias, phone):
	""" Update a subscriber for a given request with the name and phone number provided. """
	user_id = create_or_return_user(alias = alias, phone = phone)
	r = Request.query.get(request_id)
	sub = r.subscribers[0]
	sub.user_id = user_id
	db.session.add(sub)
	db.session.commit()
	app.logger.info("\n\nUpdated subscriber for request %s with alias: %s and phone: %s" % (request_id, alias, phone))

csv_export.py

"""
    public_records_portal.csv_export
    ~~~~~~~~~~~~~~~~

    Implements an export to CSV function (for staff only) for relevant database fields.

"""

from public_records_portal import models, db
import csv

def export():
	records = models.Request.query.order_by(models.Request.id).all()
	db_headers = ['id', 'text', 'date_received', 'date_created', 'due_date', 'extended']
	all_headers = ['Request ID', 'Request Text', 'Date Received', 'Date Created', 'Date Due', 'Extended?', 'Requester Name', 'Requester Phone', 'Department Name', 'Point of Contact', 'All staff involved', 'Status']
	yield '\t'.join(all_headers) + '\n'
	for curr in records:
		row = []
		for name in db_headers:
			if name == 'text':
				text = getattr(curr,'text')
				text = text.replace('\n', '').replace('\r', '').replace('\t', '')
				text = text.encode('utf8')
				# print text
				row.append(str(text))
				continue
			row.append(str(getattr(curr,name)))
		row.append(str(curr.requester_name().encode('utf8')))
		row.append(str(curr.requester_phone()))
		row.append(str(curr.department_name()))
		row.append(str(curr.point_person_name()))
		row.append(str(','.join(curr.all_owners())))
		row.append(str(curr.solid_status(cron_job = True)))
		yield '\t'.join(row) + '\n'

notifications.py

"""
    public_records_portal.notifications
    ~~~~~~~~~~~~~~~~

    Implements e-mail notifications for RecordTrac. SendGrid (https://sendgrid.com/) is a dependency, and the following environment variables need to be set in order for this to work: MAIL_USERNAME, MAIL_PASSWORD, and DEFAULT_MAIL_SENDER.

"""




from datetime import datetime, timedelta
from public_records_portal import app
import os
import json
from db_helpers import *
import sendgrid
from flask import render_template
import helpers
import logging

# Set flags:

send_emails = False
test = "[TEST] "

if app.config['ENVIRONMENT'] == 'PRODUCTION':
	send_emails = True
	test = ""
elif 'DEV_EMAIL' in app.config:
	send_emails = True

### @export "generate_prr_emails"
def generate_prr_emails(request_id, notification_type, user_id = None):
	app.logger.info("\n\n Generating e-mails for request with ID: %s, notification type: %s, and user ID: %s" %(request_id, notification_type, user_id))
	app_url = app.config['APPLICATION_URL'] 
	# Define the e-mail template:
	template = "generic_email.html" 
	if notification_type == "Request made":
		template = "new_request_email.html"
	# Get information on who to send the e-mail to and with what subject line based on the notification type:
	email_info = get_email_info(notification_type=notification_type)
	email_subject = "Public Records Request %s: %s" %(request_id, email_info["Subject"])
	recipient_types = email_info["Recipients"]
	include_unsubscribe_link = True
	unfollow_link = None 
	for recipient_type in recipient_types:
		# Skip anyone that has unsubscribed
		if user_id and (recipient_type == "Requester" or recipient_type == "Subscriber"):
			subscriber = get_subscriber(request_id = request_id, user_id = user_id)
			should_notify = get_attribute(attribute = "should_notify", obj = subscriber)
			if should_notify == False:
				app.logger.info("\n\nSubscriber %s unsubscribed, no notification sent." % subscriber.id)
				continue
		# Set up the e-mail
		page = "%srequest/%s" %(app_url,request_id) # The request URL 
		if "Staff" in recipient_type:
			page = "%scity/request/%s" %(app_url,request_id)
			include_unsubscribe_link = False # Gets excluded for city staff
		else:
			unfollow_link = "%sunfollow/%s/" %(app_url, request_id)
			if notification_type == "Request closed":
				page = "%sfeedback/request/%s" %(app_url,request_id)
		if recipient_type in ["Staff owner","Requester","Subscriber","Staff participant"]:
			if user_id:
				recipient = get_attribute(attribute = "email", obj_id = user_id, obj_type = "User")
				# if recipient_type != "Subscriber" or get_attribute(attribute="")
				if recipient:
					if unfollow_link:
						unfollow_link = unfollow_link + recipient
					send_prr_email(page = page, recipients = [recipient], subject = email_subject, template = template, include_unsubscribe_link = include_unsubscribe_link, unfollow_link = unfollow_link)
			else:
				app.logger.debug("\n\n No user ID provided")
		elif recipient_type == "Subscribers":
			subscribers = get_attribute(attribute = "subscribers", obj_id = request_id, obj_type = "Request")
			for subscriber in subscribers:
				if subscriber.should_notify == False:
					app.logger.info("\n\n Subscriber %s unsubscribed" % subscriber.id)
					continue
				recipient = get_attribute(attribute = "email", obj_id = subscriber.user_id, obj_type = "User")
				if recipient:
					if unfollow_link:
						unfollow_link = unfollow_link + recipient
					send_prr_email(page = page, recipients = [recipient], subject = email_subject, template = template, include_unsubscribe_link = include_unsubscribe_link, unfollow_link = unfollow_link) # Each subscriber needs to get a separate e-mail.
		elif recipient_type == "Staff participants":
			recipients = []
			participants = get_attribute(attribute = "owners", obj_id = request_id, obj_type = "Request")
			for participant in participants:
				if participant.active: # Only send an e-mail if they are active in the request
					recipient = get_attribute(attribute = "email", obj_id = participant.user_id, obj_type = "User")
					if recipient:
						recipients.append(recipient)
			send_prr_email(page = page, recipients = recipients, subject = email_subject, template = template, include_unsubscribe_link = include_unsubscribe_link, cc_everyone = False, unfollow_link = unfollow_link)
			app.logger.info("\n\nRecipients: %s" % recipients)
		else:
			app.logger.info("Not a valid recipient type: %s" % recipient_type)

### @export "send_prr_email"
def send_prr_email(page, recipients, subject, template, include_unsubscribe_link = True, cc_everyone = False, password = None, unfollow_link = None):
	app.logger.info("\n\nAttempting to send an e-mail to %s with subject %s, referencing page %s and template %s" % (recipients, subject, page, template))
	if recipients:
		if send_emails:
			try:
				send_email(body = render_template(template, unfollow_link = unfollow_link, page = page, password = password), recipients = recipients, subject = subject, include_unsubscribe_link = include_unsubscribe_link, cc_everyone = cc_everyone)
				app.logger.info("\n\n E-mail sent successfully!")
			except Exception, e:
				app.logger.info("\n\nThere was an error sending the e-mail: %s" % e)
		else:
			app.logger.info("\n\n E-mail flag turned off, no e-mails sent.")

### @export "send_email"
def send_email(body, recipients, subject, include_unsubscribe_link = True, cc_everyone = False):
	mail = sendgrid.Sendgrid(app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD'], secure = True)
	sender = app.config['DEFAULT_MAIL_SENDER']
	plaintext = ""
	html = body
	message = sendgrid.Message(sender, subject, plaintext, html)
	if not include_unsubscribe_link:
		message.add_filter_setting("subscriptiontrack", "enable", 0)
	if 'DEV_EMAIL' in app.config:
		recipients = [app.config['DEV_EMAIL']]
	if cc_everyone: # Not being used for now
		message.add_to(recipients[0])
		for recipient in recipients:
			# if should_notify(recipient):
				message.add_cc(recipient)
	else:
		for recipient in recipients:
			# if should_notify(recipient):
				message.add_to(recipient)
	message.add_bcc(sender)
	if send_emails:
		app.logger.info("\n\n Attempting to send e-mail with body: %s, subject: %s, to %s" %(body, subject, recipients))
		try:
			status = mail.web.send(message)
			if status == False:
				app.logger.info("\n\nSendgrid did not deliver e-mail.")
			return status
		except Exception, e:
			app.logger.error("\n\nNo e-mail was sent, error: %s" % e)
			return False
	app.logger.info("\n\nNo e-mail was sent, probably because you're in a non-production environment.")
	return False

### @export "due_date"
def due_date(date_obj, extended = None, format = True):
	days_to_fulfill = 10
	if extended == True:
		days_to_fulfill = days_to_fulfill + 14
	if not date_obj:
		return None
	if type(date_obj) is not datetime:
		date_obj = datetime.strptime(date_obj, "%Y-%m-%dT%H:%M:%S.%f")
	due_date = date_obj + timedelta(days = days_to_fulfill)
	if format:
		return format_date(due_date)
	return due_date

### @export "is_overdue"
def is_overdue(date_obj, extended = None):
	current_date = datetime.now()
	due = due_date(date_obj = date_obj, extended = extended, format = False)
	if (current_date >= due):
		return True, due
	return False, due

### @export "get_email_info"
def get_email_info(notification_type):
	email_json = open(os.path.join(app.root_path, 'static/json/emails.json'))
	json_data = json.load(email_json)
	return json_data["Notification types"][notification_type]

### @export "notify_due"
def notify_due():
	requests = get_objs("Request")
	email_json = open(os.path.join(app.root_path, 'static/json/emails.json'))
	json_data = json.load(email_json)
	for req in requests:
		status = req.solid_status
		if status != "closed":
			# Check if it is due in 2 days
			if status == "due soon":
				change_request_status(req.id, "Due soon")
				email_subject = "%sPublic Records Request %s: %s" %(test, req.id, json_data["Notification types"]["Request due"])
			elif status == "overdue":
				change_request_status(req.id, "Overdue")
				email_subject = "%sPublic Records Request %s: %s" %(test, req.id, json_data["Notification types"]["Request overdue"]["Subject"])
			else:
				continue
			recipients = get_staff_recipients(req)
			app_url = app.config['APPLICATION_URL']
			page = "%scity/request/%s" %(app_url,req.id)
			body = "You can view the request and take any necessary action at the following webpage: <a href='%s'>%s</a>.</br></br> This is an automated message. You are receiving it because you are listed as the Public Records Request Liaison, Backup or Supervisor for your department." %(page, page)
				# Need to figure out a way to pass in generic email template outside application context. For now, hardcoding the body.
			send_email(body = body, recipients = recipients, subject = email_subject, include_unsubscribe_link = False)

### @export "get_staff_recipients"
def get_staff_recipients(request):
	recipients = []
	owner_email = request.point_person().user.email
	if owner_email:
		recipients.append(owner_email)
	# Look up the department for the request, and get the contacts and backup:
	dept = request.department_name()
	if dept != "N/A":
		contact_email = get_contact_by_dept(dept)
		if contact_email and contact_email not in recipients:
			recipients.append(contact_email)
		backup_email = get_backup_by_dept(dept)
		if backup_email and backup_email not in recipients:
			recipients.append(backup_email)
	if recipients:
		return recipients
	else:
		raise ValueError('No staff recipients for request %s' %(request.id)) 

### @export "should_notify"
def should_notify(user_email):
	""" Looks up the user in do_not_email.json and returns False if found. """
	do_not_email = open(os.path.join(app.root_path, 'static/json/do_not_email.json'))
	json_data = json.load(do_not_email)
	for department in json_data:
		emails = json_data[department]['Emails']
		for email in emails:
			if email.lower() == user_email.lower():
				return False
	return True

### @export "format_date"
def format_date(obj):
	""" Take a datetime object and return it in format Jun 12, 2013 """
	if not obj:
		return None
	return helpers.localize(obj).strftime('%b %d, %Y')

prflask.py

"""
    public_records_portal.prflask
    ~~~~~~~~~~~~~~~~

    Sets up API and admin endpoints for the RecordTrac flask application.

"""



from public_records_portal import app, models, db, views
from views import * # Import all the functions that render templates
from flask.ext.restless import APIManager
from flask.ext.admin import Admin, expose, BaseView, AdminIndexView
from flask.ext.admin.contrib.sqlamodel import ModelView


# Create API
manager = APIManager(app, flask_sqlalchemy_db=db)


# The endpoints created are /api/object, e.g. publicrecordsareawesome.com/api/request/
manager.create_api(models.Request, methods=['GET'], results_per_page = 10, allow_functions = True, include_columns=['date_created', 'date_received', 'department', 'id', 'notes', 'offline_submission_type', 'owners', 'qas', 'records', 'status', 'status_updated', 'text'])
# manager.create_api(models.Owner, methods=['GET'], results_per_page = 10, allow_functions = True)
manager.create_api(models.Note, methods=['GET'], results_per_page = 10, allow_functions = True)
manager.create_api(models.Record, methods=['GET'], results_per_page = 10, allow_functions = True)
manager.create_api(models.QA, methods=['GET'], results_per_page =10, allow_functions = True)
# manager.create_api(models.Subscriber, methods=['GET'], results_per_page = 10, allow_functions = True)
manager.create_api(models.Visualization, methods=['GET'], results_per_page = 10, allow_functions = True)

class HomeView(AdminIndexView):
    @expose('/')
    def home(self):
        return self.render('admin.html')
    def is_accessible(self):
		if current_user.is_authenticated():
			if 'LIST_OF_ADMINS' in app.config:
				admins = app.config['LIST_OF_ADMINS'].split(",")
				if current_user.email.lower() in admins:
					return True
		return False

# Create Admin
admin = Admin(app, name='RecordTrac Admin', url='/admin', index_view = HomeView(name='Home'))

class AdminView(ModelView):
    def is_accessible(self):
    	if current_user.is_authenticated():
    		if 'LIST_OF_ADMINS' in app.config:
				admins = app.config['LIST_OF_ADMINS'].split(",")
				if current_user.email.lower() in admins:
					return True
        return False

class RequestView(AdminView):
	can_create = False
	can_edit = True
	column_list = ('id', 'text', 'date_created', 'status') # The fields the admin can view
	column_searchable_list = ('status', 'text') # The fields the admin can search a request by
	form_excluded_columns = ('date_created', 'extended', 'status', 'status_updated', 'current_owner') # The fields the admin cannot edit.

class RecordView(AdminView):
	can_create = False
	column_searchable_list = ('description', 'filename', 'url', 'download_url', 'access')
	column_list = ('request_id', 'description', 'filename', 'url', 'download_url', 'access')
	can_edit = False

class QAView(AdminView):
	can_create = False
	can_edit = True
	column_list = ('request_id', 'question', 'answer', 'date_created')
	form_excluded_columns = ('date_created')

class NoteView(AdminView):
	can_create = False
	can_edit = True
	column_list = ('request_id', 'text', 'date_created')
	form_excluded_columns = ('date_created')


admin.add_view(RequestView(models.Request, db.session))
admin.add_view(RecordView(models.Record, db.session))
admin.add_view(NoteView(models.Note, db.session))
admin.add_view(QAView(models.QA, db.session))

prr.py

"""
    public_records_portal.prr
    ~~~~~~~~~~~~~~~~

    Implements functions specific to managing or creating a public records request.

"""

from public_records_portal import app, db_helpers
import os, time, json
from flask import Flask, request
from flask.ext.login import current_user
from datetime import datetime, timedelta
from db_helpers import find_request, create_request, get_obj, add_staff_participant, remove_staff_participant, update_obj, get_attribute, change_request_status, create_or_return_user, create_subscriber, create_record, create_note, create_QA, create_answer
from models import *
from ResponsePresenter import ResponsePresenter
from RequestPresenter import RequestPresenter
from notifications import generate_prr_emails
import scribd_helpers
from spam import is_spam
import logging
import csv
import urllib

### @export "add_resource"
def add_resource(resource, request_body, current_user_id = None):
	fields = request_body
	if "extension" in resource:
		return request_extension(int(fields['request_id']), fields.getlist('extend_reason'), current_user_id)
	if "note" in resource:
		return add_note(request_id = int(fields['request_id']), text = fields['note_text'], user_id = current_user_id, passed_spam_filter = True) # Bypass spam filter because they are logged in.
	elif "record" in resource:
		if fields['record_description'] == "":
			return "When uploading a record, please fill out the 'summary' field."
		if 'record_access' in fields and fields['record_access'] != "":
			return add_offline_record(int(fields['request_id']), fields['record_description'], fields['record_access'], current_user_id)
		elif 'link_url' in fields and fields['link_url'] != "":
			return add_link(request_id = int(fields['request_id']), url = fields['link_url'], description = fields['record_description'], user_id = current_user_id)
		else:
			document = None
			try:
				document = request.files['record']
			except:
				app.logger.info("\n\nNo file passed in")
			return upload_record(request_id = int(fields['request_id']), document = document, description = fields['record_description'], user_id = current_user_id)
	elif "qa" in resource:
		return ask_a_question(request_id = int(fields['request_id']), user_id = current_user_id, question = fields['question_text'])
	elif "owner" in resource:
		participant_id, new = add_staff_participant(request_id = fields['request_id'], email = fields['owner_email'], reason = fields['owner_reason'])
		if new:
			generate_prr_emails(request_id = fields['request_id'], notification_type = "Staff participant added", user_id = get_attribute("user_id", obj_id = participant_id, obj_type = "Owner"))
		return participant_id
	elif "subscriber" in resource:
		return add_subscriber(request_id=fields['request_id'], email = fields['follow_email'])
	else:
		return False

### @export "update_resource"
def update_resource(resource, request_body):
	fields = request_body
	if "owner" in resource:
		if "reason_unassigned" in fields:
			return remove_staff_participant(owner_id = fields['owner_id'], reason = fields['reason_unassigned'])
		else:
			change_request_status(int(fields['request_id']), "Rerouted")
			return assign_owner(int(fields['request_id']), fields['owner_reason'], fields['owner_email'])
	elif "reopen" in resource:
		change_request_status(int(fields['request_id']), "Reopened")
		return fields['request_id']
	elif "request_text" in resource:
		update_obj(attribute = "text", val = fields['request_text'], obj_type = "Request", obj_id = fields['request_id'])
	elif "note_text" in resource:
		update_obj(attribute = "text", val = fields['note_text'], obj_type = "Note", obj_id = fields['response_id'])
		# Need to store note text somewhere else (or just do delete here as well)
	elif "note_delete" in resource:
		# Need to store note somewhere else
		remove_obj("Note", int(fields['response_id']))
	elif "record_delete" in resource:
		remove_obj("Record", int(fields['record_id']))
		# Need to store record somewhere else and prompt them to delete from Scribd as well, if they'd like
	else:
		return False

### @export "request_extension"
def request_extension(request_id, extension_reasons, user_id):
	req = Request.query.get(request_id)
	req.extension()
	text = "Request extended:"
	for reason in extension_reasons:
		text = text + reason + "</br>"
	add_staff_participant(request_id = request_id, user_id = user_id)
	return add_note(request_id = request_id, text = text, user_id = user_id, passed_spam_filter = True) # Bypass spam filter because they are logged in.

### @export "add_note"
def add_note(request_id, text, user_id = None, passed_spam_filter = False):
	if not text or text == "" or (not passed_spam_filter):
		return False
	note_id = create_note(request_id = request_id, text = text, user_id = user_id)
	if note_id:
		change_request_status(request_id, "A response has been added.")
		if user_id:
			add_staff_participant(request_id = request_id, user_id = user_id)
			generate_prr_emails(request_id = request_id, notification_type = "City response added")
		else:
			generate_prr_emails(request_id = request_id, notification_type = "Public note added")
		return note_id
	return False



### @export "upload_record"
def upload_record(request_id, description, user_id, document = None):
	""" Creates a record with upload/download attributes """
	try:
		doc_id, filename = scribd_helpers.upload_file(document = document, request_id = request_id)
	except:
		return "The upload timed out, please try again."
	if doc_id == False:
		return "Extension type '%s' is not allowed." % filename
	else:
		if str(doc_id).isdigit():
			record_id = create_record(doc_id = doc_id, request_id = request_id, user_id = user_id, description = description, filename = filename, url = app.config['HOST_URL'] + doc_id)
			change_request_status(request_id, "A response has been added.")
			generate_prr_emails(request_id = request_id, notification_type = "City response added")
			add_staff_participant(request_id = request_id, user_id = user_id)
			return record_id
	return "There was an issue with your upload."

### @export "add_offline_record"
def add_offline_record(request_id, description, access, user_id):
	""" Creates a record with offline attributes """
	record_id = create_record(request_id = request_id, user_id = user_id, access = access, description = description) # To create an offline record, we need to know the request ID to which it will be added, the user ID for the person adding the record, how it can be accessed, and a description/title of the record.
	if record_id:
		change_request_status(request_id, "A response has been added.")
		generate_prr_emails(request_id = request_id, notification_type = "City response added")
		add_staff_participant(request_id = request_id, user_id = user_id)
		return record_id
	return False

### @export "add_link"
def add_link(request_id, url, description, user_id):
	""" Creates a record with link attributes """
	record_id = create_record(url = url, request_id = request_id, user_id = user_id, description = description)
	if record_id:
		change_request_status(request_id, "A response has been added.")
		generate_prr_emails(request_id = request_id, notification_type = "City response added")
		add_staff_participant(request_id = request_id, user_id = user_id)
		return record_id
	return False

### @export "make_request"			
def make_request(text, email = None, user_id = None, phone = None, alias = None, department = None, passed_spam_filter = False, offline_submission_type = None, date_received = None):
	""" Make the request. At minimum you need to communicate which record(s) you want, probably with some text."""
	if not passed_spam_filter: 
		return None, False
	request_id = find_request(text)
	if request_id: # Same request already exists
		return request_id, False
	assigned_to_email = app.config['DEFAULT_OWNER_EMAIL']
	assigned_to_reason = app.config['DEFAULT_OWNER_REASON']
	if department:
		app.logger.info("\n\nDepartment chosen: %s" %department)
		prr_email = db_helpers.get_contact_by_dept(department)
		if prr_email:
			assigned_to_email = prr_email
			assigned_to_reason = "PRR Liaison for %s" %(department)
		else:
			app.logger.info("%s is not a valid department" %(department))
			department = None
	request_id = create_request(text = text, user_id = user_id, offline_submission_type = offline_submission_type, date_received = date_received) # Actually create the Request object
	new_owner_id = assign_owner(request_id = request_id, reason = assigned_to_reason, email = assigned_to_email) # Assign someone to the request
	open_request(request_id) # Set the status of the incoming request to "Open"
	if email or alias or phone:
		subscriber_user_id = create_or_return_user(email = email, alias = alias, phone = phone)
		subscriber_id, is_new_subscriber = create_subscriber(request_id = request_id, user_id = subscriber_user_id)
		if subscriber_id:
			generate_prr_emails(request_id, notification_type = "Request made", user_id = subscriber_user_id) # Send them an e-mail notification
	return request_id, True

### @export "add_subscriber"	
def add_subscriber(request_id, email):
	user_id = create_or_return_user(email = email)
	subscriber_id, is_new_subscriber = create_subscriber(request_id = request_id, user_id = user_id)
	if subscriber_id:
		generate_prr_emails(request_id, notification_type = "Request followed", user_id = user_id)
		return subscriber_id
	return False

### @export "ask_a_question"	
def ask_a_question(request_id, user_id, question):
	""" City staff can ask a question about a request they are confused about."""
	req = get_obj("Request", request_id)
	qa_id = create_QA(request_id = request_id, question = question, user_id = user_id)
	if qa_id:
		change_request_status(request_id, "Pending")
		requester = req.requester()
		if requester:
			generate_prr_emails(request_id, notification_type = "Question asked", user_id = requester.user_id)
		add_staff_participant(request_id = request_id, user_id = user_id)
		return qa_id
	return False

### @export "answer_a_question"
def answer_a_question(qa_id, answer, subscriber_id = None, passed_spam_filter = False):
	""" A requester can answer a question city staff asked them about their request."""
	if (not answer) or (answer == "") or (not passed_spam_filter):
		return False
	else:
		request_id = create_answer(qa_id, subscriber_id, answer)
		# We aren't changing the request status if someone's answered a question anymore, but we could change_request_status(request_id, "Pending")
		generate_prr_emails(request_id = request_id, notification_type = "Question answered")
		return True

### @export "open_request"	
def open_request(request_id):
	change_request_status(request_id, "Open")

### @export "assign_owner"	
def assign_owner(request_id, reason, email = None): 
	""" Called any time a new owner is assigned. This will overwrite the current owner."""
	req = get_obj("Request", request_id)
	past_owner_id = None
	# If there is already an owner, unassign them:
	if req.point_person():
		past_owner_id = req.point_person().id
		past_owner = get_obj("Owner", req.point_person().id)
		update_obj(attribute = "is_point_person", val = False, obj = past_owner)
	owner_id, is_new_owner = add_staff_participant(request_id = request_id, reason = reason, email = email, is_point_person = True)
	if (past_owner_id == owner_id): # Already the current owner, so don't send any e-mails
		return owner_id

	app.logger.info("\n\nA new owner has been assigned: Owner: %s" % owner_id)
	new_owner = get_obj("Owner", owner_id)	
	# Update the associated department on request
	update_obj(attribute = "department_id", val = new_owner.user.department, obj = req)
	user_id = get_attribute(attribute = "user_id", obj_id = owner_id, obj_type = "Owner")
	# Send notifications
	if is_new_owner:
		generate_prr_emails(request_id = request_id, notification_type = "Request assigned", user_id = user_id)
	return owner_id

### @export "get_request_data_chronologically"
def get_request_data_chronologically(req):
	public = False
	if current_user.is_anonymous():
		public = True
	responses = []
	if not req:
		return responses
	for i, note in enumerate(req.notes):
		if not note.user_id:
			responses.append(RequestPresenter(note = note, index = i, public = public, request = req))
	for i, qa in enumerate(req.qas):
		responses.append(RequestPresenter(qa = qa, index = i, public = public, request = req))
	if not responses:
		return responses
	responses.sort(key = lambda x:x.date(), reverse = True)
	return responses

### @export "get_responses_chronologically"
def get_responses_chronologically(req):
	responses = []
	if not req:
		return responses
	for note in req.notes:
		if note.user_id:
			responses.append(ResponsePresenter(note = note))
	for record in req.records:
		responses.append(ResponsePresenter(record = record))
	if not responses:
		return responses
	responses.sort(key = lambda x:x.date(), reverse = True)
	if "Closed" in req.status:
		responses[0].set_icon("icon-archive") # Set most recent note (closed note)'s icon
	return responses

### @export "set_directory_fields"
def set_directory_fields():
	# Set basic user data
	if 'STAFF_URL' in app.config:
		# This gets run at regular internals via db_users.py in order to keep the staff user list up to date. Before users are added/updated, ALL users get reset to 'inactive', and then only the ones in the current CSV are set to active. 
		for user in User.query.filter(User.is_staff == True).all():
			update_user(user = user, is_staff = False)
		csvfile = urllib.urlopen(app.config['STAFF_URL'])
		dictreader = csv.DictReader(csvfile, delimiter=',')
		for row in dictreader:
			create_or_return_user(email = row['email'].lower(), alias = row['name'], phone = row['phone number'], department = row['department name'], is_staff = True)
		# Set liaisons data (who is a PRR liaison for what department)
		if 'LIAISONS_URL' in app.config:
			csvfile = urllib.urlopen(app.config['LIAISONS_URL'])
			dictreader = csv.DictReader(csvfile, delimiter=',')
			for row in dictreader:
				user = create_or_return_user(email = row['PRR liaison'], contact_for = row['department name'])
				if row['PRR backup'] != "":
					user = create_or_return_user(email = row['PRR backup'], backup_for = row['department name'])
		else:
			app.logger.info("\n\n Please update the config variable LIAISONS_URL for where to find department liaison data for your agency.")
	else:
		app.logger.info("\n\n Please update the config variable STAFF_URL for where to find csv data on the users in your agency.") 
		if 'DEFAULT_OWNER_EMAIL' in app.config and 'DEFAULT_OWNER_REASON' in app.config:
			create_or_return_user(email = app.config['DEFAULT_OWNER_EMAIL'].lower(), alias = app.config['DEFAULT_OWNER_EMAIL'], department = app.config['DEFAULT_OWNER_REASON'], is_staff = True)
			app.logger.info("\n\n Creating a single user from DEFAULT_OWNER_EMAIL and DEFAULT_OWNER_REASON for now. You may log in with %s" %(app.config['DEFAULT_OWNER_EMAIL']))
		else:
			app.logger.info("\n\n Unable to create any users. No one will be able to log in.")



### @export "close_request"
def close_request(request_id, reason = "", user_id = None):
	req = get_obj("Request", request_id)
	change_request_status(request_id, "Closed")
	# Create a note to capture closed information:
	create_note(request_id, reason, user_id)
	generate_prr_emails(request_id = request_id, notification_type = "Request closed")
	add_staff_participant(request_id = request_id, user_id = user_id)

RequestPresenter.py

"""
    public_records_portal.RequestPresenter
    ~~~~~~~~~~~~~~~~

    Returns the html needed for the 'Request' portion of the case page.

"""


from public_records_portal import models
from models import Note, QA
from db_helpers import get_obj

class RequestPresenter:
	def __init__(self, request, qa = None, note = None, index = None, public = False):
		self.index = index
		self.public = public
		self.request = request
		if qa:
			self.response = qa
			self.type = "qa"
			self.uid = self.response.owner_id
			self.staff = get_obj("User", self.uid)
			self.staff_email = "N/A"
			self.staff_department = "N/A"
			self.staff_phone = "N/A"
			self.staff_alias = "N/A"
			if self.staff:
				if self.staff.email:
					self.staff_email = self.staff.email
				if self.staff.department:
					self.staff_department = self.staff.department
				if self.staff.phone:
					self.staff_phone = self.staff.phone
				if self.staff.alias:
					self.staff_alias = self.staff.alias
			directory_popover = "directoryPopover('%s', '%s', '%s', '#contactinfoPopoverQA%s')" %(self.staff_email, self.staff_department, self.staff_phone, index)
			self.owner_link = '<a href="/staff_card/%s" data-placement="top" data-toggle="popover" href="#" id="contactinfoPopoverQA%s" class="hidden-phone hidden-tablet"><span class="contactinfoPopover" onmouseover="%s">%s</span></a>' % (self.response.owner_id, index, directory_popover, self.staff_alias or self.staff_email)
			self.icon = "icon-question icon-large"
		if note:
			self.response = note
			self.type = "note"
			self.icon = "icon-edit icon-large"
	
	def get_id(self):
		return self.response.id

	def display_text(self):
		if self.type == "qa":
			text = "%s - %s" %(self.response.question, self.owner_link)
			if self.response.answer:
				text = text + "<p>%s - <span class='requester'>Requester</span></p>" %(self.response.answer)
			else:
				if self.request.is_closed():
					text = text + "<i><p>No response from requester</p></i>"
				else:
					if self.public:
						text = text + """
						<form name='respond_question' class='form-inline' id='answer' method='post' action='/update_a_qa' autocomplete='on'>
							<label class='control-label'>Answer</label><input type='hidden' name='qa_id' value='%s'/><input type='hidden' name='request_id' value='%s'/>
							<textarea id='answerTextarea' name='answer_text' class='input-xlarge' rows="2" type='text' rows='1' placeholder='Can you respond to the above question?' required/></textarea>
							<button id='askQuestion' class='btn btn-primary' type='submit'>Respond</button>
						</form> 
						""" % (self.response.id, self.request.id)
					else:
						text = text + "<p>Requester hasn't answered yet.</p>"
			return text
		elif self.type == "note":
			return "%s - Requester" %(self.response.text)
		
	def get_icon(self):
		return self.icon

	def set_icon(self, icon):
		self.icon = icon

	def date(self):
		return self.response.date_created