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"))
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"))
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)
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)
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 ""
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'])
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 ""
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'])
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'])
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'])
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'])
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)
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'])
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'])
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'])
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'])
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'])
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")})
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"))
def index():
preference = get_settings("global")
backup_dir = preference.get("backup_dir", BACKUP_DIR)
return render_template("index.html", backup_dir=backup_dir)
def schedule():
preference = get_settings('facebook_app')
if preference:
return jsonify(preference.schedule)
return jsonify({})
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)
