~ubuntu-branches/ubuntu/saucy/shotwell/saucy-proposed

    _("You are not currently logged into Picasa Web Albums.\n\nClick Login to log into Picasa Web Albums in your Web browser. You will have to authorize Shotwell Connect to link to your Picasa Web Albums account.");

internal const string OAUTH_CLIENT_ID = "1073902228337.apps.googleusercontent.com";

internal const string OAUTH_CLIENT_SECRET = "tcZxcw_HeyUbq4IIuOF1uq8u";

    private bool strip_metadata = false;

    private string username = "[unknown]";

    private Spit.Publishing.Publisher.MediaType media_type =

        Spit.Publishing.Publisher.MediaType.NONE;

        foreach(Spit.Publishing.Publishable p in host.get_publishables())

    internal bool get_persistent_strip_metadata() {

        return host.get_config_bool("strip_metadata", false);

    }

    

    internal void set_persistent_strip_metadata(bool strip_metadata) {

        host.set_config_bool("strip_metadata", strip_metadata);

    }    

    

            session.authenticate(token, "OAuth2");

            session.authenticate(token, "ClientLogin");

                warning("EVENT: couldn't create session for account: %s",

                        e.message);

            warning ("No account authentication data");

            host.post_error(new Spit.Publishing.PublishingError.SERVICE_ERROR(

                "Error while accessing the account"));

            return;

            data.insert("WindowId", (uint)windowId);

        do_fetch_username();

    }

    

    private void on_fetch_username_transaction_completed(Publishing.RESTSupport.Transaction txn) {

        txn.completed.disconnect(on_fetch_username_transaction_completed);

        txn.network_error.disconnect(on_fetch_username_transaction_error);

        

        debug("EVENT: username fetch transaction completed successfully.");

 

        do_extract_username(txn.get_response());

    

    private void on_fetch_username_transaction_error(Publishing.RESTSupport.Transaction txn,

        Spit.Publishing.PublishingError err) {

        txn.completed.disconnect(on_fetch_username_transaction_completed);

        txn.network_error.disconnect(on_fetch_username_transaction_error);

 

        debug("EVENT: username fetch transaction caused a network error");

    }

    private void on_publishing_options_publish(PublishingParameters parameters, 

        bool strip_metadata) {

            

        this.strip_metadata = strip_metadata;

            do_upload(this.strip_metadata);

        do_upload(this.strip_metadata);

    private void do_extract_username(string response_body) {

        debug("ACTION: extracting username from body of server response");

        

        Json.Parser parser = new Json.Parser();

        

        try {

            parser.load_from_data(response_body);

        } catch (Error err) {

            host.post_error(new Spit.Publishing.PublishingError.MALFORMED_RESPONSE(

                "Couldn't parse JSON response: " + err.message));

            return;

        }

        

        Json.Object response_obj = parser.get_root().get_object();

 

        if (response_obj.has_member("name")) {

            string username = response_obj.get_string_member("name");

 

            if (username != "")

                this.username = username;

        }

    }

    

    private void do_fetch_username() {

        debug("ACTION: running network transaction to fetch username.");

 

        host.install_login_wait_pane();

        host.set_service_locked(true);

        

        UsernameFetchTransaction txn = new UsernameFetchTransaction(session);

        txn.completed.connect(on_fetch_username_transaction_completed);

        txn.network_error.connect(on_fetch_username_transaction_error);

        

        try {

            txn.execute();

        } catch (Error err) {

            host.post_error(err);

        }

            // don't just post the error and stop publishing -- 404 errors are recoverable

        Gtk.Builder builder = new Gtk.Builder();

 

        try {

            // the trailing get_path() is required, since add_from_file can't cope

            // with File objects directly and expects a pathname instead.

            builder.add_from_file(

                host.get_module_file().get_parent().

                get_child("picasa_publishing_options_pane.glade").get_path());

        } catch (Error e) {

            warning("Could not parse UI file! Error: %s.", e.message);

            host.post_error(

                new Spit.Publishing.PublishingError.LOCAL_FILE_ERROR(

                    _("A file required for publishing is unavailable. Publishing to Picasa can't continue.")));

            return;

        }

 

        PublishingOptionsPane opts_pane = new PublishingOptionsPane(host, username, albums, media_type, builder,

            get_persistent_strip_metadata());

    private void do_upload(bool strip_metadata) {

        set_persistent_strip_metadata(strip_metadata);        

        

        progress_reporter = host.serialize_publishables(parameters.get_photo_major_axis_size(), 

            strip_metadata);

        do_show_service_welcome_pane();

    public void authenticate(string auth_token, string auth_method) {

                       "GoogleLogin auth=" + session.get_auth_token());

                       "Bearer " + session.get_auth_token());

internal class UsernameFetchTransaction : AuthenticatedTransaction {

    private const string ENDPOINT_URL = "https://www.googleapis.com/oauth2/v1/userinfo";

    

    public UsernameFetchTransaction(Session session) {

        base(session, ENDPOINT_URL, Publishing.RESTSupport.HttpMethod.GET);

    }

}

 

    private const string METADATA_TEMPLATE = "<?xml version=\"1.0\" ?><atom:entry xmlns:atom='http://www.w3.org/2005/Atom' xmlns:mrss='http://search.yahoo.com/mrss/'> <atom:title>%s</atom:title> %s <atom:category scheme='http://schemas.google.com/g/2005#kind' term='http://schemas.google.com/photos/2007#photo'/> %s </atom:entry>";

 

            summary = "<atom:summary>%s</atom:summary>".printf(

        string[] keywords = publishable.get_publishing_keywords();

        string keywords_string = "";

        if (keywords.length > 0) {

            keywords_string = "<mrss:group><mrss:keywords>%s</mrss:keywords></mrss:group>".printf(string.joinv(", ", keywords));

        }

 

            summary, keywords_string);

                       "GoogleLogin auth=" + session.get_auth_token());

                       "Bearer " + session.get_auth_token());

    private Gtk.Builder builder = null;

    

    private Gtk.Box pane_widget = null;

    private Gtk.Label login_identity_label = null;

    private Gtk.Label publish_to_label = null;

    private Gtk.RadioButton use_existing_radio = null;

    private Gtk.ComboBoxText existing_albums_combo = null;

    private Gtk.RadioButton create_new_radio = null;

    private Gtk.Entry new_album_entry = null;

    private Gtk.CheckButton public_check = null;

    private Gtk.ComboBoxText size_combo = null;

    private Gtk.CheckButton strip_metadata_check = null;

    private Gtk.Button publish_button = null;

    private Gtk.Button logout_button = null;

    

    public signal void publish(PublishingParameters parameters, bool strip_metadata);

    public PublishingOptionsPane(Spit.Publishing.PluginHost host, string username, 

        Album[] albums, Spit.Publishing.Publisher.MediaType media_type, Gtk.Builder builder,

        bool strip_metadata) {

        this.builder = builder;

        assert(builder != null);

        assert(builder.get_objects().length() > 0);

 

        // pull in all widgets from builder.

        pane_widget = (Gtk.Box) builder.get_object("picasa_pane_widget");

        login_identity_label = (Gtk.Label) builder.get_object("login_identity_label");

        publish_to_label = (Gtk.Label) builder.get_object("publish_to_label");

        use_existing_radio = (Gtk.RadioButton) builder.get_object("use_existing_radio");

        existing_albums_combo = (Gtk.ComboBoxText) builder.get_object("existing_albums_combo");

        create_new_radio = (Gtk.RadioButton) builder.get_object("create_new_radio");

        new_album_entry = (Gtk.Entry) builder.get_object("new_album_entry");

        public_check = (Gtk.CheckButton) builder.get_object("public_check");

        size_combo = (Gtk.ComboBoxText) builder.get_object("size_combo");

        strip_metadata_check = (Gtk.CheckButton) this.builder.get_object("strip_metadata_check");

        publish_button = (Gtk.Button) builder.get_object("publish_button");

        logout_button = (Gtk.Button) builder.get_object("logout_button");

 

        // populate any widgets whose contents are programmatically-generated.

        login_identity_label.set_label(_("You are logged into Picasa Web Albums as %s.").printf(username));

        strip_metadata_check.set_active(strip_metadata);

 

 

        if((media_type & Spit.Publishing.Publisher.MediaType.PHOTO) == 0) {

            publish_to_label.set_label(_("Videos will appear in:"));

            size_combo.set_visible(false);

            size_combo.set_sensitive(false);

        }

        else {

            publish_to_label.set_label(_("Photos will appear in:"));

            foreach(SizeDescription desc in size_descriptions) {

                size_combo.append_text(desc.name);

            }

            size_combo.set_visible(true);

            size_combo.set_sensitive(true);

            size_combo.set_active(host.get_config_int(DEFAULT_SIZE_CONFIG_KEY, 0));

        }

 

        // connect all signals.

        // size_combo won't have been set to anything useful if this is the first time we've

        // published to Picasa, and/or we've only published video before, so it may be negative,

        // indicating nothing was selected. Clamp it to a valid value...

        int size_combo_last_active = (size_combo.get_active() >= 0) ? size_combo.get_active() : 0;

        

        host.set_config_int(DEFAULT_SIZE_CONFIG_KEY, size_combo_last_active);

        int photo_major_axis_size = size_descriptions[size_combo_last_active].major_axis_pixels;

                is_public), strip_metadata_check.get_active());

            publish(new PublishingParameters.to_existing_album(photo_major_axis_size, album_url), strip_metadata_check.get_active());

        result += new SizeDescription(_("Google+ (2048 x 1536 pixels)"), 2048);

    

    protected void notify_publish(PublishingParameters parameters) {

        publish(parameters, strip_metadata_check.get_active());

    }

    

    protected void notify_logout() {

        logout();

    }

 

    public Gtk.Widget get_widget() {

        return pane_widget;

    }

    

    public Spit.Publishing.DialogPane.GeometryOptions get_preferred_geometry() {

        return Spit.Publishing.DialogPane.GeometryOptions.NONE;

    }

    

    public void on_pane_installed() {

        installed();

         

        publish.connect(notify_publish);

        logout.connect(notify_logout);

    }

    

    public void on_pane_uninstalled() {

        publish.disconnect(notify_publish);

        logout.disconnect(notify_logout);

    }