path: root/html/text_entry_list.js

/**
 * This file is part of Haketilo.
 *
 * Function: Driving a list of editable entries. Used to make UI for management
 *           of repo URLs and script allowing/blocking rules.
 *
 * Copyright (C) 2022 Wojtek Kosior
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * As additional permission under GNU GPL version 3 section 7, you
 * may distribute forms of that code without the copy of the GNU
 * GPL normally required by section 4, provided you include this
 * license notice and, in case of non-source distribution, a URL
 * through which recipients can access the Corresponding Source.
 * If you modify file(s) with this exception, you may extend this
 * exception to your version of the file(s), but you are not
 * obligated to do so. If you do not wish to do so, delete this
 * exception statement from your version.
 *
 * As a special exception to the GPL, any HTML file which merely
 * makes function calls to this code, and for that purpose
 * includes it by reference shall be deemed a separate work for
 * copyright law purposes. If you modify this code, you may extend
 * this exception to your version of the code, but you are not
 * obligated to do so. If you do not wish to do so, delete this
 * exception statement from your version.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * I, Wojtek Kosior, thereby promise not to sue for violation of this file's
 * license. Although I request that you do not make use of this code in a
 * proprietary program, I am not going to enforce this in court.
 */

#IMPORT html/dialog.js
#IMPORT common/indexeddb.js AS haketilodb

#FROM html/DOM_helpers.js IMPORT clone_template
#FROM common/patterns.js  IMPORT validate_normalize_url_pattern

const coll = new Intl.Collator();

function Entry(text, list, entry_idx) {
    Object.assign(this, clone_template("text_entry"));

    const editable = () => list.active_entry === this;
    this.exists = () => text !== null;

    /*
     * Called in the constructor when creating a completely new entry and as a
     * result of clicking on an existing entry in the list.
     */
    this.make_editable = () => {
	if (editable())
	    return;

	if (list.active_entry !== null)
	    list.active_entry.make_noneditable();

	list.active_entry = this;

	this.editable_view.classList.remove("hide");
	this.noneditable_view.classList.add("hide");

	this.input.value = text || "";
    }

    /*
     * Called when 'Cancel' is clicked, when another entry becomes editable and
     * when an entry ends being modified.
     */
    this.make_noneditable = () => {
	if (!editable())
	    return;

	list.active_entry = null;

	if (!this.exists()) {
	    this.main_div.remove();
	    return;
	}

	this.editable_view.classList.add("hide");
	this.noneditable_view.classList.remove("hide");
    }

    /*
     * The *_cb() calls are allowed to throw if an error occurs. It is expected
     * *_cb() will show some dialog that will block other clicks until they
     * returns/throw.
     */

    const add_clicked = async () => {
	if (!editable() || this.exists())
	    return;

	await list.create_cb(this.input.value);
	this.make_noneditable();
    }

    /*
     * Changing entry's text is not handled here, instead we wait for subsequent
     * item removal and creation requests from the outside.
     */
    const save_clicked = async () => {
	if (!editable() || !this.exists())
	    return;

	await list.replace_cb(text, this.input.value);
	this.make_noneditable();
    }

    const enter_hit = () => add_clicked().then(save_clicked);

    /*
     * Removing entry from the list is not handled here, instead we wait for
     * subsequent item removal requests from the outside.
     */
    const remove_clicked = async () => {
	if (editable() || !this.exists())
	    return;

	await list.remove_cb(text);
    }

    /*
     * Called from the outside after the entry got removed from the database. It
     * is assumed entry_exists() is true when this is called.
     */
    this.remove = () => {
	if (editable()) {
	    text = null;
	    this.save_but.classList.add("hide");
	    this.add_but.classList.remove("hide");
	} else {
	    this.main_div.remove();
	}
    }

    if (this.exists()) {
	this.text.innerText = text;
    } else {
	this.save_but.classList.add("hide");
	this.add_but.classList.remove("hide");
	this.make_editable();
    }

    for (const [node, cb] of [
	[this.save_but,         save_clicked],
	[this.add_but,          add_clicked],
	[this.remove_but,       remove_clicked],
	[this.cancel_but,       this.make_noneditable],
	[this.noneditable_view, this.make_editable],
    ])
	node.addEventListener("click", list.dialog_ctx.when_hidden(cb));

    const enter_cb = e => (e.key === 'Enter') && enter_hit();
    this.input.addEventListener("keypress",
				list.dialog_ctx.when_hidden(enter_cb));

    if (entry_idx > 0) {
	const prev_text = list.shown_texts[entry_idx - 1];
	list.entries_by_text.get(prev_text).main_div.after(this.main_div);
    } else {
	if (!editable() && list.active_entry && !list.active_entry.exists())
	    list.active_entry.main_div.after(this.main_div);
	else
	    list.list_div.prepend(this.main_div);
    }
}

function TextEntryList(dialog_ctx, destroy_cb,
		       remove_cb, create_cb, replace_cb) {
    Object.assign(this, {dialog_ctx, remove_cb, create_cb, replace_cb});
    Object.assign(this, clone_template("text_entry_list"));
    this.ul = document.createElement("ul");
    this.shown_texts = [];
    this.entries_by_text = new Map();
    this.active_entry = null;

    const find_entry_idx = text => {
	let left = 0, right = this.shown_texts.length;

	while (left < right) {
	    const mid = (left + right) >> 1;
	    if (coll.compare(text, this.shown_texts[mid]) > 0)
		left = mid + 1;
	    else /* <= 0 */
		right = mid;
	}

	return left;
    }

    this.remove = text => {
	if (!this.entries_by_text.has(text))
	    return;

	this.shown_texts.splice(find_entry_idx(text), 1);
	this.entries_by_text.get(text).remove();
	this.entries_by_text.delete(text)
    }

    this.add = text => {
	if (this.entries_by_text.has(text))
	    return;

	const idx = find_entry_idx(text);
	this.entries_by_text.set(text, new Entry(text, this, idx));
	this.shown_texts.splice(idx, 0, text);
    }

    this.destroy = () => {
	this.main_div.remove();
	destroy_cb();
    }

    const add_new = () => new Entry(null, this, 0);

    this.new_but.addEventListener("click", dialog_ctx.when_hidden(add_new));
}

async function repo_list(dialog_ctx) {
    let list;

    function validate_normalize(repo_url) {
	let error_msg;

	/* In the future we might also try making a test connection. */
	if (!/^https:\/\/[^/.]+\.[^/.]+/.test(repo_url))
	    error_msg = "Provided URL is not valid.";

	if (!/^https:\/\//.test(repo_url))
	    error_msg = "Repository URLs shoud use https:// schema.";

	/* Make exception for localhost while disallowing http://. */
	if (/^http:\/\/(127\.0\.0\.1|localhost)([:/].*)?$/.test(repo_url))
	    error_msg = null;

	if (error_msg) {
	    dialog.error(dialog_ctx, error_msg);
	    throw error_msg;
	}

	return repo_url.replace(/\/*$/, "/");
    }

    async function remove_repo(repo_url) {
	dialog.loader(dialog_ctx, `Removing repository '${repo_url}'...`);

	try {
	    await haketilodb.del_repo(repo_url);
	    var removing_ok = true;
	} finally {
	    if (!removing_ok) {
		dialog.error(dialog_ctx,
			     `Failed to remove repository '${repo_url}' :(`);
	    }

	    dialog.close(dialog_ctx);
	}
    }

    async function create_repo(repo_url) {
	repo_url = validate_normalize(repo_url);

	dialog.loader(dialog_ctx, `Adding repository '${repo_url}'...`);

	try {
	    await haketilodb.set_repo(repo_url);
	    var adding_ok = true;
	} finally {
	    if (!adding_ok)
		dialog.error(dialog_ctx, `Failed to add repository '${repo_url}' :(`);

	    dialog.close(dialog_ctx);
	}
    }

    async function replace_repo(old_repo_url, new_repo_url) {
	if (old_repo_url === new_repo_url)
	    return;

	new_repo_url = validate_normalize(new_repo_url);

	dialog.loader(dialog_ctx, "Replacing repository...");

	try {
	    await haketilodb.set_repo(new_repo_url);
	    await haketilodb.del_repo(old_repo_url);
	    var replacing_ok = true;
	} finally {
	    if (!replacing_ok)
		dialog.error(dialog_ctx, "Failed to replace repository :(");

	    dialog.close(dialog_ctx);
	}
    }

    function onchange(change) {
	if (change.new_val)
	    list.add(change.key);
	else
	    list.remove(change.key);
    }

    dialog.loader(dialog_ctx, "Loading repositories...");
    const [tracking, items] = await haketilodb.track.repo(onchange);
    dialog.close(dialog_ctx);

    list = new TextEntryList(dialog_ctx, () => haketilodb.untrack(tracking),
			     remove_repo, create_repo, replace_repo);

    items.forEach(item => list.add(item.url));

    return list;
}
#EXPORT repo_list

async function blocking_allowing_lists(dialog_ctx) {
    function validate_normalize(url_pattern) {
	try {
	    return validate_normalize_url_pattern(url_pattern);
	} catch(e) {
	    dialog.error(dialog_ctx, e);
	    throw e;
	}
    }

    async function default_allowing_on(url_pattern, allow) {
	dialog.loader(dialog_ctx,
		      `Setting default scripts blocking policy on '${url_pattern}'...`);

	try {
	    await haketilodb.set_default_allowing(url_pattern);
	    var default_allowing_ok = true;
	} finally {
	    if (!default_allowing_ok) {
		dialog.error(dialog_ctx,
			     `Failed to remove rule for '${url_pattern}' :(`);
	    }

	    dialog.close(dialog_ctx);
	}
    }

    async function set_allowing_on(url_pattern, allow) {
	url_pattern = validate_normalize(url_pattern);

	const [action, action_cap] = allow ?
	      ["allowing", "Allowing"] : ["blocking", "Blocking"];
	dialog.loader(dialog_ctx, `${action_cap} scripts on '${url_pattern}'...`);

	try {
	    await haketilodb.set_allowed(url_pattern, allow);
	    var set_allowing_ok = true;
	} finally {
	    if (!set_allowing_ok)
		dialog.error(dialog_ctx,
			     `Failed to write ${action} rule for '${url_pattern}' :(`);

	    dialog.close(dialog_ctx);
	}
    }

    async function replace_allowing_on(old_pattern, new_pattern, allow) {
	new_pattern = validate_normalize(new_pattern);
	if (old_pattern === new_pattern)
	    return;

	const action = allow ? "allowing" : "blocking";
	dialog.loader(dialog_ctx, `Rewriting script ${action} rule...`);

	try {
	    await haketilodb.set_allowed(new_pattern, allow);
	    await haketilodb.set_default_allowing(old_pattern);
	    var replace_allowing_ok = true;
	} finally {
	    if (!replace_allowing_ok)
		dialog.error(dialog_ctx, `Failed to rewrite ${action} rule :(`);

	    dialog.close(dialog_ctx);
	}
    }

    let blocking_list, allowing_list;

    function onchange(change) {
	if (change.new_val) {
	    if (change.new_val.allow)
		var [to_add, to_remove] = [allowing_list, blocking_list];
	    else
		var [to_add, to_remove] = [blocking_list, allowing_list];

	    to_add.add(change.key);
	    to_remove.remove(change.key);
	} else {
	    blocking_list.remove(change.key);
	    allowing_list.remove(change.key);
	}
    }

    dialog.loader(dialog_ctx, "Loading script blocking settings...");
    const [tracking, items] = await haketilodb.track.blocking(onchange);
    dialog.close(dialog_ctx);

    let untrack_called = 0;
    function untrack() {
	if (++untrack_called === 2)
	    haketilodb.untrack(tracking);
    }

    const lists = [];
    for (const allow of [false, true]) {
	lists[allow + 0] =
	    new TextEntryList(dialog_ctx, untrack,
			      pattern => default_allowing_on(pattern),
			      pattern => set_allowing_on(pattern, allow),
			      (p1, p2) => replace_allowing_on(p1, p2, allow));
    }
    [blocking_list, allowing_list] = lists;

    for (const item of items) {
	if (item.allow)
	    allowing_list.add(item.pattern);
	else
	    blocking_list.add(item.pattern);
    }

    return lists;
}
#EXPORT blocking_allowing_lists