WIP: app launcher

solid/appinfo/routes.php

@@ -35,5 +35,7 @@
         ['name' => 'storage#handleDelete', 'url' => '/@{userId}/storage{path}', 'verb' => 'DELETE', 'requirements' => array('path' => '.+')],
         ['name' => 'storage#handlePatch', 'url' => '/@{userId}/storage{path}', 'verb' => 'PATCH', 'requirements' => array('path' => '.+')],
         ['name' => 'storage#handleHead', 'url' => '/@{userId}/storage{path}', 'verb' => 'HEAD', 'requirements' => array('path' => '.+')],
+
+        ['name' => 'app#appLauncher', 'url' => '/launcher/', 'verb' => 'GET'],
     ]
 ];

solid/composer.json

@@ -3,22 +3,28 @@
     "description": "A WebID-OIDC Identity Provider, to allow interoperability with SolidProject.org",
     "type": "project",
     "license": "MIT",
+    "config": {
+        "platform": {
+            "php": "7.2"
+        }
+    },
     "authors": [
         {
             "name": "Auke van Slooten"
         },
-		{
-			"name": "Yvo Brevoort"
-		}
+        {
+            "name": "Yvo Brevoort"
+        }
     ],
     "require": {
         "easyrdf/easyrdf": "^0.9.1",
         "pdsinterop/flysystem-rdf": "dev-master",
         "pdsinterop/solid-auth": "dev-master",
         "pdsinterop/solid-crud": "dev-master",
         "pdsinterop/flysystem-nextcloud":"dev-master",
-	"laminas/laminas-diactoros": "^2.4",
-        "codercat/jwk-to-pem": "^1.0"
+        "laminas/laminas-diactoros": "^2.4",
+        "codercat/jwk-to-pem": "^1.0",
+        "lcobucci/jwt": "^3.3"
     },
     "require-dev": {
         "phpunit/phpunit": "^5.4"

solid/css/style.css

@@ -1,3 +1,15 @@
-#hello {
-	color: red;
+li.solid-app {
+	padding: 10px;
+	border: 1px solid #ccc;
+	margin: 5px;
 }
+.solid-acl {
+	padding: 2px 6px;
+	margin-right: 4px;
+	border: 1px solid #888;
+	border-radius: 2px;
+	display: inline-block;
+}
+.solid-permissions {
+	margin-bottom: 10px;
+}

solid/js/launcher.js

@@ -0,0 +1,336 @@
+var launcherApi = {};
+var launcher = {};
+
+var loader = function() {
+    editor.data.load({});
+    window.removeEventListener("load", loader);
+}
+window.addEventListener("load", loader);
+
+window.addEventListener("simply-content-loaded", function() {
+    api = {
+        fetcher : false,
+        session : false,
+        getFetcher : function() {
+            return new Promise(function(resolve, reject) {
+                if (!api.fetcher) {
+                    api.fetcher = solidAuthFetcher.customAuthFetcher();
+                }
+                resolve(api.fetcher);
+            });
+        },
+        getSession : function() {
+            if (!api.session) {
+                api.session = solidAuthFetcher.getSession()
+                .then(function(session) {
+                    if (session.loggedIn) {
+                        return session;
+                    } else {
+                        return fetcher.login({
+                            // webId: "https://nextcloud.local/index.php/apps/solid/@alice/turtle#me",
+                            oidcIssuer: 'https://nextcloud.local',
+                            redirect: document.location.href
+                        });
+                    }
+                });
+            }
+            return api.session;
+        },
+        login : function() {
+            return api.getFetcher()
+            .then(function(fetcher) {
+                return api.getSession()
+                .then(function() {
+                    return fetcher;
+                });
+            });
+        },
+        url : "https://nextcloud.local/index.php/apps/solid/@alice/storage/",
+        get : function(path) {
+            return api.login()
+            .then(function(fetcher) {
+                return fetcher.fetch(api.url + path);
+            });
+        },
+        post : function(path, body) {
+            return api.login()
+            .then(function(fetcher) {
+                return fetcher.fetch(api.url + path, {
+                    method: "POST",
+                    body: body
+                });
+            });
+        },
+        put : function(path, body) {
+            return api.login()
+            .then(function(fetcher) {
+                return fetcher.fetch(api.url + path, {
+                    method: "PUT",
+                    body: body
+                });
+            });
+        },
+        delete : function(path) {
+            return api.login()
+            .then(function(fetcher) {
+                return fetcher.fetch(api.url + path, {
+                    method: "DELETE"
+                });
+            });
+        },
+        patch : function(path, body) {
+            return api.login()
+            .then(function(fetcher) {
+                return fetcher.fetch(api.url + path, {
+                    method: "PATCH",
+                    body: body,
+                    headers: {
+                        "Content-type" : "application/sparql-update"
+                    }
+                });
+            });
+        }
+    };
+    launcherApi = {
+        getApps: function() {
+            return new Promise(function(resolve, reject) {
+                var data = document.querySelector("script#apps").innerText;
+                data = JSON.parse(data);
+                resolve(data);
+            });
+        },
+        getPrivateTypeIndex() {
+            return api.get("settings/privateTypeIndex.ttl")
+            .then(function(response) {
+                if (response.status === 200) {
+                    return response.text();
+                }
+                throw new Error("getPrivateTypeIndex failed", response.status);
+            })
+            .then(function(text) {
+                console.log(text);
+            });
+        },
+        createContainer: function(path) {
+            return api.get(path)
+            .then(function(response) {
+                if (response.status != 200) {
+                    // not found, try to create it;
+                    // Create a dummy file to make sure the container is created.
+                    return api.put(path + ".dummy", "");
+                }
+            })
+            .then(function() {
+                return api.get(path);
+            });
+        },
+        createFile : function(filepath, contents) {
+            return api.get(filepath)
+            .then(function(response) {
+                if (response.status != 200) {
+                    return api.put(filepath, contents);
+                }
+            })
+            .then(function() {
+                return api.get(filepath);
+            });
+        },
+        addPodWidePermissions : function(permissions, origin) {
+        },
+        addFilePermissions : function(filename, permissions, origin) {
+            return api.get(filename + ".acl") // FIXME: find the acl file from the Link header;
+            .then(function(response) {
+                if (response.status != 200) {
+                    // generate an acl for this file;
+                } else {
+                    // add permissions to the existing file;
+                }
+            })
+        },
+        addContainerPermissions : function(container, permissions, origin) {
+        },
+        registerClassWithFile : function(resourceClass, filename, public) {
+        },
+        registerClassWithContainer : function(resourceClass, container, public) {
+        }
+    };
+
+    simply.bind = false;
+
+    launcher = simply.app({
+        routes: {
+            '/#launch/:app' : function(params) {
+                editor.pageData.app = params.app;
+                editor.pageData.page = "Launch app";
+            },
+            '/' : function(params) {
+                launcher.actions.getApps();  
+                editor.pageData.page = "Launcher";
+                editor.pageData.pageTitle = "Solid Apps - Nextcloud";
+            }
+        },
+        commands: {
+            allowAndLaunch : function(el) {
+                var launchUrl = el.getAttribute("data-solid-url");
+                var app = editor.pageData.apps.filter(function(app) {
+                    return app.launchUrl == launchUrl;
+                })[0];
+                launcher.actions.preparePod(app);
+                window.open(app.launchUrl);
+            },
+            launch : function(el) {
+                var launchUrl = el.getAttribute("data-solid-url");
+                var app = editor.pageData.apps.filter(function(app) {
+                    return app.launchUrl == launchUrl;
+                })[0];
+                window.open(app.launchUrl);
+            }
+        },
+        actions: {
+            getApps : function() {
+                return launcherApi.getApps()
+                .then(function(apps) {
+                    editor.pageData.apps = apps;
+                });
+            },
+            preparePod : function(appInfo) {
+                appInfo.requirements.forEach(function(requirement) {
+                    switch(requirement['type']) {
+                        case "podWide":
+                            // add podwide permissions as requested by this app - add the origin of the app
+                            launcher.actions.addPodWidePermissions(requirement.permissions, appInfo.appOrigin);
+                        break;
+                        case "container":
+                            // add the container
+                            // add permissions for the container
+                            launcher.actions.createContainer(requirement.container);
+                            launcher.actions.addContainerPermissions(requirement.container, requirement.permissions, appInfo.appOrigin);
+                        break;
+                        case "file":
+                            // add the file
+                            // add permissions to the file
+                            launcher.actions.createFile(requirement.filename);
+                            launcher.actions.addFilePermissions(requirement.filename, requirement.permissions, appInfo.appOrigin);
+                        break;
+                        case "class":
+                            // add the class in the correct type registry (public = true)
+                            if (requirement.filename) {
+                                launcher.actions.registerClassWithFile(requirement.class, requirement.filename, requirement.public);
+                            } else if (requirement.container) {
+                                launcher.actions.registerClassWithContainer(requirement.class, requirement.container, requirement.public);
+                            }
+                        break;
+                        default:
+                            // FIXME: unknown requirement, now what?
+                        break;
+                    }
+                });
+            },
+            createContainer : function(containerPath) {
+                console.log("Create container " + containerPath);
+                return launcherApi.createContainer(containerPath);
+            },
+            createFile : function(filePath) {
+                console.log("Create file " + filePath);
+                return launcherApi.createFile(filePath);
+            },
+            addPodWidePermissions : function(permissions, origin) {
+                console.log("Add pod wide permissions");
+                return launcherApi.addPodWidePermissions(permissions, origin);
+            },
+            addFilePermissions : function(filename, permissions, origin) {
+                console.log("Add file permissions");
+                return launcherApi.addFilePermissions(filename, permissions, origin);
+            },
+            addContainerPermissions : function(container, permissions, origin) {
+                console.log("Add container permissions");
+                return launcherApi.addContainerPermissions(container, permissions, origin);
+            },
+            registerClassWithFile : function(resourceClass, filename, public) {
+                console.log("Register class with file ");
+                return launcherApi.registerClassWithFile(resourceClass, filename, public);
+            },
+            registerClassWithContainer : function(resourceClass, container, public) {
+                console.log("Register class with container ");
+                return launcherApi.registerClassWithContainer(resourceClass, container, public);
+            }
+        }
+    });
+
+    function clone(ob) {
+        return JSON.parse(JSON.stringify(ob));
+    }
+
+    function updateDataSource(name) {
+        document.querySelectorAll('[data-simply-data="'+name+'"]').forEach(function(list) {
+            editor.list.applyDataSource(list, name);
+            list.dataBindingPaused = 0;
+        });
+    };
+});
+
+editor.transformers = {
+    "schemaClass" : {
+        render : function(data) {
+            this.simplyData = data;
+            switch (data) {
+                case "schema.TextDigitalDocument":
+                    return "text files";
+                break;
+                case "http://www.w3.org/2002/01/bookmark#Bookmark":
+                    return "bookmarks";
+                break;
+                default:
+                    return "data";
+                break;
+            }
+        },
+        extract : function(data) {
+            return this.simplyData;
+        }
+    },
+    "registered" : {
+        render: function(data) {
+            this.simplyData = data;
+            if (data == 1) {
+                return "✓"; // checkmark
+            } else {
+                return "";
+            }
+        },
+        extract: function(data) {
+            return this.simplyData;
+        }
+    },
+    "grants" : {
+        render : function(data) {
+            this.simplyData = data;
+            switch (data) {
+                case "acl.Read":
+                    return "Read";
+                break;
+                case "acl.Control":
+                    return "Control access";
+                break;
+                case "acl.Write":
+                    return "Add and delete";
+                break;
+                case "acl.Append":
+                    return "Add";
+                break;
+                default:
+                    return data;
+                break;
+            }
+        },
+        extract : function(data) {
+            return this.simplyData;
+        }
+    }
+};
+
+editor.addDataSource("apps", {
+    load : function(el, callback) {
+        callback(data);
+    }
+});