Merge lp:~axlrose112/midori/midori-restful_client-feature into lp:midori

[axlrose112]

midori extension resful-client

[Cris Dywan (kalikiana)]

As an observation the coding style diverts a bit and uses Java style VariableNames rather than variableNames, though as always I consider this up to the extension author(s). The code is generally very clean and modular, which is nice.

Suggestions for improvement:

You could use Midori.Database API to simplify error handling and binding of parameters. Compiled statements are more efficient than concatenating queries on demand.
c.f. grep Midori.Database extensions

I didn't figure out how to create projects. I think the UX needs improvement.

A "Submit" button would seem like a nice idea, through trial and error I found out that hitting Enter in the text field makes a request, but it took me a moment.

^^ I think the projects UX is critical here for landing a first version, the other ones are optional.

review: Needs Fixing

[axlrose112 (axlrose112)]

great i am going to fix it :)

Unmerged revisions

7046. By axlrose112 on 2015-10-10

midori restful client feature

=== added file 'extensions/restful-client.vala'
--- extensions/restful-client.vala	1970-01-01 00:00:00 +0000
+++ extensions/restful-client.vala	2015-10-10 13:23:24 +0000
@@ -0,0 +1,1012 @@
+/*
+ Copyright (C) 2015 James Axl <[e-mail]>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ See the file COPYING for the full license text.
+
+ 0. Earth and all that is in it, with knowledge we protect it. And the best of mankind knowledge makes him and he makes it.
+*/
+
+using Soup;
+
+namespace RestFul {
+    private class Manager : Midori.Extension {
+        private MainWindow _MainWindow;
+ 
+        internal Manager () {
+            GLib.Object (name: _("Restful Client"),
+                         description: _("Test your requests with Restful-Server"),
+                         version: "0.1" + Midori.VERSION_SUFFIX,
+                         authors: "James Axl <[e-mail]>");
+            activate.connect (this.activated);
+            deactivate.connect (this.deactivated);
+        }
+        
+        void tool_menu_populated (Gtk.Menu menu) {
+            var item = new Gtk.MenuItem.with_label("Restful Client");
+            menu.add(item);
+            item.activate.connect (() => {
+                if (_MainWindow == null ) {
+                    _MainWindow = new MainWindow();
+                    _MainWindow.ShowAll();
+                } else if(_MainWindow.Opened) {
+                     _MainWindow.present ();
+                     return;
+                } else {
+                    _MainWindow = new MainWindow();
+                    _MainWindow.ShowAll();
+                }
+            });
+            item.show();
+        }
+
+        void browser_added (Midori.Browser browser) {
+            browser.populate_tool_menu.connect(tool_menu_populated);
+        }
+
+        void activated (Midori.App app) {
+            _MainWindow = null;
+            foreach (var browser in app.get_browsers ())
+                browser_added (browser);
+            app.add_browser.connect (browser_added);
+        }
+ 
+        void deactivated () {
+            var app = get_app ();
+            app.add_browser.disconnect (browser_added);
+        }
+
+    }
+
+    public class RequestGui : Gtk.Box {
+        public string method {get; private set;}
+        public string Header {get; private set;}
+        public string UrlText {get; private set;}
+        public string DataText {get; private set;}
+        private Gtk.Entry Url;
+        private Gtk.Entry Data;
+        private Gtk.ComboBox Cbox;
+        private Gtk.ComboBox HeaderBox;
+        private Project project;
+        private RestfulData Db;
+        public MainWindow _MainWindow;
+
+        public RequestGui(MainWindow mainWindow) {
+                
+            Object (orientation : Gtk.Orientation.VERTICAL, spacing : 5);
+            _MainWindow = mainWindow;
+            var paned =  new Gtk.Paned (Gtk.Orientation.HORIZONTAL);
+            var scrolledResultView = new Gtk.ScrolledWindow (null, null);
+            var scrolledProject = new Gtk.ScrolledWindow (null, null);
+            var status = new Gtk.Statusbar();
+            var notebook = new Gtk.Notebook ();
+            var title = new Gtk.Label ("Projects");
+            var vbox1 = new Gtk.Box (Gtk.Orientation.VERTICAL, 3);
+            var hbox1 = new Gtk.Box (Gtk.Orientation.HORIZONTAL, 3);
+            var hbox2  = new Gtk.Box (Gtk.Orientation.HORIZONTAL, 3);
+            var hbox3  = new Gtk.Box (Gtk.Orientation.HORIZONTAL, 3);
+            var hbox4  = new Gtk.Box (Gtk.Orientation.HORIZONTAL, 3);
+            var appendRequest = new Gtk.Button.with_label("Append");
+            var resultView = new Gtk.TextView();
+            Db = new RestfulData();
+            var soupRequest = new RestfulSoup(this);
+            project = new Project(this, appendRequest, Db);
+            appendRequest.clicked.connect (() => {
+                project.AddRequest();
+            });
+            appendRequest.set_sensitive(false);
+            Url = new Gtk.Entry();
+            Data = new Gtk.Entry();
+            Url.set_placeholder_text ("Set URL");
+            Data.set_placeholder_text ("Set DATA");
+            Url.changed.connect (() => {
+                UrlText = Url.get_text ();
+                if(UrlText == "" || !project.IsProject ) appendRequest.set_sensitive(false);
+                else if(UrlText != "" && project.IsProject) appendRequest.set_sensitive(true);
+            });
+            Url.activate.connect (() => {
+                if (UrlText == "") {
+                    InfoDialog("Fill the URL field");
+                    return;
+                }
+                if (!soupRequest.SendRequest(UrlText, DataText, method, Header)) return ;
+                resultView.buffer.text = soupRequest.ResfultBody;
+            });
+            Url.set_icon_from_icon_name (Gtk.EntryIconPosition.SECONDARY, "edit-clear");
+            Url.icon_press.connect ((pos, event) => {
+                if (pos == Gtk.EntryIconPosition.SECONDARY) {
+                    Url.set_text ("");
+                }
+            });
+            Data.changed.connect (() => {
+                DataText = Data.get_text ();
+            });
+            Data.activate.connect (() => {
+                soupRequest.SendRequest(UrlText, DataText, method, Header);
+                resultView.buffer.text = soupRequest.ResfultBody;
+            });
+            Data.set_icon_from_icon_name (Gtk.EntryIconPosition.SECONDARY, "edit-clear");
+            Data.icon_press.connect ((pos, event) => {
+                if (pos == Gtk.EntryIconPosition.SECONDARY) {
+                    Data.set_text ("");
+                }
+            });
+
+            resultView.editable = false;
+            var bar = new Gtk.MenuBar ();
+            var itemFile = new Gtk.MenuItem.with_mnemonic ("_File");
+            var itemHelp = new Gtk.MenuItem.with_mnemonic ("_?");
+            bar.add (itemFile);
+            bar.add (itemHelp);
+            var fileMenu = new Gtk.Menu ();
+            var helpMenu = new Gtk.Menu ();
+            
+            itemFile.set_submenu (fileMenu);
+            itemHelp.set_submenu (helpMenu);
+            var itemNew = new Gtk.MenuItem.with_mnemonic ("_New project");
+            var itemExportAll = new Gtk.MenuItem.with_mnemonic ("_Export data");
+            var itemImportAll = new Gtk.MenuItem.with_mnemonic ("_Import data");
+            var itemSeeYou = new Gtk.MenuItem.with_mnemonic ("_See you");
+            var itemAbout = new Gtk.MenuItem.with_mnemonic ("_About");
+            var itemHelpWeb = new Gtk.MenuItem.with_mnemonic ("_Help");
+
+            fileMenu.add (itemNew);
+            fileMenu.add (itemExportAll);
+            fileMenu.add (itemImportAll);
+            fileMenu.add (itemSeeYou);
+            helpMenu.add (itemAbout);
+            helpMenu.add (itemHelpWeb);
+
+            itemNew.activate.connect (() => {
+                project.ItemNewProject();
+            });
+            
+            itemHelpWeb.activate.connect (() => {
+                try {
+                    AppInfo.launch_default_for_uri ("https://wiki.xfce.org/restful-client_midori", null);
+                } catch {
+                    print("Can not open it\n");
+                }
+            });
+            
+            itemAbout.activate.connect (() => {
+                Gtk.MessageDialog msg = new Gtk.MessageDialog (_MainWindow, Gtk.DialogFlags.MODAL, Gtk.MessageType.WARNING, Gtk.ButtonsType.OK_CANCEL, "Welcome to Midori Restful-client");
+                msg.format_secondary_text("Press Ok if you like it and Cancel if you have issues.");
+                msg.response.connect ((response_id) => {
+                    switch (response_id) {
+                        case Gtk.ResponseType.OK:
+                            try {
+                            AppInfo.launch_default_for_uri ("http://midori-browser.org/", null);
+                            } catch {
+                            print("Can not open it\n");
+                            }
+                            break;
+                        case Gtk.ResponseType.CANCEL:
+                            try {
+                            AppInfo.launch_default_for_uri ("https://bugs.launchpad.net/midori/+filebug", null);
+                            } catch {
+                            print("Can not open it\n");
+                            }
+                            break;
+                        }
+                    msg.destroy();
+                    });
+                msg.show ();
+            });
+            
+            itemImportAll.activate.connect (() => {
+                var import = new RestFullExportImportData();
+                Gtk.FileChooserDialog chooser = new Gtk.FileChooserDialog (
+                "Select your favorite file", _MainWindow, Gtk.FileChooserAction.OPEN,
+                "_Cancel",
+                Gtk.ResponseType.CANCEL,
+                "_Open",
+                Gtk.ResponseType.ACCEPT);
+                var filter = new Gtk.FileFilter ();
+                chooser.set_filter (filter);
+                filter.add_pattern ("*.midorix");
+                if (chooser.run () == Gtk.ResponseType.ACCEPT) {
+                    string uri = chooser.get_uri();
+                    import.ImportData(uri);
+                }
+                chooser.close ();
+            });
+
+            itemExportAll.activate.connect (() => {
+                var export = new RestFullExportImportData();
+                Gtk.FileChooserDialog chooser = new Gtk.FileChooserDialog (
+                "Select your favorite file", _MainWindow, Gtk.FileChooserAction.SAVE,
+                "_Cancel",
+                Gtk.ResponseType.CANCEL,
+                "_Save",
+                Gtk.ResponseType.ACCEPT);
+                if (chooser.run () == Gtk.ResponseType.ACCEPT) {
+                    string uri = chooser.get_uri();
+                    export.ExportData(uri);
+                }
+                chooser.close ();
+            });
+
+            itemSeeYou.activate.connect (() => {
+                _MainWindow.destroy();
+            });
+
+            /* cb method */
+            var method_store = new Gtk.ListStore (1, typeof (string));
+            Gtk.TreeIter iter;
+            method = "POST";
+            method_store.append (out iter);
+            method_store.set (iter, 0, method);
+            method_store.append (out iter);
+            method_store.set (iter, 0, "GET");
+            method_store.append (out iter);
+            method_store.set (iter, 0, "PUT");
+            method_store.append (out iter);
+            method_store.set (iter, 0, "DELETE");
+
+            /* cb header */
+            Gtk.ListStore headerlist = new Gtk.ListStore (1, typeof (string));
+
+            headerlist.append (out iter);
+            headerlist.set (iter, 0, "application/x-www-form-urlencoded");
+            headerlist.append (out iter);
+            headerlist.set (iter, 0, "application/json");
+
+            /* The Box */
+                
+            Cbox = new Gtk.ComboBox.with_model (method_store);
+            HeaderBox = new Gtk.ComboBox.with_model (headerlist);
+
+            var renderer = new Gtk.CellRendererText ();
+            Cbox.pack_start (renderer, false);
+            Cbox.add_attribute (renderer, "text", 0);
+            Cbox.active = 0;
+
+            var headerrenderer = new Gtk.CellRendererText ();
+            HeaderBox.pack_start (headerrenderer, false);
+            HeaderBox.add_attribute (headerrenderer, "text", 0);
+            HeaderBox.active = 0;
+
+            Cbox.changed.connect (() => {
+                GLib.Value val1;
+                Cbox.get_active_iter (out iter);
+                method_store.get_value (iter, 0, out val1);
+                method = (string) val1;
+            });
+
+            HeaderBox.changed.connect (() => {
+                GLib.Value val1;
+                HeaderBox.get_active_iter (out iter);
+                headerlist.get_value (iter, 0, out val1);
+                Header = (string) val1;
+            });
+
+            hbox1.pack_start (Cbox, false, false, 5);
+            hbox1.pack_start (Url, true, true, 5);
+            hbox1.pack_start (appendRequest , false, false, 5);
+            hbox2.pack_start (HeaderBox, false, false, 5);
+            hbox2.pack_start (Data, true, true, 5);
+            scrolledResultView.add(resultView);
+            hbox3.pack_start (scrolledResultView, true, true, 5);
+            scrolledProject.add(project);
+            notebook.append_page (scrolledProject, title);
+            paned.add1(notebook);
+            paned.add2(vbox1);
+            vbox1.pack_start (hbox1, false, false, 5);
+            vbox1.pack_start (hbox2, false, false, 5);
+            vbox1.pack_start (hbox3, true, true, 5);
+            hbox4.pack_start (paned, true, true, 7);
+            this.pack_start (bar, false, false, 1);
+            this.pack_start (hbox4, true, true, 5);
+            this.pack_start (status, false, false, 1);
+            BackToTheZero();
+        }
+    
+        public void FillWidgets(List<string> dataResquest) {
+            Url.set_text(dataResquest.nth_data (0));
+            if (dataResquest.nth_data(1) == "empty")
+                dataResquest.nth(1).data = "";
+            Data.set_text(dataResquest.nth_data(1));
+            Cbox.set_active(int.parse(dataResquest.nth_data (2)));
+            HeaderBox.set_active(int.parse(dataResquest.nth_data (3)));
+            foreach (string request in dataResquest)
+                dataResquest.remove(request);
+        }
+
+        public void BackToTheZero() {
+            Url.set_text("");
+            Data.set_text("");
+            Cbox.set_active(0);
+            HeaderBox.set_active(0);
+            Header = "application/x-www-form-urlencoded";
+            method = "POST";
+            UrlText = "";
+            DataText = "";
+        }
+
+        public void InfoDialog(string msg) {
+            var dialog = new Gtk.MessageDialog(_MainWindow, Gtk.DialogFlags.MODAL,Gtk.MessageType.WARNING, Gtk.ButtonsType.OK, msg);
+            dialog.set_title("Midori");
+            dialog.run();
+            dialog.destroy();
+        }
+    }
+
+   public class MainWindow : Gtk.Window {
+        public bool Opened {get; set;}
+        public MainWindow() {
+            this.title = "Midori Restful-client";
+            this.set_default_size (800, 600);
+            this.window_position = Gtk.WindowPosition.CENTER;
+            Opened = false;
+            this.destroy.connect(HideMe);
+        }
+        
+        public void ShowAll() {
+            Opened = true;
+            var gui = new RequestGui(this);
+            this.add(gui);
+            this.show_all();
+        }
+
+        private void HideMe() {
+            this.destroy();
+            Opened = false;
+        }
+    }
+
+    public class RestfulSoup {
+        public string ResfultBody {get; private set;}
+        private RequestGui _RequestGui;
+        
+        public RestfulSoup (RequestGui requestGui) {
+            _RequestGui = requestGui;
+        }
+
+        public bool SendRequest(string url, string data, string method, string header) {
+            var new_url = url;
+
+            try {
+                var regex = new Regex("""^(http|https)(:\/\/[a-zA-Z0-9?=#.\/]+)""");
+                if (regex.match(new_url)) {
+                    var session = new Soup.Session ();
+                    var message = new Soup.Message (method, new_url);
+                    if (data != "")
+                        message.set_request(header, MemoryUse.COPY, data.data);
+                    session.send_message (message);
+                    ResfultBody = (string) message.response_body.data;
+                    return true;
+                } else {
+                    _RequestGui.InfoDialog("You should put a right url e.g 'http://midori-browser.org'");
+                }
+            } catch( RegexError re ) {
+                warning ("%s", re.message);
+            }
+            return false;
+        }
+    }
+
+    public class RestfulData {
+        private Sqlite.Database DB;
+        private int EC;
+        private string ErrMsg;
+        public List<string> ProjectList;
+        public List<string> RequestList;
+        public List<string> RequestDataList;
+        public RestfulData() {
+            // Open/Create a database: I used /tmp just for testing but i am going to use config dir after
+            EC = Sqlite.Database.open ("/tmp/midori_restful.db", out DB);
+            ProjectList = new List<string>();
+            RequestList = new List<string>();
+            RequestDataList = new List<string>();
+            if (EC != Sqlite.OK) {
+                stderr.printf ("Can't open database: %d: %s\n", DB.errcode (), DB.errmsg ());
+                return;
+            }
+            string query = """
+                        create table if not exists `project` (
+                        `id_project`        INTEGER,
+                        `name`        Text NOT NULL UNIQUE,
+                        `date`        TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                         PRIMARY KEY(id_project));
+                         create table if not exists `request` (
+                         `id_request`        INTEGER,
+                         `name`        Text NOT NULL UNIQUE,
+                         `url`        Text NOT NULL,
+                         `data`        Text NOT NULL,
+                         `method`        Text NOT NULL,
+                         `header`        Text NOT NULL,
+                         `date`        TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                         `id_project`        integer,
+                         PRIMARY KEY(id_request),
+                         Foreign key(id_project) references project on delete cascade on update cascade);
+                """;
+            string on_key = "PRAGMA foreign_keys = ON;";
+            EC = DB.exec (on_key, null, out ErrMsg);
+
+            // Execute our query:
+            EC = DB.exec (query, null, out ErrMsg);
+            if (EC != Sqlite.OK){
+                stderr.printf ("Error: %s\n", ErrMsg);
+                return;
+            }
+        }
+
+        public bool RegisterProject(string name, string date = "empty") {
+            string query;
+            if (date == "empty")
+                query = "INSERT INTO project (name) VALUES ('"+ name +"');";
+            else 
+                query = "INSERT INTO project (name) VALUES ('"+ name +"', '"+ date +"');";
+
+            EC = DB.exec (query, null, out ErrMsg);
+            if (EC != Sqlite.OK) {
+                stderr.printf ("Error: %s\n", ErrMsg);
+                return false;
+             }
+             return true;
+         }
+
+         public bool DeleteProject(string name) {
+            string query = "DELETE from project WHERE name = '"+ name +"';";
+            EC = DB.exec (query, null, out ErrMsg);
+            if (EC != Sqlite.OK) {
+                stderr.printf ("Error: %s\n", ErrMsg);
+                return false;
+            }
+            return true;
+         }
+
+        public bool CheckDuplicatProject (string name) {
+            Sqlite.Statement stmt;
+            var query = "select name from project where name = '"+ name +"';";
+            if ((EC = DB.prepare_v2 (query, -1, out stmt, null)) ==  Sqlite.ERROR) {
+                printerr ("SQL error: %d, %s\n", EC, DB.errmsg ());
+                return false;
+            }
+            EC = stmt.step();
+            if (EC != Sqlite.ROW && EC != Sqlite.DONE)return false;
+            return (EC == Sqlite.ROW);
+        }
+
+        public bool RetrieveProject() {
+            var query = "select name from project;";
+            EC = DB.exec (query, exec_callback, out ErrMsg);
+            if (EC != Sqlite.OK) {
+                stderr.printf ("Error: %s\n", ErrMsg);
+                return false;
+            }
+            return true;
+        }
+
+        public int CountProject() {
+            string[] res;
+            int nrows;
+            int ncols;
+            var query = "select name from project;"; 
+            if ((EC = DB.get_table (query, out res, out nrows, out ncols, out ErrMsg)) == Sqlite.ERROR) { 
+                printerr ("SQL error: %d, %s\n", EC, ErrMsg);
+            }
+            return nrows;
+        }
+
+        private int exec_callback (int n_columns, string[] values, string[] column_names) {
+            for (int i = 0; i < n_columns; i++) {
+                this.ProjectList.append(values[i]);
+            }
+            return 0;
+        }
+
+        public bool RegisterRequest(string p_name, string r_name, string r_url, string method, string r_data, string r_header, string r_date = "empty"){
+            Sqlite.Statement stmt;
+            string query;
+            int id_project = 0;
+            string p_query = "select id_project from project where name = '"+ p_name +"';";
+            if ((EC = DB.prepare_v2 (p_query, -1, out stmt, null)) ==  Sqlite.ERROR) {
+                printerr ("SQL error: %d, %s\n", EC, DB.errmsg ());
+                return false;
+            }
+
+            if (stmt.step () == Sqlite.ROW) id_project = int.parse(stmt.column_text (0));
+            if (r_date == "empty")
+                query = "INSERT INTO request (name, url, data, id_project, method, header) VALUES ('"+ r_name +"', '"+ r_url +"', '"+ r_data +"' , ?, '"+ method +"', '"+ r_header +"');";
+            else
+                query = "INSERT INTO request (name, url, data, id_project, method, header, date) VALUES ('"+ r_name +"', '"+ r_url +"', '"+ r_data +"' , ?, '"+ method +"', '"+ r_header +"', '"+ r_date +"');";
+
+            EC = DB.prepare_v2(query, -1, out stmt);
+            EC = stmt.bind_int(1, id_project);
+            EC = stmt.step();
+            if (EC != Sqlite.DONE) {
+                stderr.printf ("Error: %s\n", ErrMsg);
+                return false;
+            }
+
+            return true;
+        }
+
+        public bool DuplicatRequest(string p_name, string r_name) {
+            Sqlite.Statement stmt;
+            var query = "select project.name from request, project where request.id_project = project.id_project and request.name = '"+r_name+"' and project.name='"+p_name+"';";
+            if ((EC = DB.prepare_v2 (query, -1, out stmt, null)) ==  Sqlite.ERROR) {
+                printerr ("SQL error: %d, %s\n", EC, DB.errmsg ());
+                return false;
+            }
+            EC = stmt.step();
+            if (EC != Sqlite.ROW && EC != Sqlite.DONE) return false;
+            return (EC == Sqlite.ROW);
+        }
+
+        public bool DeleteRequest(string name) {
+
+            string query = "DELETE FROM request WHERE name = '"+ name +"';";
+            EC = DB.exec (query, null, out ErrMsg);
+            if (EC != Sqlite.OK) {
+                stderr.printf ("Error here: %s\n", ErrMsg);
+                return false;
+            }
+            return true;
+        }
+
+        public bool RetrieveRequestByProject(string name) {
+            Sqlite.Statement stmt;
+            string query = "select request.name from project, request where request.id_project = project .id_project and project.name = '"+ name +"';";
+            if ((EC = DB.prepare_v2 (query, -1, out stmt, null)) ==  Sqlite.ERROR) {
+                printerr ("SQL error: %d, %s\n", EC, DB.errmsg ());
+                return false;
+            }
+            while (stmt.step () == Sqlite.ROW) {
+                this.RequestList.append(stmt.column_text(0));
+            }
+            return true;
+        }
+
+        public bool RetrieveRequestData(string name){
+            Sqlite.Statement stmt;
+            string query = "select url, data, method, header, date from request where name = '"+ name +"';";
+            if ((EC = DB.prepare_v2 (query, -1, out stmt, null)) ==  Sqlite.ERROR) {
+                printerr ("SQL error: %d, %s\n", EC, DB.errmsg ());
+                return false;
+            }
+            if (stmt.step () == Sqlite.ROW) {
+                this.RequestDataList.append(stmt.column_text(0));
+                this.RequestDataList.append(stmt.column_text(1));
+                switch (stmt.column_text(2)) {
+                    case "POST":
+                        this.RequestDataList.append("0");
+                        break;
+                    case "GET":
+                        this.RequestDataList.append("1");
+                        break;
+                    case "PUT":
+                        this.RequestDataList.append("2");
+                        break;
+                    case "DELETE":
+                        this.RequestDataList.append("3");
+                        break;
+                }
+                switch (stmt.column_text(3)) {
+                    case "application/x-www-form-urlencoded":
+                        this.RequestDataList.append("0");
+                        break;
+                    case "application/json":
+                        this.RequestDataList.append("1");
+                        break;
+                }
+                this.RequestDataList.append(stmt.column_text(4));
+                return true;
+            }
+            return false;
+        }
+
+    public bool RetrieveRequestDataXml(string name){
+            Sqlite.Statement stmt;
+            string query = "select url, data, method, header, date from request where name = '"+ name +"';";
+            if ((EC = DB.prepare_v2 (query, -1, out stmt, null)) ==  Sqlite.ERROR) {
+                printerr ("SQL error: %d, %s\n", EC, DB.errmsg ());
+                return false;
+            }
+            if (stmt.step () == Sqlite.ROW) {
+                this.RequestDataList.append(stmt.column_text(0));
+                this.RequestDataList.append(stmt.column_text(1));
+                this.RequestDataList.append(stmt.column_text(2));
+                this.RequestDataList.append(stmt.column_text(3));
+                this.RequestDataList.append(stmt.column_text(4));
+                return true;
+            }
+            return false;
+        }
+
+    }
+
+    public class Project : Gtk.TreeView {
+        
+        public string SelectedRow {get; private set;}
+        public bool IsProject {get; private set;}
+        private Gtk.TreeStore ProjectStore;
+        private Gtk.TreeIter ProjectParent;
+        private Gtk.TreeIter RequestChild;
+        private Gtk.TreeIter selected_iter;
+        private Gtk.Button AppendRequest;
+        private RestfulData Db;
+        private InputDialog Name;
+        private RequestGui _RequestGui;
+        private Gtk.TreeSelection _Selection;
+        private Gtk.Menu menuSystem;
+        private Gtk.MenuItem delete_project;
+        private Gtk.MenuItem delete_request;
+
+        public Project (RequestGui requestGui , Gtk.Button appendRequest, RestfulData db) {
+            IsProject = false;
+            AppendRequest = appendRequest;
+            Db = db;
+            _RequestGui = requestGui;
+            var selected = this.get_selection ();
+            selected.changed.connect (this.SeletedRow);
+            this.headers_visible = false;
+            menuSystem = new Gtk.Menu();
+            delete_project = new Gtk.MenuItem.with_label ("Delete project");
+            delete_request = new Gtk.MenuItem.with_label ("Delete request");
+            delete_project.activate.connect (() => {
+                DeleteProjectRequest();
+            });
+            delete_request.activate.connect (() => {
+                DeleteProjectRequest();
+            });
+            menuSystem.add(delete_project);
+            menuSystem.add(delete_request);
+            menuSystem.show();
+
+            this.button_press_event.connect((w, event) => {
+                if (event.button == 3) {
+                    return PopUpHandler (menuSystem, event);
+                }
+                return false;
+            }); 
+            this.popup_menu.connect((event) => {
+                return PopUpHandler (menuSystem, null);
+            });
+
+            ProjectStore = new Gtk.TreeStore (1, typeof (string));
+            this.set_model (ProjectStore);                
+            this.insert_column_with_attributes (-1, "Projects", new Gtk.CellRendererText (), "text", 0, null);
+            if (Db.RetrieveProject()) {
+                foreach (string project in Db.ProjectList) {
+                    ProjectStore.append (out ProjectParent, null);
+                    ProjectStore.set (ProjectParent, 0, project, -1);
+                    if(Db.RetrieveRequestByProject(project)){
+                        foreach (string request in Db.RequestList) {
+                            ProjectStore.append (out RequestChild, ProjectParent);
+                            ProjectStore.set (RequestChild, 0, request, -1);
+                        }
+                    foreach (string request in Db.RequestList)
+                        Db.RequestList.remove(request);
+                    }
+                }
+                foreach (string project in Db.ProjectList)
+                    Db.RequestList.remove(project);
+            }
+        }
+
+        private bool PopUpHandler (Gtk.Menu popup, Gdk.EventButton? eb) {
+
+            if (Db.CountProject() > 0) {
+                if (eb.button == 3) {
+                    Gtk.TreePath path;
+                    Gtk.TreeViewColumn column;
+                    int mousex = (int) eb.x;
+                    int mousey = (int) eb.y;
+                    int x;
+                    int y;
+                    int a;
+                    int b;
+                    convert_tree_to_bin_window_coords (mousex, mousey, out a, out b);
+                    if (get_path_at_pos (a, b, out path, out  column, out  x, out y))
+                        set_cursor (path, column, true);
+                    popup.popup (null, null, null, eb.button, eb.time);
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public void ItemNewProject() {
+            Name = new InputDialog(_RequestGui._MainWindow);
+            Name.show_all ();
+
+            Name.input.activate.connect (() => {
+                if (Name.input.get_text() == "") {
+                    CheckInputEmptyOrDuplicat(true);
+                    return;
+                } else if (AddProject(Name.input.get_text())) {
+                    Name.close();
+                    return;
+                } else {
+                    CheckInputEmptyOrDuplicat(false);
+                    return;
+                }
+            });
+        }
+
+        private bool AddProject(string name) {
+            if (Db.CheckDuplicatProject(name)) return false;
+            if(!Db.RegisterProject(name)) return false;
+            ProjectStore.append (out ProjectParent, null);
+            ProjectStore.set (ProjectParent, 0, name, -1);
+            return true;
+        }
+
+        public void DeleteProjectRequest() {
+            GLib.Value val;
+            Gtk.TreeModel model;
+            Gtk.TreeIter iter;
+            if (_Selection.get_selected (out model, out selected_iter)) {
+                ProjectStore.get_value(selected_iter, 0, out val);
+                if (!model.iter_parent (out iter, selected_iter)) {
+                    if(Db.DeleteProject((string) val))
+                        ProjectStore.remove(ref selected_iter);
+                } else {
+                    if(Db.DeleteRequest((string) val))
+                    ProjectStore.remove(ref selected_iter);
+                }
+            }
+        }
+
+        public void SeletedRow(Gtk.TreeSelection selection) {
+            Gtk.TreeModel model;
+            Gtk.TreeIter iter;
+            _Selection = selection;
+            Value val;
+            if (_Selection.get_selected (out model, out selected_iter)) {
+                ProjectStore.get_value( selected_iter, 0, out val);
+                SelectedRow = (string)val;
+                if (model.iter_parent (out iter, selected_iter)) {
+                    IsProject = false;
+                    delete_project.hide();
+                    delete_request.show();
+                    AppendRequest.set_sensitive(false);
+                    if (Db.RetrieveRequestData(SelectedRow))
+                        _RequestGui.FillWidgets(Db.RequestDataList);
+                    else
+                        _RequestGui.BackToTheZero();
+                } else {
+                    delete_request.hide();
+                    delete_project.show();
+                    IsProject = true;
+                    _RequestGui.BackToTheZero();
+                }
+            }
+        }
+
+        public void AddRequest() {
+            GLib.Value valProject;
+            ProjectStore.get_value(selected_iter, 0, out valProject);
+            Name = new InputDialog(_RequestGui._MainWindow);
+            Name.show_all();
+
+            Name.input.activate.connect (() => {
+                if (Name.input.get_text() == "") {
+                    Name.Warnning.set_text("Please fill the field");
+                    CheckInputEmptyOrDuplicat(true);
+                    return;
+                } else if (Db.DuplicatRequest((string)valProject, Name.input.get_text())){
+                    CheckInputEmptyOrDuplicat(false);
+                    return;
+                } else if (!Db.RegisterRequest( (string)valProject, Name.input.get_text(), _RequestGui.UrlText, _RequestGui.method, _RequestGui.DataText, _RequestGui.Header)) return ;
+                Gtk.TreeIter project_iter;
+                ProjectStore.append (out project_iter, selected_iter);
+                ProjectStore.set (project_iter, 0, Name.input.get_text(), -1);
+                Name.close();
+            });
+        }
+
+        private void CheckInputEmptyOrDuplicat(bool emptyOrDuplicat) {
+            if (emptyOrDuplicat) Name.Warnning.set_text("Please fill the field");
+            else Name.Warnning.set_text("Already exists");
+            Gdk.Color RED;
+            Gdk.Color.parse("red", out RED);
+            Name.Warnning.modify_fg(Gtk.StateType.NORMAL, RED);
+            
+            if (Name.VboxWarnning.get_children().length() == 1)
+                Name.VboxWarnning.pack_start (Name.Warnning, false, false, 5);
+            Name.Warnning.show();
+        }
+    }
+
+    public class InputDialog : Gtk.Dialog {
+        public Gtk.Entry input;
+        public Gtk.Label Warnning;
+        public Gtk.Box VboxWarnning;
+
+        public InputDialog(MainWindow mainWindow) {
+            Object(title : "Restful-client", parent : mainWindow);
+            this.set_default_size (50, 30);
+            this.border_width = 5;
+            this.window_position = Gtk.WindowPosition.CENTER;
+            var hbox1 = new Gtk.Box (Gtk.Orientation.HORIZONTAL, 5);
+            VboxWarnning = new Gtk.Box (Gtk.Orientation.VERTICAL, 1);
+            var vbox1 = get_content_area () as Gtk.Box;
+            input = new Gtk.Entry();
+            Warnning = new Gtk.Label("");
+            Warnning.hide();
+            input.set_placeholder_text("Set a name");
+            VboxWarnning.pack_end (hbox1, true, false, 5);
+            hbox1.pack_start (input, true, true, 5);
+            vbox1.pack_start (VboxWarnning, false, false, 5);
+            mainWindow.destroy.connect(this.Destroy);
+        }
+
+        private void Destroy() {
+            this.destroy();
+        }
+    }
+    
+    public class RestFullExportImportData {
+        
+        private Xml.TextWriter Writer;
+        private List<string> XmlDataList;
+        private RestfulData _DB;
+        
+        public RestFullExportImportData() {
+            _DB = new RestfulData();
+        }
+
+        public void ExportData(string path) {
+            if (_DB.RetrieveProject()) {
+                Writer = new Xml.TextWriter.filename (path + ".midorix");
+                Writer.set_indent (true);
+                Writer.set_indent_string ("\t");
+                Writer.start_document ();
+                Writer.start_element ("Projects");
+                foreach(var l in _DB.ProjectList) {
+                    Writer.start_element ("Project");
+                    Writer.start_attribute ("name");
+                    Writer.write_string (l);
+                    Writer.end_attribute ();
+                    if (_DB.RetrieveRequestByProject(l)) {
+                        foreach(var r in _DB.RequestList) {
+                            Writer.start_element ("Request");
+                            Writer.start_attribute ("name");
+                            Writer.write_string (r);
+                            if (_DB.RetrieveRequestDataXml(r)) {
+                                Writer.write_element ("url", _DB.RequestDataList.nth_data(1));
+                                Writer.write_element ("method", _DB.RequestDataList.nth_data(2));
+                                if (_DB.RequestDataList.nth_data(1) == "")
+                                    _DB.RequestDataList.nth(1).data = "empty";
+                                Writer.write_element ("data", _DB.RequestDataList.nth_data(1));
+                                Writer.write_element ("header", _DB.RequestDataList.nth_data(3));
+                                Writer.write_element ("date", _DB.RequestDataList.nth_data(4));
+                            }
+                            foreach (string request in _DB.RequestDataList)
+                                _DB.RequestDataList.remove(request);
+
+                            Writer.end_attribute ();
+                            Writer.end_element();
+                        }
+                        foreach (string request in _DB.RequestList)
+                            _DB.RequestList.remove(request);
+                    }
+                    Writer.end_element();
+                }
+                foreach (string request in _DB.ProjectList)
+                    _DB.ProjectList.remove(request);
+                Writer.end_element();
+                Writer.end_document();
+                Writer.flush();
+            }
+        }
+
+        public void ImportData(string path) {
+            
+            Xml.Doc* doc = Xml.Parser.parse_file (path);
+            XmlDataList = new List<string?>();
+            if (doc == null) {
+                stdout.printf ("File %s not found or permissions missing\n", path);
+                return;
+            }
+
+            Xml.Node* root = doc->get_root_element ();
+            if (root == null) {
+                stdout.printf ("WANTED! root\n");
+                delete doc;
+                return;
+            }
+
+            if (root->name == "Projects") {
+                RegsiterXmlProject (root);
+            } else {
+                stdout.printf ("Unexpected element %s\n", root->name);
+                return;
+            }
+            delete doc;
+        }
+        private void FillXmlList (Xml.Node* node, string node_name) {
+            assert (node->name == node_name);
+
+            for (Xml.Node* iter = node->children; iter != null; iter = iter->next) {
+                if (iter->type == Xml.ElementType.TEXT_NODE) {
+                    XmlDataList.append(iter->get_content ());
+                } else {
+                    stdout.printf ("Unexpected element %s\n", iter->name);
+                    return;
+                }
+            }
+        }
+
+        public void RegsiterXmlItem (Xml.Node* node) {
+            assert (node->name == "Project");
+
+            string? id = node->get_prop ("name");
+            if (id != null) {
+                _DB.RegisterProject(id);
+            } else {
+                stdout.puts ("Expected: <Project name=...\n");
+                return;
+            }
+
+            for (Xml.Node* iter = node->children; iter != null; iter = iter->next) {
+                if (iter->type == Xml.ElementType.ELEMENT_NODE) {
+                    switch (iter->name) {
+                    case "Request":
+                        string? id_r = iter->get_prop ("name");
+                        for (Xml.Node* iter_r = iter->children; iter_r != null; iter_r = iter_r->next) {
+                            if (iter_r->type == Xml.ElementType.ELEMENT_NODE) {
+                                switch (iter_r->name) {
+                                case "url":
+                                    FillXmlList (iter_r, "url");
+                                    break;
+                                case "method":
+                                    FillXmlList (iter_r, "method");
+                                    break;
+                                case "data":
+                                    FillXmlList (iter_r, "data");
+                                    break;
+                                case "header":
+                                    FillXmlList (iter_r, "header");
+                                    break;
+                                case "date":
+                                    FillXmlList (iter_r, "date");
+                                    break;
+                                        
+                                default:
+                                    stdout.printf ("Unexpected element %s\n", iter_r->name);
+                                    break;
+                                }
+                            }
+                        }
+                        if (_DB.RegisterRequest(id, id_r, XmlDataList.nth_data(0), XmlDataList.nth_data(1), XmlDataList.nth_data(2), XmlDataList.nth_data(3), XmlDataList.nth_data(4)))
+                            foreach (string request in XmlDataList)
+                                XmlDataList.remove(request);
+                        else 
+                                return;
+                        break;  
+                    default:
+                        stdout.printf ("Unexpected element %s\n", iter->name);
+                        break;
+                    }
+                }
+            }
+        }
+
+        public void RegsiterXmlProject (Xml.Node* node) {
+            assert (node->name == "Projects");
+
+            for (Xml.Node* iter = node->children; iter != null; iter = iter->next) {
+                if (iter->type == Xml.ElementType.ELEMENT_NODE) {
+                    if (iter->name == "Project") {
+                        RegsiterXmlItem (iter);
+                    } else {
+                        stdout.printf ("Unexpected element %s\n", iter->name);
+                    }
+                }
+            }
+        }
+        
+    }
+}
+public Midori.Extension extension_init () {                                                                                                                    
+    return new RestFul.Manager ();
+}