def check(request, enc, ppt_import_request_id):
ppt_import_request = models.PptImportRequest.objects.get(id=ppt_import_request_id)
if ppt_import_request.status_code == models.StatusCode.DONE:
return data_response.create(enc, 'ok', {"status_code": "1"})
elif ppt_import_request.status_code == models.StatusCode.ERROR:
return data_response.create(enc, 'ok', {"status_code": "-1"})
else:
return data_response.create(enc, 'ok', {"status_code": "0"})
def save_custom_page(request, enc, flowgram, content):
page_id = request.POST.get('page_id', '')
page = models.Page.objects.get(id=page_id) if page_id else None
user = flowgram.owner
if page:
# If editing an existing page.
# Checking to make sure the page belongs to the specified Flowgram.
if not page.flowgram == flowgram:
return error_response.create(
enc,
'The specified page does not belong to the specified Flowgram.')
html = render_to_string('blankpages/view.html', {'html': content,
'user': user})
controller.set_page_contents(page, html, sethl=True)
# This try..except block is used for legacy support (previous versions did not save a
# separate CustomPage object).
try:
custom_page = models.CustomPage.objects.get(page=page)
custom_page.content = content
custom_page.save()
except models.CustomPage.DoesNotExist:
models.CustomPage.objects.create(page=page, content=content)
controller.make_thumbnail(page)
return data_response.create(enc, 'ok', encode.page.to_dict(page))
else:
# If creating a new page.
html = render_to_string('blankpages/view.html', {'html': content,
'user': user})
title = "%s's custom Flowgram page" % user
page = models.Page.objects.create(title=title, source_url='')
page = controller.create_page_to_flowgram(flowgram, page, html)
page.source_url = '%sapi/getpage/%s/' % (localsettings.my_URL_BASE, page.id)
page.is_custom = True
page.save()
models.CustomPage.objects.create(page=page, content=content)
return data_response.create(enc, 'ok', encode.page.to_dict(page))
def get_comments_paginated(request, enc, flowgram, page_size, page_number, last_comment_id):
"""Gets the comments for a Flowgram, paginated. Optional parameters: page_number (starts at 1)
and last_comment_id (the ID of the last comment already received for this Flowgram) are
mutually exclusive."""
comments = models.Comment.objects.filter(flowgram=flowgram).order_by('-created_at')
num_comments = comments.count()
if page_number >= 0:
# If page_number is specifed (where page 1 is the earliest comments).
comments = comments[min(0, num_comments - page_size * page_number):\
num_comments - page_size * (page_number - 1)]
elif last_comment_id:
# If last_comment_id is specified, returning only comments after the last comment.
last_comment = comments.get(id=last_comment_id)
comments = comments.filter(created_at__gt=last_comment.created_at)[:page_size]
else:
# If neither page_number or last_comment_id are specified, return the most recent page.
comments = comments[:page_size]
return data_response.create(
enc,
'ok',
{
'num_comments': num_comments,
'comments': [encode.comment.to_dict(comment) for comment in comments]
})
def get_fg(request, flowgram, working_flowgram):
if working_flowgram:
controller.set_working_flowgram(request.user, flowgram)
return data_response.create(request.GET.get('enc', 'json'),
'ok',
encode.flowgram_encoder.to_dict(flowgram, True, request.user))
def check_all(request, apr_ids, etvr_ids, imr_ids, page_ids, ppt_ids, thumb_page_ids):
(aprs_done, aprs_failed) = check_add_page_requests(apr_ids)
(etvrs_done, etvrs_failed) = check_export_to_video_requests(etvr_ids)
(imrs_done, imrs_failed) = check_import_media_requests(imr_ids)
(pages_done, pages_failed) = check_pages(page_ids)
(ppts_done, ppts_failed) = check_ppt(ppt_ids, request.POST.get('flowgram_id', None))
(thumbs_done, thumbs_failed) = check_thumbs(thumb_page_ids)
return data_response.create(
request.POST.get('enc', 'json'),
'ok',
{
'aprs_done': aprs_done,
'aprs_failed': aprs_failed,
'etvrs_done': etvrs_done,
'etvrs_failed': etvrs_failed,
'imrs_done': imrs_done,
'imrs_failed': imrs_failed,
'pages_done': pages_done,
'pages_failed': pages_failed,
'ppts_done': ppts_done,
'ppts_failed': ppts_failed,
'thumbs_done' : thumbs_done,
'thumbs_failed' : thumbs_failed,
})
def my_logout(request):
controller.record_stat(request, 'view_logout_website', '0', '')
auth.logout(request)
if request.GET.get('redirect', 'true').lower() == 'true':
return helpers.go_back(request)
else:
return data_response.create(request.POST.get('enc', 'json'), 'ok', {})
def export_to_video(request, enc, flowgram, use_highlight_popups, request_email):
etvr = models.ExportToVideoRequest.objects.create(
flowgram=flowgram,
use_highlight_popups=use_highlight_popups,
request_user=request.user if request.user.is_authenticated() else ANONYMOUS_USER_OBJECT,
request_email=request_email)
return data_response.create(enc, 'ok', etvr.id)
def add_feedback(request, enc, url, email, sysinfo, comments):
from flowgram.core.mail import announce_feedback
feedback = models.Feedback.objects.create(url=url, email=email, sys_info=sysinfo, comments=comments)
announce_feedback(feedback)
return data_response.create(enc, 'ok', {})
def queue_add_url(request, enc, url, flowgram):
if not url.startswith('http://') and not url.startswith('https://'):
url = 'http://' + url
match = GALLERY_ME_COM_REGEX.match(url)
if match:
(username, gallery, file) = match.groups(0)
title = 'MobileMe Gallery - %s' % file
link = 'http://gallery.me.com/%s/%s/%s/web.jpg' % (username, gallery, file)
html = '<html><head><title>%s</title><style>@import url("/media/css/photo_importers.css");</style></head><body><img src="%s" /></body></html>' % \
(title, link)
page = models.Page.objects.create(title=title, source_url=link)
page = controller.create_page_to_flowgram(flowgram, page, html)
aprId = '-1'
else:
page = models.Page.objects.create(flowgram=flowgram,
owner=request.user,
source_url=url,
position=controller.get_next_position(flowgram))
aprId = models.AddPageRequest.objects.create(flowgram=flowgram, url=url, page=page).id
return data_response.create(enc, 'ok', {'ready': 0,
'error': 0,
'results': encode.page.to_dict(page),
'request_id': aprId})
def require(method, required_args=[], permissions=[]):
def check(func):
@wraps(func)
def wrapper_func(request, *args, **kwargs):
method_args = request.GET if request.method == 'GET' else request.POST
default_enc = 'json'
parsed_required_args = []
for required_arg in required_args:
(required_arg, type, default_value) = parse_required_arg(required_arg)
parsed_required_args.append([required_arg, type, default_value])
if required_arg == 'enc':
default_enc = default_value
enc = method_args.get('enc', default_enc)
# Checking method.
if method and request.method != method:
return error_response.create(enc, '%s method not allowed.' % request.method)
transformed_values = {}
try:
# Checking required arguments.
for (required_arg, type, default_value) in parsed_required_args:
if default_value == None and \
not required_arg in method_args and \
not required_arg in kwargs:
return error_response.create(enc, 'Missing required field %s.' % required_arg)
try:
value = method_args.get(required_arg, kwargs.get(required_arg, default_value))
new_name = required_arg
if type in transformers.transform_funcs:
(new_name, value) = transformers.transform_funcs[type](request, value)
if required_arg in transformers.transform_funcs:
(new_name, value) = \
transformers.transform_funcs[required_arg](request, value)
args += (value,)
transformed_values[new_name or required_arg] = value
except transformers.TransformError, (errMessage):
return error_response.create(enc, str(errMessage))
# Checking permissions
for permission in permissions:
if not permissionscheckers.permission_funcs[permission](request,
method_args,
transformed_values):
return error_response.create(enc, 'Does not have %s permission.' % permission \
if localsettings.DEBUG \
else 'Permission violation')
except RedirectException, e:
return HttpResponseRedirect(e.url)
kwargs = {}
return func(request, *args, **kwargs) or data_response.create(enc, 'ok', {})
def create_flowgram(request, title):
flowgram = controller.new_flowgram(request.user, title)
controller.set_working_flowgram(request.user, flowgram)
log.debug("Action log: create_flowgram %s for %s" % (flowgram.id, request.user.username))
return data_response.create(request.POST.get('enc', 'json'),
'ok',
encode.flowgram_encoder.to_dict(flowgram, True, request.user))
def get_fgs_paginated(request, page_size, page_number):
flowgrams = models.Flowgram.objects.filter(owner=request.user)
num_flowgrams = flowgrams.count()
flowgrams = flowgrams.order_by('-created_at')
flowgrams = flowgrams[(page_number - 1) * page_size:page_number * page_size]
flowgrams = [encode.flowgram_encoder.to_dict(flowgram, False, request.user) \
for flowgram in flowgrams]
return data_response.create(request.GET.get('enc', 'json'),
'ok',
{'num_flowgrams': num_flowgrams,
'flowgrams': flowgrams})
def send_editbar_done_email(request, enc, flowgram):
from flowgram.core.mail import toolbar_done
toolbar_done(flowgram, request.user)
log.action('flowgram %s done by %s ' % (flowgram.id, request.user.username))
return data_response.create(
enc,
'ok',
{
'user': request.user.username,
'flowgram': flowgram.title,
})
def get_app_init_data(request, enc):
from flowgram.core.helpers import get_post_token_value
if request.user.is_authenticated():
return data_response.create(
enc,
'ok',
{
'username': request.user.username,
'post_token': get_post_token_value(request),
'session_id': request.COOKIES[settings.SESSION_COOKIE_NAME]
})
else:
set_cookie_needed = False
if not request.COOKIES.has_key(settings.SESSION_COOKIE_NAME):
request.session.save()
request.COOKIES[settings.SESSION_COOKIE_NAME] = request.session.session_key
set_cookie_needed = True
response = data_response.create(
enc,
'ok',
{
'username': '',
'post_token': get_post_token_value(request),
})
if set_cookie_needed:
response.set_cookie(settings.SESSION_COOKIE_NAME,
request.session.session_key,
max_age=None,
expires=None,
domain=settings.SESSION_COOKIE_DOMAIN,
path=settings.SESSION_COOKIE_PATH,
secure=settings.SESSION_COOKIE_SECURE or None)
return response
def add_audio_fms(request, page, time, duration):
file_path = '%s/%s/%s/%d.flv' % (localsettings.FMS_STREAM_DIR, page.flowgram.id, page.id, time)
if os.path.isfile(file_path):
audio = models.Audio.objects.create(page=page, time=time, duration=duration)
audio.path = file_path
helpers.set_modified(page.flowgram)
s3.save_filename_to_bucket(localsettings.S3_BUCKET_AUDIO, '%s.flv' % audio.id, file_path)
return data_response.create(request.POST.get('enc', 'json'), 'ok', audio.id)
else:
log.debug('add_audio_fms called with page.id=%s, time=%d, and duration=%d but file_path=%s DNE' % \
(page.id, time, duration, file_path))
return error_response.create(request.POST.get('enc', 'json'), 'flv does not exist.')
def handle_file_upload_media(enc, content, content_type, filetype, filename, flowgram_or_page):
temp_media_path = tempfile.mkstemp('.media')
os.close(temp_media_path[0])
file = open(temp_media_path[1], "wb")
file.write(content)
file.close()
os.chmod(temp_media_path[1], 0640)
extension = filename[filename.rfind('.') + 1:].lower()
content_type = EXTENSION_TO_CONTENT_TYPE[extension]
kwargs = {'path': temp_media_path[1],
'content_type': content_type}
kwargs['page' if isinstance(flowgram_or_page, models.Page) else 'flowgram'] = flowgram_or_page
import_media_request = models.ImportMediaRequest.objects.create(**kwargs)
return data_response.create(enc, 'ok', import_media_request.id)
def ajax_login(request, enc, user, password, remember):
from django.contrib import auth
from flowgram.core.helpers import get_post_token_value
username = user.username
user = auth.authenticate(username=username, password=password)
assert(user)
auth.login(request, user)
request.session[settings.PERSISTENT_SESSION_KEY] = remember
return data_response.create(
enc,
'ok',
{
'username': username,
'post_token': get_post_token_value(request),
'session_id': request.COOKIES[settings.SESSION_COOKIE_NAME]
})
def upload(request, enc):
if request.FILES.has_key('file'):
# do later in queue once per slide
# adds a page to the fg
# html will be like before but embed a swf that is centered
# page = Page.objects.create(title=request.FILES['file']['filename'], position=255)
# page = controller.create_page_to_flowgram(fg, page, html)
(fg, new) = controller.get_working_flowgram(request.user)
if new:
log.debug("Action log: new working flowgram %s created during add_page" % fg.id)
# create queue item
ppt_import_request = models.PptImportRequest.objects.create(flowgram=fg)
# 2. Send to S3
ppt_import_request.save_ppt_to_s3(request.FILES['file']['content'])
return data_response.create(enc, 'ok', ppt_import_request.id)
else:
return error_response.create(enc, 'No file was uploaded.')
def add_comment(request, enc, flowgram, text):
if not text:
# TODO(westphal): Drop support for XML.
if enc == 'xml':
return HttpResponse('No comment text')
else:
return error_response.create(enc, 'No comment text')
comment = models.Comment.objects.create(
owner=request.user if request.user.is_authenticated() else None,
flowgram=flowgram,
text=text)
controller.record_stat(request, 'add_comment_website', '0', comment.id)
if localsettings.FEATURE['notify_fw']:
controller.store_fgcomented_event({'commentor': request.user,
'fg_id': flowgram.id,
'eventCode': 'FG_COMMENTED'})
# TODO(westphal): Drop support for XML.
if enc == 'xml':
return HttpResponse(helpers.render_comment_to_xml(comment), mimetype="text/xml")
else:
return data_response.create(enc, 'ok', encode.comment.to_dict(comment))
def get_more_fgs_paginated(request, page_size, page_number, type):
if type == 'related':
flowgram_id = request.GET.get('flowgram_id')
flowgram = models.Flowgram.objects.get(id=flowgram_id)
flowgrams = get_related_flowgrams(flowgram, request)
elif type == 'featured':
flowgrams = get_featured_flowgrams()
elif type == 'mostpopular':
flowgrams = get_most_popular_flowgrams()
elif type == 'mostdiscussed':
flowgrams = get_most_discussed_flowgrams()
elif type == 'toprated':
flowgrams = get_top_rated_flowgrams()
else:
raise Http404
num_flowgrams = len(flowgrams)
flowgrams = flowgrams[(page_number - 1) * page_size:page_number * page_size]
flowgrams = [encode.flowgram_encoder.to_dict(flowgram, False, request.user) \
for flowgram in flowgrams]
return data_response.create(request.GET.get('enc', 'json'),
'ok',
{'num_flowgrams': num_flowgrams,
'flowgrams': flowgrams})
def import_rss(flowgram, rss_url, type, options):
if rss_url.startswith("feed://"):
rss_url = "http://" + rss_url[7:]
parsed = feedparser.parse(rss_url)
if not parsed.has_key("status"):
raise Http404
else:
if parsed["status"] == "404":
raise Http404
is_atom = not not parsed["feed"]
if is_atom:
# If ATOM
channelTitle = parsed["feed"].get("title", "")
channelDescription = ""
else:
# If RSS
channelTitle = parsed.channel.title
channelDescription = parsed.channel.description
flowgram_changed = False
if not flowgram.title or flowgram.title.lower() == "untitled":
flowgram.title = channelTitle
flowgram_changed = True
if not flowgram.description:
flowgram.description = channelDescription
flowgram_changed = True
if flowgram_changed:
flowgram.save()
pages = []
items = parsed["items"]
if options["max_results"]:
max_results = options["max_results"]
items = items[:max_results]
if type == "linkedarticles" or type == "articlesummaries":
required_keys = ["title", "link", "description"]
for item in items:
for rkey in required_keys:
if not item.has_key("title"):
title = ""
elif item.has_key("title"):
title = item.title
if not item.has_key("link"):
link = ""
elif item.has_key("link"):
link = item.link
if not item.has_key("description"):
description = ""
elif item.has_key("description"):
description = item.description
# need to check whether the 'title,link,description' attribute exists
if type == "linkedarticles":
page = Page.objects.create(
flowgram=flowgram,
owner=flowgram.owner,
title=title,
source_url=link,
position=controller.get_next_position(flowgram),
)
controller.add_default_time(page)
AddPageRequest.objects.create(flowgram=flowgram, url=link, page=page)
pages.append(encode.page.to_dict(page))
elif type == "articlesummaries":
# Create and save the page:
page = Page.objects.create(title=title, source_url=link)
page.save()
context = Context({"title": title, "url": link, "description": remove_script_tags(description)})
template = loader.get_template("importers/rss.html")
html = "%s" % template.render(context)
page = controller.create_page_to_flowgram(flowgram, page, html)
pages.append(encode.page.to_dict(page))
elif type == "singlesummarypage":
# Create and save the page:
page = Page.objects.create(title=channelTitle, source_url=rss_url)
page.save()
context = Context({"title": channelTitle, "items": items})
template = loader.get_template("importers/rss_singlesummarypage.html")
html = "%s" % template.render(context)
page = controller.create_page_to_flowgram(flowgram, page, html)
pages.append(encode.page.to_dict(page))
if len(pages) == 0:
raise Http404
return data_response.create(options.get("enc", "json"), "ok", pages)
def handle_file_upload_image(enc, content, content_type, filetype, filename, flowgram):
temp_image = tempfile.mkstemp(".image")
os.close(temp_image[0])
temp_image_path = temp_image[1]
try:
file = open(temp_image_path, "wb")
file.write(content)
file.close()
try:
# Opens the file to make sure it works as an image.
image = Image.open(temp_image_path)
image.load()
except:
return error_response.create(
enc,
'Invalid image: Currently supported image types include: JPEG, PNG, and GIF')
(mime, extension) = IMAGE_FORMAT_TO_MIME_AND_EXTENSION[image.format]
# Resizing the image if too large.
if image.size[0] > settings.DEFAULT_PHOTO_WIDTH or \
image.size[1] > settings.DEFAULT_PHOTO_HEIGHT:
image.thumbnail((settings.DEFAULT_PHOTO_WIDTH, settings.DEFAULT_PHOTO_HEIGHT),
Image.BICUBIC)
page = models.Page.objects.create(title=filename)
uploaded_file = models.UploadedFile.objects.create(page=page, mimetype=mime, media_type=0)
page.source_url = uploaded_file.get_absolute_url()
html = ''.join(['<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"><html><head><title></title>',
'<link rel="stylesheet" type="text/css" href="',
localsettings.MEDIA_URL,
'css/photo_importers.css">',
'<link rel="stylesheet" type="text/css" href="',
localsettings.MEDIA_URL,
'css/page.css"></head><body><div><img src="',
uploaded_file.get_absolute_url(),
'" /></div></body></html>'])
# Saving the thumbnailed image and reading the data.
try:
temp_image_final = tempfile.mkstemp(extension)
os.close(temp_image_final[0])
temp_image_final_path = temp_image_final[1]
image.save(temp_image_final_path)
file = open(temp_image_final_path, "rb")
data = file.read()
file.close()
finally:
os.remove(temp_image_final_path)
uploaded_file.set_file(data)
page = controller.create_page_to_flowgram(flowgram, page, html)
return data_response.create(enc, 'ok', encode.page.to_dict(page))
finally:
os.remove(temp_image_path)
def handle_file_upload_doc(enc, content, content_type, filetype, filename, flowgram):
ppt_import_request = models.PptImportRequest.objects.create(flowgram=flowgram, filetype=filetype)
ppt_import_request.save_ppt_to_s3(content)
return data_response.create(enc, 'ok', ppt_import_request.id)
def create(enc, message):
from flowgram.core.response import data_response
# The template field is only used for enc=html.
return data_response.create(enc, 'error', {'template': '500.html',
'message': message})
def create(enc, status, form):
from flowgram.core.response import data_response
output = dict((field, errors) for field, errors in form.errors.iteritems())
return data_response.create(enc, 'error', output)
def save_as(request, flowgram, title, enc):
new_fg = controller.copy_flowgram(request.user, flowgram)
new_fg.title = title
new_fg.save()
return data_response.create(enc, 'ok', new_fg.id)
def get_working_fg(request):
enc = helpers.get(request, 'enc', 'json')
if not request.user.is_authenticated():
return error_response.create(enc, 'Login required')
return data_response.create(enc, 'ok', controller.get_working_flowgram(request.user)[0].id)
def get_favorite_fgs_paginated(request, page_size, page_number):
favorites_dict = controller.get_favorite_fgs_paginated(request.user, page_size, page_number)
favorites_dict['flowgrams'] = [encode.flowgram_encoder.to_dict(flowgram, False, request.user) \
for flowgram in favorites_dict['flowgrams']]
return data_response.create(request.GET.get('enc', 'json'), 'ok', favorites_dict)
