From 2e2851dc13d73352530dd4495c7e05603b2e520d Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Wed, 10 Apr 2024 23:38:38 +0200
Subject: Adding upstream version 2.1.2~dev0+20240219.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 deluge/ui/web/js/deluge-all/Client.js | 199 ++++++++++++++++++++++++++++++++++
 1 file changed, 199 insertions(+)
 create mode 100644 deluge/ui/web/js/deluge-all/Client.js

(limited to 'deluge/ui/web/js/deluge-all/Client.js')

diff --git a/deluge/ui/web/js/deluge-all/Client.js b/deluge/ui/web/js/deluge-all/Client.js
new file mode 100644
index 0000000..a06e863
--- /dev/null
+++ b/deluge/ui/web/js/deluge-all/Client.js
@@ -0,0 +1,199 @@
+/**
+ * Deluge.Client.js
+ *
+ * Copyright (c) Damien Churchill 2009-2010 <damoxc@gmail.com>
+ *
+ * This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+ * the additional special exception to link portions of this program with the OpenSSL library.
+ * See LICENSE for more details.
+ */
+Ext.namespace('Ext.ux.util');
+
+/**
+ * A class that connects to a json-rpc resource and adds the available
+ * methods as functions to the class instance.
+ * @class Ext.ux.util.RpcClient
+ * @namespace Ext.ux.util
+ */
+Ext.ux.util.RpcClient = Ext.extend(Ext.util.Observable, {
+    _components: [],
+
+    _methods: [],
+
+    _requests: {},
+
+    _url: null,
+
+    _optionKeys: ['scope', 'success', 'failure'],
+
+    /**
+     * @event connected
+     * Fires when the client has retrieved the list of methods from the server.
+     * @param {Ext.ux.util.RpcClient} this
+     */
+    constructor: function (config) {
+        Ext.ux.util.RpcClient.superclass.constructor.call(this, config);
+        this._url = config.url || null;
+        this._id = 0;
+
+        this.addEvents(
+            // raw events
+            'connected',
+            'error'
+        );
+        this.reloadMethods();
+    },
+
+    reloadMethods: function () {
+        this._execute('system.listMethods', {
+            success: this._setMethods,
+            scope: this,
+        });
+    },
+
+    _execute: function (method, options) {
+        options = options || {};
+        options.params = options.params || [];
+        options.id = this._id;
+
+        var request = Ext.encode({
+            method: method,
+            params: options.params,
+            id: options.id,
+        });
+        this._id++;
+
+        return Ext.Ajax.request({
+            url: this._url,
+            method: 'POST',
+            success: this._onSuccess,
+            failure: this._onFailure,
+            scope: this,
+            jsonData: request,
+            options: options,
+        });
+    },
+
+    _onFailure: function (response, requestOptions) {
+        var options = requestOptions.options;
+        errorObj = {
+            id: options.id,
+            result: null,
+            error: {
+                msg: 'HTTP: ' + response.status + ' ' + response.statusText,
+                code: 255,
+            },
+        };
+
+        this.fireEvent('error', errorObj, response, requestOptions);
+
+        if (Ext.type(options.failure) != 'function') return;
+        if (options.scope) {
+            options.failure.call(
+                options.scope,
+                errorObj,
+                response,
+                requestOptions
+            );
+        } else {
+            options.failure(errorObj, response, requestOptions);
+        }
+    },
+
+    _onSuccess: function (response, requestOptions) {
+        var responseObj = Ext.decode(response.responseText);
+        var options = requestOptions.options;
+        if (responseObj.error) {
+            this.fireEvent('error', responseObj, response, requestOptions);
+
+            if (Ext.type(options.failure) != 'function') return;
+            if (options.scope) {
+                options.failure.call(
+                    options.scope,
+                    responseObj,
+                    response,
+                    requestOptions
+                );
+            } else {
+                options.failure(responseObj, response, requestOptions);
+            }
+        } else {
+            if (Ext.type(options.success) != 'function') return;
+            if (options.scope) {
+                options.success.call(
+                    options.scope,
+                    responseObj.result,
+                    responseObj,
+                    response,
+                    requestOptions
+                );
+            } else {
+                options.success(
+                    responseObj.result,
+                    responseObj,
+                    response,
+                    requestOptions
+                );
+            }
+        }
+    },
+
+    _parseArgs: function (args) {
+        var params = [];
+        Ext.each(args, function (arg) {
+            params.push(arg);
+        });
+
+        var options = params[params.length - 1];
+        if (Ext.type(options) == 'object') {
+            var keys = Ext.keys(options),
+                isOption = false;
+
+            Ext.each(this._optionKeys, function (key) {
+                if (keys.indexOf(key) > -1) isOption = true;
+            });
+
+            if (isOption) {
+                params.remove(options);
+            } else {
+                options = {};
+            }
+        } else {
+            options = {};
+        }
+        options.params = params;
+        return options;
+    },
+
+    _setMethods: function (methods) {
+        var components = {},
+            self = this;
+
+        Ext.each(methods, function (method) {
+            var parts = method.split('.');
+            var component = components[parts[0]] || {};
+
+            var fn = function () {
+                var options = self._parseArgs(arguments);
+                return self._execute(method, options);
+            };
+            component[parts[1]] = fn;
+            components[parts[0]] = component;
+        });
+
+        for (var name in components) {
+            self[name] = components[name];
+        }
+        Ext.each(
+            this._components,
+            function (component) {
+                if (!component in components) {
+                    delete this[component];
+                }
+            },
+            this
+        );
+        this._components = Ext.keys(components);
+        this.fireEvent('connected', this);
+    },
+});
-- 
cgit v1.2.3