예제 #1
0
파일: views.py 프로젝트: advatar/thevault
    def do_app_settings():
        """
        Update application settings
        """
        from flask import request, flash, redirect

        preference = get_settings("global")
        new_preference = AppSettingsForm(request.form)
        preference["run_at_startup"] = new_preference.run_at_startup.data

        backup_dir = new_preference.backup_dir.data

        home_dir = get_home_dir()
        logger.debug("home dir is: %r", home_dir)
        logger.debug("backup dir is: %r", backup_dir)
        if not backup_dir.startswith(home_dir):
            flash("Invalid Backup Directory path", "error")
            return redirect(url_for(".app_settings"))

        preference["backup_dir"] = backup_dir

        need_restart = False
        if not is_same_path(BACKUP_DIR, backup_dir):
            move_backup_dir(backup_dir)
            need_restart = True

        save_settings("global", preference)
        run_at_startup(preference["run_at_startup"])
        save_config("backup_dir", backup_dir)
        flash("Application settings updated!")
        if need_restart:
            return redirect(url_for(".restarting"))
        return redirect(url_for(".app_settings"))
예제 #2
0
파일: views.py 프로젝트: advatar/thevault
def do_preferences():
    preference = get_settings("facebook_app")

    if not preference:
        logger.debug('no preference found. redirecting to setup')
        return redirect(url_for('setup'))

    schedule_form = ScheduleForm(request.form, prefix='schedule')
    settings_form = SettingsForm(request.form, prefix='settings')

    preference['settings'] = {
        'statuses': settings_form.statuses.data,
        'events': settings_form.events.data,
        'albums': settings_form.albums.data,
        'notes': settings_form.notes.data,
        'links': settings_form.links.data,
        'friends': settings_form.friends.data,
        'photos': settings_form.photos.data}

    preference['schedule'] = {
        'interval': schedule_form.interval.data,
        'dayofmonth': schedule_form.dayofmonth.data,
        'dayofweek': schedule_form.dayofweek.data,
        'timeofday': schedule_form.timeofday.data,
        'hourofday': schedule_form.hourofday.data,
        'minuteofhour': schedule_form.minuteofhour.data,
        'ampm': schedule_form.ampm.data}

    save_settings("facebook_app", preference)
    reload_schedules() 
    flash("Facebook settings updated.")
    return redirect(url_for("preferences"))
예제 #3
0
파일: views.py 프로젝트: advatar/thevault
 def app_settings():
     """
     Show the application settings page.
     """
     preference = get_settings("global")
     if not preference.has_key("backup_dir") or not preference["backup_dir"]:
         preference["backup_dir"] = BACKUP_DIR
     form = AppSettingsForm(**preference)
     return render_template("settings.html", form=form)
예제 #4
0
파일: views.py 프로젝트: advatar/thevault
def setup_link():
    try:
        settings = get_settings('facebook_app')

        if settings:
            return render_template("facebook_app/manage_link.html")
        else:
            return render_template("facebook_app/setup_link.html")
    except Exception, e:
        logger.debug("%r", e)
예제 #5
0
파일: views.py 프로젝트: advatar/thevault
def setup_link():
    try:
        settings = get_settings('google_contacts_app')

        if settings:
            return render_template('google_contacts_app/manage_link.html')
        else:
            return render_template('google_contacts_app/setup_link.html')
    except Exception, e:
        logger.debug('%r', e)
        return ""
예제 #6
0
파일: views.py 프로젝트: advatar/thevault
def preferences():
    preference = get_settings('picasaweb_app')

    if not preference:
        logger.debug('no preference found. redirecting to setup')
        return redirect(url_for('setup'))

    schedule_form = ScheduleForm(prefix='schedule', **preference['schedule'])

    return render_template('picasaweb_app/preferences.html',
            schedule_form=schedule_form,
            profile=preference['profile'])
예제 #7
0
파일: views.py 프로젝트: advatar/thevault
def setup_link():
    try:
        settings = get_settings('picasaweb_app')

        if settings:
            return render_template('picasaweb_app/manage_link.html')
        else:
            return render_template('picasaweb_app/setup_link.html')

    except Exception, e:
        logger.debug("error in setup_link view: %r", e)
        return ""
예제 #8
0
파일: views.py 프로젝트: advatar/thevault
def archives():
    page, per_page = get_pagination_params(request)
    profile = get_settings("google_contacts_app")

    if not profile:
        logger.debug("no profile found. google_contacts_app was not setup")
        return redirect(url_for('preferences'))

    archives = get_paginated_archives("google_contacts_app", page, per_page)

    return render_template("google_contacts_app/archives.html",
            archives=archives,
            profile=profile['profile'])
예제 #9
0
파일: views.py 프로젝트: advatar/thevault
def archives():
    page, per_page = get_pagination_params(request) 
    profile = get_settings("facebook_app")

    if not profile:
        logger.debug('no archive found. facebook_app is not set up')
        return redirect(url_for("preferences"))
    
    archives = get_paginated_archives("facebook_app", page, per_page)

    return render_template("facebook_app/archives.html",
            archives=archives,
            profile=profile['profile'])
예제 #10
0
파일: views.py 프로젝트: advatar/thevault
def archives():
    page, per_page = get_pagination_params(request)
    profile = get_settings('picasaweb_app')

    if not profile:
        logger.debug('no profile found. picasaweb was not setup')
        return redirect(url_for('preferences'))

    archives = get_paginated_archives('picasaweb_app', page, per_page)

    return render_template('picasaweb_app/archives.html',
            archives=archives,
            profile=profile['profile'])
예제 #11
0
파일: views.py 프로젝트: advatar/thevault
def archive_albums(archive_id):
    archive = get_archive('picasaweb_app', archive_id)
    data = get_archive_file('picasaweb_app', archive.filename)

    #logger.debug('%r', data['albums'])
    profile = get_settings('picasaweb_app')
    page, per_page = get_pagination_params(request, default_per_page=28)

    albums = Paginator(data['albums'], page=page, per_page=per_page)

    return render_template('picasaweb_app/albums.html',
            albums=albums,
            archive_id=archive.id,
            profile=profile['profile'])
예제 #12
0
파일: views.py 프로젝트: advatar/thevault
    def load_schedules():
        """
        Load schedules from db to kronos scheduler.
        Starts the backup routine for an app module if we missed a schedule.
        """
        logger.debug("in load_schedules")
        modules = app.modules

        for app_name in modules.keys():
            if app_name in ["base", "account"]:
                continue
            logger.debug("loading schedule for %s", app_name)

            settings = get_settings(app_name)
            if not settings:
                continue

            logger.debug("%r", settings["schedule"])

            def callback(app_name):
                try:
                    url = "http://%s:%s/%s/backup" % (HOST, PORT, app_name)
                    progress = get_backup_progress(app_name)

                    if not progress:
                        urllib2.urlopen(url).read()
                except Exception, e:
                    logger.debug("%r", e)

            taskname = "%s" % (app_name)

            add_schedule(taskname, settings["schedule"], callback)
            logger.debug("schedule added")
            today = datetime.datetime.today()

            if not is_online():
                logger.debug("we are offline. skipping backup on boot")
                return make_response("schedule loaded")

            archive = get_recent_archive(app_name)
            if archive:
                logger.debug("there is an archive")
                try:
                    if not backup_is_on_schedule(today, archive.archived_at, settings["schedule"]):
                        logger.debug("we missed a backup schedule. starting backup")
                        KRON.add_single_task(callback, "backup_%s" % app_name, 1, "threaded", [app_name], None)
                    else:
                        logger.debug("we are on schedule")
                except Exception, e:
                    logger.debug("error: %r" % e)
예제 #13
0
파일: views.py 프로젝트: advatar/thevault
def archive(archive_id):
    archive = get_archive('google_contacts_app', archive_id)
    atom_data = get_archive_file("google_contacts_app", archive.filename)

    data = gdata.contacts.ContactsFeedFromString(atom_data.ToString())

    profile = get_settings("google_contacts_app")
    page, per_page = get_pagination_params(request)

    contacts = Paginator(data.entry, page=page, per_page=per_page)

    return render_template("google_contacts_app/archive.html",
            contacts=contacts,
            archive_id=archive_id,
            profile=profile['profile'])
예제 #14
0
파일: views.py 프로젝트: advatar/thevault
def preferences():

    preference = get_settings("facebook_app")

    if not preference:
        logger.debug('no preference found. redirecting to setup')
        return redirect(url_for("setup"))

    schedule_form = ScheduleForm(prefix="schedule", **preference['schedule'])
    settings_form = SettingsForm(prefix="settings", **preference['settings'])

    return render_template("facebook_app/preferences.html",
            schedule_form=schedule_form,
            settings_form=settings_form,
            profile=preference['profile'])
예제 #15
0
파일: views.py 프로젝트: advatar/thevault
def archive_photo(archive_id, photo_id):
    archive = get_archive('facebook_app', archive_id)
    data = get_archive_file('facebook_app', archive.filename)

    page, per_page = get_pagination_params(request, default_per_page=1)

    preference = get_settings('facebook_app')

    photos = sorted(data['photos'], key=itemgetter('created_time'), reverse=True)
    photos = PhotoPaginator(photos, photo_id)

    return render_template('facebook_app/photo.html',
            archive_id=archive_id,
            photos=photos,
            profile=preference['profile'])
예제 #16
0
파일: views.py 프로젝트: advatar/thevault
def archive_album(archive_id, album_id):
    archive = get_archive('facebook_app', archive_id)
    data = get_archive_file("facebook_app", archive.filename)

    page, per_page = get_pagination_params(request, default_per_page=28)
    photos = sorted(data['albums'][album_id]['photos'].values(), key=itemgetter('created_time'), reverse=True)
    photos = Paginator(photos, page, per_page)

    preference = get_settings('facebook_app')

    return render_template("facebook_app/album_photos.html",
            archive_id=archive_id,
            album_id=album_id,
            album=data['albums'][album_id],
            photos=photos,
            profile=preference['profile'])
예제 #17
0
파일: views.py 프로젝트: advatar/thevault
def archive_album(archive_id, album_id):
    archive = get_archive('picasaweb_app', archive_id)
    data = get_archive_file('picasaweb_app', archive.filename)

    profile = get_settings('picasaweb_app')
    page, per_page = get_pagination_params(request, default_per_page=28)
    photos = sorted(data['albums'][album_id]['photos'].values(), key=itemgetter('published'), reverse=True)

    photos = Paginator(photos, page, per_page)

    return render_template('picasaweb_app/album.html',
            archive_id=archive_id,
            album_id=album_id,
            album=data['albums'][album_id],
            photos=photos,
            profile=profile['profile'])
예제 #18
0
파일: views.py 프로젝트: advatar/thevault
def backup():
    if not is_online():
        logger.debug("skipping google contacts backup. we are offline")
        return jsonify({'error': 'offline'})

    logger.debug("running backup for google_contacts_app")

    preference = get_settings("google_contacts_app")

    def make_response(payload):
        response = app.make_response(jsonify(payload))
        response.headers['cache-control'] = 'no-cache'
        return response

    if not preference:
        logger.debug('no preference found.')
        return make_response({'error': 'no preference'})

    backup_time = run_backup(preference)
    logger.debug('done google_contacts backup')

    return jsonify({'backup_time': backup_time.strftime("%Y-%m-%d %H%M")})
예제 #19
0
파일: views.py 프로젝트: advatar/thevault
def do_preferences():
    preference = get_settings('google_contacts_app')

    if not preference:
        logger.debug('no preference found. redirecting to setup')
        return redirect(url_for('setup'))

    schedule_form = ScheduleForm(request.form, prefix='schedule')
    
    preference['schedule'] = {
        'interval': schedule_form.interval.data,
        'dayofmonth': schedule_form.dayofmonth.data,
        'dayofweek': schedule_form.dayofweek.data,
        'timeofday': schedule_form.timeofday.data,
        'hourofday': schedule_form.hourofday.data,
        'minuteofhour': schedule_form.minuteofhour.data,
        'ampm': schedule_form.ampm.data}
    save_settings('google_contacts_app', preference)

    reload_schedules()
    flash("Google Contacts settings updated.")
    return redirect(url_for("preferences"))
예제 #20
0
파일: views.py 프로젝트: advatar/thevault
 def index():
     preference = get_settings("global")
     backup_dir = preference.get("backup_dir", BACKUP_DIR)
     return render_template("index.html", backup_dir=backup_dir)
예제 #21
0
파일: views.py 프로젝트: advatar/thevault
def schedule():
    preference = get_settings('facebook_app') 
    if preference:
        return jsonify(preference.schedule)
    return jsonify({})
예제 #22
0
파일: views.py 프로젝트: advatar/thevault
    elif item == "friends":
        sort_key = "name"
        reverse = False
    elif item == "statuses":
        sort_key = "updated_time"
    elif item == "events":
        sort_key = "start_time"
    elif item == "photos":
        sort_key = "created_time"

    try:
        requested_data = sorted(data[str(item)], key=itemgetter(sort_key), reverse=reverse)
    except KeyError, e:
        requested_data = {}

    profile = get_settings("facebook_app")
    page, per_page = get_pagination_params(request)
    if item == "albums":
        per_page = 28
    return render_template("facebook_app/%s.html" % item,
            **{str(item): Paginator(requested_data, page, per_page),
                "archive_id": archive_id,
                "profile": profile['profile']})


@module.route("/archives/<archive_id>/albums/<album_id>/photos")
def archive_album(archive_id, album_id):
    archive = get_archive('facebook_app', archive_id)
    data = get_archive_file("facebook_app", archive.filename)

    page, per_page = get_pagination_params(request, default_per_page=28)