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)