From 5355c285fc5dfce3daf945fa6d5080f6c381d1ee Mon Sep 17 00:00:00 2001 From: Arthur Schiwon Date: Tue, 3 Mar 2015 11:56:03 +0100 Subject: LDAP Wizard Overhaul wizard refactor reimplement save spinners and cursor implement Port detector introduced detector queue, added base dn detector disable input fields when detectors are running introduce spinners for fields that are being updated by detector cache jq element objects consolidate processing of detector results in generic / abstract base class display notification if a detector discovered a problem don't run base dn detector if a base is configured reset detector queue on configuration switch implement functionality check and update of status indicator document ConfigModel jsdoc for controller and main view more documentation implement the user filter tab view so far the multiselects get initialized (not filled yet) and the mode can be switched. mode is also restored. reintroduce filter switch confirmation in admin XP mode new detector for user object classes. so we also load user object classes if necessary and are able to save and show the setting. multiselect trigger save actions now on close only show spinners automatically, when a detector is running 20k limit for object classes preselection test adjust wordings, fix grammar add group (for users tab) detector also includes wording fixes error presentation moved from detectors to view, where it belongs add info label to users page missing wording changes show effective LDAP filter in Assisted Mode add user filter detector implement count button for users and limit all count actions to 1001 for performance reasons make port field a bit bigger. not perfect though. do not detect port automatically implement login filter tab view only load features in assisted mode and don't enable assisted fields while in raw mode add tooltips on login filter checkbox options for better understanding permanently show filter on login tab and also compile login filter in assisted mode test/verify button on login attributes tab, with backend changes. only run wizard requests if your an active tab. also run compile filter requests when switching to assisted mode underline toggle filter links to stress that they are clickable unity user and group tab functionality in common abstract class, add group filter tab view. only detectors and template adjustments left to have group tab implementation complete add object class and group detector for groups as well as filter composer show ldap filter permanently on groups tab introduce input element that can deal better with many groups, will be used with > 40 fix disabling complex group chooser while detection is running hide complex group chooser on config switch fix few more issues with complex chooser make complex group chooser available on Users tab as well detect base dn improvements/changes: - do not look for Base DN automatically, offer a button instead - fix for alternative way to detect a base dn (if agent dn is not given) - do not trigger filter composers on config switch Changes with configuration chooser controls - "New" was removed out of the configuration list - and split into buttons "add" and "copy" - delete button is also now an icon add test button for Base DN reimplement advanced tab. The save button is gone. reimplement expert tab remove unused methods implement mail attribute detector implement user display name attribute detection implement member group association detector replace text input with textarea for raw filter input finish functionality check auto-enable good configurations, as it was before cleanup move save confirmation handling to base class, reduces code duplication enable tabs only if no running save processes are left. move onConfigLoaded to base class, avoids code duplication simplify, save LOCs Test Configuration button to be dealt with in main view as it is a cross-tab element require detectorQueue in constructor cleanup put bootstrap into a function and thus make it testable get rid of old stuff --- apps/user_ldap/js/wizard/configModel.js | 606 +++++++++++++++++++++ apps/user_ldap/js/wizard/controller.js | 56 ++ apps/user_ldap/js/wizard/view.js | 433 +++++++++++++++ apps/user_ldap/js/wizard/wizard.js | 80 +++ .../js/wizard/wizardDetectorAvailableAttributes.js | 59 ++ apps/user_ldap/js/wizard/wizardDetectorBaseDN.js | 52 ++ .../js/wizard/wizardDetectorClearGroupMappings.js | 30 + .../js/wizard/wizardDetectorClearUserMappings.js | 30 + .../js/wizard/wizardDetectorEmailAttribute.js | 38 ++ .../js/wizard/wizardDetectorFeatureAbstract.js | 52 ++ .../js/wizard/wizardDetectorFilterGroup.js | 31 ++ .../js/wizard/wizardDetectorFilterLogin.js | 32 ++ .../js/wizard/wizardDetectorFilterUser.js | 31 ++ apps/user_ldap/js/wizard/wizardDetectorGeneric.js | 117 ++++ .../js/wizard/wizardDetectorGroupCount.js | 27 + .../js/wizard/wizardDetectorGroupObjectClasses.js | 29 + .../js/wizard/wizardDetectorGroupsForGroups.js | 29 + .../js/wizard/wizardDetectorGroupsForUsers.js | 29 + apps/user_ldap/js/wizard/wizardDetectorPort.js | 44 ++ apps/user_ldap/js/wizard/wizardDetectorQueue.js | 89 +++ .../wizard/wizardDetectorSimpleRequestAbstract.js | 44 ++ .../js/wizard/wizardDetectorTestAbstract.js | 63 +++ .../js/wizard/wizardDetectorTestBaseDN.js | 29 + .../js/wizard/wizardDetectorTestConfiguration.js | 31 ++ .../js/wizard/wizardDetectorTestLoginName.js | 30 + .../user_ldap/js/wizard/wizardDetectorUserCount.js | 26 + .../wizardDetectorUserDisplayNameAttribute.js | 39 ++ .../wizard/wizardDetectorUserGroupAssociation.js | 40 ++ .../js/wizard/wizardDetectorUserObjectClasses.js | 29 + apps/user_ldap/js/wizard/wizardFilterOnType.js | 76 +++ .../js/wizard/wizardFilterOnTypeFactory.js | 27 + apps/user_ldap/js/wizard/wizardObject.js | 60 ++ .../user_ldap/js/wizard/wizardTabAbstractFilter.js | 373 +++++++++++++ apps/user_ldap/js/wizard/wizardTabAdvanced.js | 330 +++++++++++ apps/user_ldap/js/wizard/wizardTabElementary.js | 346 ++++++++++++ apps/user_ldap/js/wizard/wizardTabExpert.js | 130 +++++ apps/user_ldap/js/wizard/wizardTabGeneric.js | 547 +++++++++++++++++++ apps/user_ldap/js/wizard/wizardTabGroupFilter.js | 124 +++++ apps/user_ldap/js/wizard/wizardTabLoginFilter.js | 235 ++++++++ apps/user_ldap/js/wizard/wizardTabUserFilter.js | 136 +++++ 40 files changed, 4609 insertions(+) create mode 100644 apps/user_ldap/js/wizard/configModel.js create mode 100644 apps/user_ldap/js/wizard/controller.js create mode 100644 apps/user_ldap/js/wizard/view.js create mode 100644 apps/user_ldap/js/wizard/wizard.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorAvailableAttributes.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorBaseDN.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorClearGroupMappings.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorClearUserMappings.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorEmailAttribute.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorFeatureAbstract.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorFilterGroup.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorFilterLogin.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorFilterUser.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorGeneric.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorGroupCount.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorGroupObjectClasses.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorGroupsForGroups.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorGroupsForUsers.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorPort.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorQueue.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorSimpleRequestAbstract.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorTestAbstract.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorTestBaseDN.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorTestConfiguration.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorTestLoginName.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorUserCount.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorUserDisplayNameAttribute.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorUserGroupAssociation.js create mode 100644 apps/user_ldap/js/wizard/wizardDetectorUserObjectClasses.js create mode 100644 apps/user_ldap/js/wizard/wizardFilterOnType.js create mode 100644 apps/user_ldap/js/wizard/wizardFilterOnTypeFactory.js create mode 100644 apps/user_ldap/js/wizard/wizardObject.js create mode 100644 apps/user_ldap/js/wizard/wizardTabAbstractFilter.js create mode 100644 apps/user_ldap/js/wizard/wizardTabAdvanced.js create mode 100644 apps/user_ldap/js/wizard/wizardTabElementary.js create mode 100644 apps/user_ldap/js/wizard/wizardTabExpert.js create mode 100644 apps/user_ldap/js/wizard/wizardTabGeneric.js create mode 100644 apps/user_ldap/js/wizard/wizardTabGroupFilter.js create mode 100644 apps/user_ldap/js/wizard/wizardTabLoginFilter.js create mode 100644 apps/user_ldap/js/wizard/wizardTabUserFilter.js (limited to 'apps/user_ldap/js/wizard') diff --git a/apps/user_ldap/js/wizard/configModel.js b/apps/user_ldap/js/wizard/configModel.js new file mode 100644 index 00000000000..c3f1e85b592 --- /dev/null +++ b/apps/user_ldap/js/wizard/configModel.js @@ -0,0 +1,606 @@ +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc this class represents a server configuration. It communicates + * with the ownCloud server to ensure to always have the up to date LDAP + * configuration. It sends various events that views can listen to and + * provides methods so they can modify the configuration based upon user + * input. This model is also extended by so-called "detectors" who let the + * ownCloud server try to auto-detect settings and manipulate the + * configuration as well. + * + * @constructor + */ + var ConfigModel = function() {}; + + ConfigModel.prototype = { + /** @constant {number} */ + FILTER_MODE_ASSISTED: 0, + /** @constant {number} */ + FILTER_MODE_RAW: 1, + + /** + * initializes the instance. Always call it after creating the instance. + * + * @param {OCA.LDAP.Wizard.WizardDetectorQueue} detectorQueue + */ + init: function (detectorQueue) { + /** @type {object} holds the configuration in key-value-pairs */ + this.configuration = {}; + /** @type {object} holds the subscribers that listen to the events */ + this.subscribers = {}; + /** @type {Array} holds registered detectors */ + this.detectors = []; + /** @type {boolean} whether a configuration is currently loading */ + this.loadingConfig = false; + + if(detectorQueue instanceof OCA.LDAP.Wizard.WizardDetectorQueue) { + /** @type {OCA.LDAP.Wizard.WizardDetectorQueue} */ + this.detectorQueue = detectorQueue; + } + }, + + /** + * loads a specified configuration + * + * @param {string} [configID] - the configuration id (or prefix) + */ + load: function (configID) { + if(this.loadingConfig) { + return; + } + this._resetDetectorQueue(); + + this.configID = configID; + var url = OC.generateUrl('apps/user_ldap/ajax/getConfiguration.php'); + var params = OC.buildQueryString({ldap_serverconfig_chooser: configID}); + this.loadingConfig = true; + var model = this; + $.post(url, params, function (result) { model._processLoadConfig(model, result) }); + }, + + /** + * creates a new LDAP configuration + * + * @param {boolean} [copyCurrent] - if true, the current configuration + * is copied, otherwise a blank one is created. + */ + newConfig: function(copyCurrent) { + this._resetDetectorQueue(); + + var url = OC.generateUrl('apps/user_ldap/ajax/getNewServerConfigPrefix.php'); + var params = {}; + if(copyCurrent === true) { + params['copyConfig'] = this.configID; + } + params = OC.buildQueryString(params); + var model = this; + copyCurrent = _.isUndefined(copyCurrent) ? false : copyCurrent; + $.post(url, params, function (result) { model._processNewConfigPrefix(model, result, copyCurrent) }); + }, + + /** + * deletes the current configuration. This method will not ask for + * confirmation, if desired it needs to be ensured by the caller. + * + * @param {string} [configID] - the configuration id (or prefix) + */ + deleteConfig: function(configID) { + var url = OC.generateUrl('apps/user_ldap/ajax/deleteConfiguration.php'); + var params = OC.buildQueryString({ldap_serverconfig_chooser: configID}); + var model = this; + $.post(url, params, function (result) { model._processDeleteConfig(model, result, configID) }); + }, + + /** + * @callback wizardCallBack + * @param {ConfigModel} [model] + * @param {OCA.LDAP.Wizard.WizardDetectorGeneric} [detector] + * @param {object} [result] - response from the ajax request + */ + + /** + * calls an AJAX endpoint at ownCloud. This method should be called by + * detectors only! + * + * @param {string} [params] - as return by OC.buildQueryString + * @param {wizardCallBack} [callback] + * @param {OCA.LDAP.Wizard.WizardDetectorGeneric} [detector] + * @returns {jqXHR} + */ + callWizard: function(params, callback, detector) { + return this.callAjax('wizard.php', params, callback, detector); + }, + + /** + * calls an AJAX endpoint at ownCloud. This method should be called by + * detectors only! + * + * @param {string} destination - the desired end point + * @param {string} [params] - as return by OC.buildQueryString + * @param {wizardCallBack} [callback] + * @param {OCA.LDAP.Wizard.WizardDetectorGeneric} [detector] + * @returns {jqXHR} + */ + callAjax: function(destination, params, callback, detector) { + var url = OC.generateUrl('apps/user_ldap/ajax/' + destination); + var model = this; + return $.post(url, params, function (result) { + callback(model, detector,result); + }); + }, + + /** + * setRequested Event + * + * @event ConfigModel#setRequested + * @type{object} - empty + */ + + /** + * modifies a configuration key. If a provided configuration key does + * not exist or the provided value equals the current setting, false is + * returned. Otherwise ownCloud server will be called to save the new + * value, an event will notify when this is done. True is returned when + * the request is sent, however it does not mean whether saving was + * successful or not. + * + * This method is supposed to be called by views, after the user did a + * change which needs to be saved. + * + * @param {string} [key] + * @param {string|number} [value] + * @returns {boolean} + * @fires {ConfigModel#setRequested} + */ + set: function(key, value) { + if(_.isUndefined(this.configuration[key])) { + console.warn('will not save undefined key: ' + key); + return false; + } + if(this.configuration[key] === value) { + return false; + } + this._broadcast('setRequested', {}); + var url = OC.generateUrl('apps/user_ldap/ajax/wizard.php'); + var objParams = { + ldap_serverconfig_chooser: this.configID, + action: 'save', + cfgkey: key, + cfgval: value + }; + var strParams = OC.buildQueryString(objParams); + var model = this; + $.post(url, strParams, function(result) { model._processSetResult(model, result, objParams) }); + return true; + }, + + /** + * configUpdated Event + * + * object property is a key-value-pair of the configuration key as index + * and its value. + * + * @event ConfigModel#configUpdated + * @type{object} + */ + + /** + * updates the model's configuration data. This should be called only, + * when a new configuration value was received from the ownCloud server. + * This is typically done by detectors, but never by views. + * + * Cancels with false if old and new values already match. + * + * @param {string} [key] + * @param {string} [value] + * @returns {boolean} + * @fires ConfigModel#configUpdated + */ + update: function(key, value) { + if(this.configuration[key] === value) { + return false; + } + if(!_.isUndefined(this.configuration[key])) { + // don't write e.g. count values to the configuration + // they don't go as feature, yet + this.configuration[key] = value; + } + var configPart = {}; + configPart[key] = value; + this._broadcast('configUpdated', configPart); + }, + + /** + * @typedef {object} FeaturePayload + * @property {string} feature + * @property {Array} data + */ + + /** + * informs about a detected LDAP "feature" (wider sense). For examples, + * the detected object classes for users or groups + * + * @param {FeaturePayload} payload + */ + inform: function(payload) { + this._broadcast('receivedLdapFeature', payload); + }, + + /** + * @typedef {object} ErrorPayload + * @property {string} message + * @property {string} relatedKey + */ + + /** + * broadcasts an error message, if a wizard reply ended up in an error. + * To be called by detectors. + * + * @param {ErrorPayload} payload + */ + gotServerError: function(payload) { + this._broadcast('serverError', payload); + }, + + /** + * detectionStarted Event + * + * @event ConfigModel#detectionStarted + * @type{string} - the target configuration key that is being + * auto-detected + */ + + /** + * lets the model broadcast the info that a detector starts to run + * + * supposed to be called by detectors only + * + * @param {string} [key] + * @fires ConfigModel#detectionStarted + */ + notifyAboutDetectionStart: function(key) { + this._broadcast('detectionStarted', key); + }, + + /** + * detectionCompleted Event + * + * @event ConfigModel#detectionCompleted + * @type{string} - the target configuration key that was + * auto-detected + */ + + /** + * lets the model broadcast the info that a detector run was completed + * + * supposed to be called by detectors only + * + * @param {string} [key] + * @fires ConfigModel#detectionCompleted + */ + notifyAboutDetectionCompletion: function(key) { + this._broadcast('detectionCompleted', key); + }, + + /** + * @callback listenerCallback + * @param {OCA.LDAP.Wizard.WizardTabGeneric|OCA.LDAP.Wizard.WizardView} [view] + * @param {object} [params] + */ + + /** + * registers a listener to an event + * + * the idea is that only views listen. + * + * @param {string} [name] - the event name + * @param {listenerCallback} [fn] + * @param {OCA.LDAP.Wizard.WizardTabGeneric|OCA.LDAP.Wizard.WizardView} [context] + */ + on: function(name, fn, context) { + if(_.isUndefined(this.subscribers[name])) { + this.subscribers[name] = []; + } + this.subscribers[name].push({fn: fn, context: context}); + }, + + /** + * starts a configuration test on the ownCloud server + */ + requestConfigurationTest: function() { + var url = OC.generateUrl('apps/user_ldap/ajax/testConfiguration.php'); + var params = OC.buildQueryString(this.configuration); + var model = this; + $.post(url, params, function(result) { model._processTestResult(model, result) }); + //TODO: make sure only one test is running at a time + }, + + /** + * the view may request a call to the wizard, for instance to fetch + * object classes or groups + * + * @param {string} featureKey + * @param {Object} [additionalParams] + */ + requestWizard: function(featureKey, additionalParams) { + var model = this; + var detectorCount = this.detectors.length; + var found = false; + for(var i = 0; i < detectorCount; i++) { + if(this.detectors[i].runsOnFeatureRequest(featureKey)) { + found = true; + (function (detector) { + model.detectorQueue.add(function() { + return detector.run(model, model.configID, additionalParams); + }); + })(model.detectors[i]); + } + } + if(!found) { + console.warn('No detector found for feature ' + featureKey); + } + }, + + /** + * resets the detector queue + * + * @private + */ + _resetDetectorQueue: function() { + if(!_.isUndefined(this.detectorQueue)) { + this.detectorQueue.reset(); + } + }, + + /** + * detectors can be registered herewith + * + * @param {OCA.LDAP.Wizard.WizardDetectorGeneric} [detector] + */ + registerDetector: function(detector) { + if(detector instanceof OCA.LDAP.Wizard.WizardDetectorGeneric) { + this.detectors.push(detector); + } + }, + + /** + * emits an event + * + * @param {string} [name] - the event name + * @param {*} [params] + * @private + */ + _broadcast: function(name, params) { + if(_.isUndefined(this.subscribers[name])) { + return; + } + var subscribers = this.subscribers[name]; + var subscriberCount = subscribers.length; + for(var i = 0; i < subscriberCount; i++) { + if(_.isUndefined(subscribers[i]['fn'])) { + console.warn('callback method is not defined. Event ' + name); + continue; + } + subscribers[i]['fn'](subscribers[i]['context'], params); + } + }, + + /** + * ConfigModel#configLoaded Event + * + * @event ConfigModel#configLoaded + * @type {object} - LDAP configuration as key-value-pairs + */ + + /** + * @typedef {object} ConfigLoadResponse + * @property {string} [status] + * @property {object} [configuration] - only present if status equals 'success' + */ + + /** + * processes the ajax response of a configuration load request + * + * @param {ConfigModel} [model] + * @param {ConfigLoadResponse} [result] + * @fires ConfigModel#configLoaded + * @private + */ + _processLoadConfig: function(model, result) { + model.configuration = {}; + if(result['status'] === 'success') { + $.each(result['configuration'], function(key, value) { + model.configuration[key] = value; + }); + } + model.loadingConfig = false; + model._broadcast('configLoaded', model.configuration); + }, + + /** + * @typedef {object} ConfigSetPayload + * @property {boolean} [isSuccess] + * @property {string} [key] + * @property {string} [value] + * @property {string} [errorMessage] + */ + + /** + * ConfigModel#setCompleted Event + * + * @event ConfigModel#setCompleted + * @type {ConfigSetPayload} + */ + + /** + * @typedef {object} ConfigSetResponse + * @property {string} [status] + * @property {object} [message] - might be present only in error cases + */ + + /** + * processes the ajax response of a configuration key set request + * + * @param {ConfigModel} [model] + * @param {ConfigSetResponse} [result] + * @param {object} [params] - the original changeSet + * @fires ConfigModel#configLoaded + * @private + */ + _processSetResult: function(model, result, params) { + var isSuccess = (result['status'] === 'success'); + if(isSuccess) { + model.configuration[params.cfgkey] = params.cfgval; + } + var payload = { + isSuccess: isSuccess, + key: params.cfgkey, + value: model.configuration[params.cfgkey], + errorMessage: _.isUndefined(result['message']) ? '' : result['message'] + }; + model._broadcast('setCompleted', payload); + + // let detectors run + // NOTE: detector's changes will not result in new _processSetResult + // calls, … in case they interfere it is because of this ;) + if(_.isUndefined(model.detectorQueue)) { + console.warn("DetectorQueue was not set, detectors will not be fired"); + return; + } + var detectorCount = model.detectors.length; + for(var i = 0; i < detectorCount; i++) { + if(model.detectors[i].triggersOn(params.cfgkey)) { + (function (detector) { + model.detectorQueue.add(function() { + return detector.run(model, model.configID); + }); + })(model.detectors[i]); + } + } + }, + + /** + * @typedef {object} ConfigTestPayload + * @property {boolean} [isSuccess] + */ + + /** + * ConfigModel#configurationTested Event + * + * @event ConfigModel#configurationTested + * @type {ConfigTestPayload} + */ + + /** + * @typedef {object} StatusResponse + * @property {string} [status] + */ + + /** + * processes the ajax response of a configuration test request + * + * @param {ConfigModel} [model] + * @param {StatusResponse} [result] + * @fires ConfigModel#configurationTested + * @private + */ + _processTestResult: function(model, result) { + var payload = { + isSuccess: (result['status'] === 'success') + }; + model._broadcast('configurationTested', payload); + }, + + /** + * @typedef {object} BasicConfigPayload + * @property {boolean} [isSuccess] + * @property {string} [configPrefix] - the new config ID + * @property {string} [errorMessage] + */ + + /** + * ConfigModel#newConfiguration Event + * + * @event ConfigModel#newConfiguration + * @type {BasicConfigPayload} + */ + + /** + * @typedef {object} NewConfigResponse + * @property {string} [status] + * @property {string} [configPrefix] + * @property {object} [defaults] - default configuration values + * @property {string} [message] - might only appear with status being + * not 'success' + */ + + /** + * processes the ajax response of a new configuration request + * + * @param {ConfigModel} [model] + * @param {NewConfigResponse} [result] + * @param {boolean} [copyCurrent] + * @fires ConfigModel#newConfiguration + * @fires ConfigModel#configLoaded + * @private + */ + _processNewConfigPrefix: function(model, result, copyCurrent) { + var isSuccess = (result['status'] === 'success'); + var payload = { + isSuccess: isSuccess, + configPrefix: result['configPrefix'], + errorMessage: _.isUndefined(result['message']) ? '' : result['message'] + }; + model._broadcast('newConfiguration', payload); + + if(isSuccess) { + this.configID = result['configPrefix']; + if(!copyCurrent) { + model.configuration = {}; + $.each(result['defaults'], function(key, value) { + model.configuration[key] = value; + }); + // view / tabs need to update with new blank config + model._broadcast('configLoaded', model.configuration); + } + } + }, + + /** + * ConfigModel#deleteConfiguration Event + * + * @event ConfigModel#deleteConfiguration + * @type {BasicConfigPayload} + */ + + /** + * processes the ajax response of a delete configuration request + * + * @param {ConfigModel} [model] + * @param {StatusResponse} [result] + * @param {string} [configID] + * @fires ConfigModel#deleteConfiguration + * @private + */ + _processDeleteConfig: function(model, result, configID) { + var isSuccess = (result['status'] === 'success'); + var payload = { + isSuccess: isSuccess, + configPrefix: configID, + errorMessage: _.isUndefined(result['message']) ? '' : result['message'] + }; + model._broadcast('deleteConfiguration', payload); + } + }; + + OCA.LDAP.Wizard.ConfigModel = ConfigModel; +})(); diff --git a/apps/user_ldap/js/wizard/controller.js b/apps/user_ldap/js/wizard/controller.js new file mode 100644 index 00000000000..7c1f0d5d818 --- /dev/null +++ b/apps/user_ldap/js/wizard/controller.js @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; +OCA.LDAP = {}; +OCA.LDAP.Wizard = {}; + +(function(){ + + /** + * @classdesc minimalistic controller that basically makes the view render + * + * @constructor + */ + var WizardController = function() {}; + + WizardController.prototype = { + /** + * initializes the instance. Always call it after creating the instance. + */ + init: function() { + this.view = false; + this.configModel = false; + }, + + /** + * sets the model instance + * + * @param {OCA.LDAP.Wizard.ConfigModel} [model] + */ + setModel: function(model) { + this.configModel = model; + }, + + /** + * sets the view instance + * + * @param {OCA.LDAP.Wizard.WizardView} [view] + */ + setView: function(view) { + this.view = view; + }, + + /** + * makes the view render i.e. ready to be used + */ + run: function() { + this.view.render(); + } + }; + + OCA.LDAP.Wizard.Controller = WizardController; +})(); diff --git a/apps/user_ldap/js/wizard/view.js b/apps/user_ldap/js/wizard/view.js new file mode 100644 index 00000000000..8eb10c58017 --- /dev/null +++ b/apps/user_ldap/js/wizard/view.js @@ -0,0 +1,433 @@ +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc main view class. It takes care of tab-unrelated control + * elements (status bar, control buttons) and does or requests configuration + * checks. It also manages the separate tab views. + * + * @constructor + */ + var WizardView = function() {}; + + WizardView.prototype = { + /** @constant {number} */ + STATUS_ERROR: 0, + /** @constant {number} */ + STATUS_INCOMPLETE: 1, + /** @constant {number} */ + STATUS_SUCCESS: 2, + + /** + * initializes the instance. Always call it after creating the instance. + */ + init: function () { + this.tabs = {}; + this.tabs.server = new OCA.LDAP.Wizard.WizardTabElementary(); + this.$settings = $('#ldapSettings'); + this.$saveSpinners = $('.ldap_saving'); + this.saveProcesses = 0; + _.bindAll(this, 'onTabChange', 'onTestButtonClick'); + }, + + /** + * applies click events to the forward and backword buttons + */ + initControls: function() { + var view = this; + $('.ldap_action_continue').click(function(event) { + event.preventDefault(); + view._controlContinue(view); + }); + + $('.ldap_action_back').click(function(event) { + event.preventDefault(); + view._controlBack(view); + }); + + $('.ldap_action_test_connection').click(this.onTestButtonClick); + }, + + /** + * registers a tab + * + * @param {OCA.LDAP.Wizard.WizardTabGeneric} tabView + * @param {string} index + * @returns {boolean} + */ + registerTab: function(tabView, index) { + if( _.isUndefined(this.tabs[index]) + && tabView instanceof OCA.LDAP.Wizard.WizardTabGeneric + ) { + this.tabs[index] = tabView; + this.tabs[index].setModel(this.configModel); + return true; + } + return false; + }, + + /** + * checks certain config values for completeness and depending on them + * enables or disables non-elementary tabs. + */ + basicStatusCheck: function(view) { + var host = view.configModel.configuration.ldap_host; + var port = view.configModel.configuration.ldap_port; + var base = view.configModel.configuration.ldap_base; + var agent = view.configModel.configuration.ldap_dn; + var pwd = view.configModel.configuration.ldap_agent_password; + + if((host && port && base) && ((!agent && !pwd) || (agent && pwd))) { + view.enableTabs(); + } else { + view.disableTabs(); + } + }, + + /** + * if the configuration is sufficient the model is being request to + * perform a configuration test. Otherwise, the status indicator is + * being updated with the status "incomplete" + */ + functionalityCheck: function() { + // this method should be called only if necessary, because it may + // cause an LDAP request! + var host = this.configModel.configuration.ldap_host; + var port = this.configModel.configuration.ldap_port; + var base = this.configModel.configuration.ldap_base; + var userFilter = this.configModel.configuration.ldap_userlist_filter; + var loginFilter = this.configModel.configuration.ldap_login_filter; + + if(host && port && base && userFilter && loginFilter) { + this.configModel.requestConfigurationTest(); + } else { + this._updateStatusIndicator(this.STATUS_INCOMPLETE); + } + }, + + /** + * will request a functionality check if one of the related configuration + * settings was changed. + * + * @param {ConfigSetPayload|Object} [changeSet] + */ + considerFunctionalityCheck: function(changeSet) { + var testTriggers = [ + 'ldap_host', 'ldap_port', 'ldap_dn', 'ldap_agent_password', + 'ldap_base', 'ldap_userlist_filter', 'ldap_login_filter' + ]; + for(var key in changeSet) { + if($.inArray(key, testTriggers)) { + this.functionalityCheck(); + return; + } + } + }, + + /** + * keeps number of running save processes and shows a spinner if + * necessary + * + * @param {WizardView} [view] + * @listens ConfigModel#setRequested + */ + onSetRequested: function(view) { + view.saveProcesses += 1; + if(view.saveProcesses === 1) { + view.showSaveSpinner(); + } + }, + + /** + * keeps number of running save processes and hides the spinner if + * necessary. Also triggers checks, to adjust tabs state and status bar. + * + * @param {WizardView} [view] + * @param {ConfigSetPayload} [result] + * @listens ConfigModel#setCompleted + */ + onSetRequestDone: function(view, result) { + if(view.saveProcesses > 0) { + view.saveProcesses -= 1; + if(view.saveProcesses === 0) { + view.hideSaveSpinner(); + } + } + + view.basicStatusCheck(view); + var param = {}; + param[result.key] = 1; + view.considerFunctionalityCheck(param); + }, + + /** + * updates the status indicator based on the configuration test result + * + * @param {WizardView} [view] + * @param {ConfigTestPayload} [result] + * @listens ConfigModel#configurationTested + */ + onTestCompleted: function(view, result) { + if(result.isSuccess) { + view._updateStatusIndicator(view.STATUS_SUCCESS); + } else { + view._updateStatusIndicator(view.STATUS_ERROR); + } + }, + + /** + * triggers initial checks upon configuration loading to update status + * controls + * + * @param {WizardView} [view] + * @listens ConfigModel#configLoaded + */ + onConfigLoaded: function(view) { + view.basicStatusCheck(view); + view.functionalityCheck(); + }, + + /** + * reacts on attempts to switch to a different tab + * + * @param {object} event + * @param {object} ui + * @returns {boolean} + */ + onTabChange: function(event, ui) { + if(this.saveProcesses > 0) { + return false; + } + + var newTabID = ui.newTab[0].id; + if(newTabID === '#ldapWizard1') { + newTabID = 'server'; + } + var oldTabID = ui.oldTab[0].id; + if(oldTabID === '#ldapWizard1') { + oldTabID = 'server'; + } + if(!_.isUndefined(this.tabs[newTabID])) { + this.tabs[newTabID].isActive = true; + this.tabs[newTabID].onActivate(); + } else { + console.warn('Unreferenced activated tab ' + newTabID); + } + if(!_.isUndefined(this.tabs[oldTabID])) { + this.tabs[oldTabID].isActive = false; + } else { + console.warn('Unreferenced left tab ' + oldTabID); + } + }, + + /** + * triggers checks upon configuration updates to keep status controls + * up to date + * + * @param {WizardView} [view] + * @param {object} [changeSet] + * @listens ConfigModel#configUpdated + */ + onConfigUpdated: function(view, changeSet) { + view.basicStatusCheck(view); + view.considerFunctionalityCheck(changeSet); + }, + + /** + * requests a configuration test + */ + onTestButtonClick: function() { + this.configModel.requestWizard('ldap_action_test_connection', this.configModel.configuration); + }, + + /** + * sets the model instance and registers event listeners + * + * @param {OCA.LDAP.Wizard.ConfigModel} [configModel] + */ + setModel: function(configModel) { + /** @type {OCA.LDAP.Wizard.ConfigModel} */ + this.configModel = configModel; + for(var i in this.tabs) { + this.tabs[i].setModel(configModel); + } + + // make sure this is definitely run after tabs did their work, order is important here + // for now this works, because tabs are supposed to register their listeners in their + // setModel() method. + // alternative: make Elementary Tab a Publisher as well. + this.configModel.on('configLoaded', this.onConfigLoaded, this); + this.configModel.on('configUpdated', this.onConfigUpdated, this); + this.configModel.on('setRequested', this.onSetRequested, this); + this.configModel.on('setCompleted', this.onSetRequestDone, this); + this.configModel.on('configurationTested', this.onTestCompleted, this); + }, + + /** + * enables tab and navigation buttons + */ + enableTabs: function() { + //do not use this function directly, use basicStatusCheck instead. + if(this.saveProcesses === 0) { + $('.ldap_action_continue').removeAttr('disabled'); + $('.ldap_action_back').removeAttr('disabled'); + this.$settings.tabs('option', 'disabled', []); + } + }, + + /** + * disables tab and navigation buttons + */ + disableTabs: function() { + $('.ldap_action_continue').attr('disabled', 'disabled'); + $('.ldap_action_back').attr('disabled', 'disabled'); + this.$settings.tabs('option', 'disabled', [1, 2, 3, 4, 5]); + }, + + /** + * shows a save spinner + */ + showSaveSpinner: function() { + this.$saveSpinners.removeClass('hidden'); + $('#ldap *').addClass('save-cursor'); + }, + + /** + * hides the save spinner + */ + hideSaveSpinner: function() { + this.$saveSpinners.addClass('hidden'); + $('#ldap *').removeClass('save-cursor'); + }, + + /** + * performs a config load request to the model + * + * @param {string} [configID] + * @private + */ + _requestConfig: function(configID) { + this.configModel.load(configID); + }, + + /** + * bootstraps the visual appearance and event listeners, as well as the + * first config + */ + render: function () { + $('#ldapAdvancedAccordion').accordion({ heightStyle: 'content', animate: 'easeInOutCirc'}); + this.$settings.tabs({}); + $('.ldap_submit').button(); + $('.ldap_action_test_connection').button(); + $('#ldapSettings').tabs({ beforeActivate: this.onTabChange }); + + this.initControls(); + this.disableTabs(); + + this._requestConfig(this.tabs.server.getConfigID()); + }, + + /** + * updates the status indicator / bar + * + * @param {number} [state] + * @private + */ + _updateStatusIndicator: function(state) { + var $indicator = $('.ldap_config_state_indicator'); + var $indicatorLight = $('.ldap_config_state_indicator_sign'); + + switch(state) { + case this.STATUS_ERROR: + $indicator.text(t('user_ldap', + 'Configuration incorrect' + )); + $indicator.removeClass('ldap_grey'); + $indicatorLight.addClass('error'); + $indicatorLight.removeClass('success'); + break; + case this.STATUS_INCOMPLETE: + $indicator.text(t('user_ldap', + 'Configuration incomplete' + )); + $indicator.removeClass('ldap_grey'); + $indicatorLight.removeClass('error'); + $indicatorLight.removeClass('success'); + break; + case this.STATUS_SUCCESS: + $indicator.text(t('user_ldap', 'Configuration OK')); + $indicator.addClass('ldap_grey'); + $indicatorLight.removeClass('error'); + $indicatorLight.addClass('success'); + if(!this.tabs.server.isActive) { + this.configModel.set('ldap_configuration_active', 1); + } + break; + } + }, + + /** + * handles a click on the Back button + * + * @param {WizardView} [view] + * @private + */ + _controlBack: function(view) { + var curTabIndex = view.$settings.tabs('option', 'active'); + if(curTabIndex == 0) { + return; + } + view.$settings.tabs('option', 'active', curTabIndex - 1); + view._controlUpdate(curTabIndex - 1); + }, + + /** + * handles a click on the Continue button + * + * @param {WizardView} [view] + * @private + */ + _controlContinue: function(view) { + var curTabIndex = view.$settings.tabs('option', 'active'); + if(curTabIndex == 3) { + return; + } + view.$settings.tabs('option', 'active', 1 + curTabIndex); + view._controlUpdate(curTabIndex + 1); + }, + + /** + * updates the controls (navigation buttons) + * + * @param {number} [nextTabIndex] - index of the tab being switched to + * @private + */ + _controlUpdate: function(nextTabIndex) { + if(nextTabIndex == 0) { + $('.ldap_action_back').addClass('invisible'); + $('.ldap_action_continue').removeClass('invisible'); + } else + if(nextTabIndex == 1) { + $('.ldap_action_back').removeClass('invisible'); + $('.ldap_action_continue').removeClass('invisible'); + } else + if(nextTabIndex == 2) { + $('.ldap_action_continue').removeClass('invisible'); + $('.ldap_action_back').removeClass('invisible'); + } else + if(nextTabIndex == 3) { + $('.ldap_action_back').removeClass('invisible'); + $('.ldap_action_continue').addClass('invisible'); + } + } + }; + + OCA.LDAP.Wizard.WizardView = WizardView; +})(); diff --git a/apps/user_ldap/js/wizard/wizard.js b/apps/user_ldap/js/wizard/wizard.js new file mode 100644 index 00000000000..faa9de918a4 --- /dev/null +++ b/apps/user_ldap/js/wizard/wizard.js @@ -0,0 +1,80 @@ +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + + + +/** + * initializes the wizard and related components and kicks it off. + */ + +(function() { + var Wizard = function() { + var detectorQueue = new OCA.LDAP.Wizard.WizardDetectorQueue(); + detectorQueue.init(); + + var detectors = []; + detectors.push(new OCA.LDAP.Wizard.WizardDetectorPort()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorBaseDN()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorEmailAttribute()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorUserDisplayNameAttribute()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorUserGroupAssociation()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorUserObjectClasses()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorGroupObjectClasses()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorGroupsForUsers()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorGroupsForGroups()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorFilterUser()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorFilterLogin()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorFilterGroup()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorUserCount()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorGroupCount()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorAvailableAttributes()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorTestLoginName()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorTestBaseDN()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorTestConfiguration()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorClearUserMappings()); + detectors.push(new OCA.LDAP.Wizard.WizardDetectorClearGroupMappings()); + + var model = new OCA.LDAP.Wizard.ConfigModel(); + model.init(detectorQueue); + // NOTE: order of detectors may play a role + // for example, BaseDN detector needs the port. The port is typically found + // by the Port Detector. If BaseDN detector was run first, it will not have + // all necessary information. Only after Port Detector was executed… + for (var i = 0; i <= detectors.length; i++) { + model.registerDetector(detectors[i]); + } + + var filterOnTypeFactory = new OCA.LDAP.Wizard.FilterOnTypeFactory(); + + var tabs = []; + tabs.push(new OCA.LDAP.Wizard.WizardTabUserFilter(filterOnTypeFactory)); + tabs.push(new OCA.LDAP.Wizard.WizardTabLoginFilter()); + tabs.push(new OCA.LDAP.Wizard.WizardTabGroupFilter(filterOnTypeFactory)); + tabs.push(new OCA.LDAP.Wizard.WizardTabAdvanced()); + tabs.push(new OCA.LDAP.Wizard.WizardTabExpert()); + + var view = new OCA.LDAP.Wizard.WizardView(model); + view.init(); + view.setModel(model); + for (var j = 0; j <= tabs.length; j++) { + view.registerTab(tabs[j], '#ldapWizard' + (j + 2)); + } + + var controller = new OCA.LDAP.Wizard.Controller(); + controller.init(); + controller.setView(view); + controller.setModel(model); + controller.run(); + } + + OCA.LDAP.Wizard.Wizard = Wizard; +})(); + +$(document).ready(function() { + new OCA.LDAP.Wizard.Wizard(); +}); diff --git a/apps/user_ldap/js/wizard/wizardDetectorAvailableAttributes.js b/apps/user_ldap/js/wizard/wizardDetectorAvailableAttributes.js new file mode 100644 index 00000000000..f0272351749 --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorAvailableAttributes.js @@ -0,0 +1,59 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc an Attributes Detector. It executes the auto-detection of + * available attributes by the ownCloud server, if requirements are met. + * + * @constructor + */ + var WizardDetectorAvailableAttributes = OCA.LDAP.Wizard.WizardDetectorGeneric.subClass({ + /** @inheritdoc */ + init: function() { + // given, it is not a configuration key + this.setTargetKey('ldap_loginfilter_attributes'); + this.runsOnRequest = true; + }, + + /** + * runs the detector, if port is not set. + * + * @param {OCA.LDAP.Wizard.ConfigModel} model + * @param {string} configID - the configuration prefix + * @returns {boolean|jqXHR} + * @abstract + */ + run: function(model, configID) { + model.notifyAboutDetectionStart(this.getTargetKey()); + var params = OC.buildQueryString({ + action: 'determineAttributes', + ldap_serverconfig_chooser: configID + }); + return model.callWizard(params, this.processResult, this); + }, + + /** + * @inheritdoc + */ + processResult: function(model, detector, result) { + if(result.status === 'success') { + var payload = { + feature: 'AvailableAttributes', + data: result.options[detector.getTargetKey()] + }; + model.inform(payload); + } + this._super(model, detector, result); + } + }); + + OCA.LDAP.Wizard.WizardDetectorAvailableAttributes = WizardDetectorAvailableAttributes; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorBaseDN.js b/apps/user_ldap/js/wizard/wizardDetectorBaseDN.js new file mode 100644 index 00000000000..70b9923e58d --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorBaseDN.js @@ -0,0 +1,52 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc a Base DN Detector. It executes the auto-detection of the base + * DN by the ownCloud server, if requirements are met. + * + * @constructor + */ + var WizardDetectorBaseDN = OCA.LDAP.Wizard.WizardDetectorGeneric.subClass({ + /** @inheritdoc */ + init: function() { + this.setTargetKey('ldap_base'); + this.runsOnRequest = true; + }, + + /** + * runs the detector, if specified configuration settings are set and + * base DN is not set. + * + * @param {OCA.LDAP.Wizard.ConfigModel} model + * @param {string} configID - the configuration prefix + * @returns {boolean|jqXHR} + * @abstract + */ + run: function(model, configID) { + if( !model.configuration['ldap_host'] + || !model.configuration['ldap_port'] + + ) + { + return false; + } + model.notifyAboutDetectionStart(this.getTargetKey()); + var params = OC.buildQueryString({ + action: 'guessBaseDN', + ldap_serverconfig_chooser: configID + }); + return model.callWizard(params, this.processResult, this); + } + }); + + OCA.LDAP.Wizard.WizardDetectorBaseDN = WizardDetectorBaseDN; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorClearGroupMappings.js b/apps/user_ldap/js/wizard/wizardDetectorClearGroupMappings.js new file mode 100644 index 00000000000..c6ef0a9cab1 --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorClearGroupMappings.js @@ -0,0 +1,30 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc requests clearing of user mappings + * + * @constructor + */ + var WizardDetectorClearGroupMappings = OCA.LDAP.Wizard.WizardDetectorTestAbstract.subClass({ + /** @inheritdoc */ + init: function() { + // given, it is not a configuration key + this.setTargetKey('ldap_action_clear_group_mappings'); + this.testName = 'ClearMappings'; + this.isLegacy = true; + this.legacyDestination = 'clearMappings.php'; + this.runsOnRequest = true; + } + }); + + OCA.LDAP.Wizard.WizardDetectorClearGroupMappings = WizardDetectorClearGroupMappings; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorClearUserMappings.js b/apps/user_ldap/js/wizard/wizardDetectorClearUserMappings.js new file mode 100644 index 00000000000..0e4811b39ea --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorClearUserMappings.js @@ -0,0 +1,30 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc requests clearing of user mappings + * + * @constructor + */ + var WizardDetectorClearUserMappings = OCA.LDAP.Wizard.WizardDetectorTestAbstract.subClass({ + /** @inheritdoc */ + init: function() { + // given, it is not a configuration key + this.setTargetKey('ldap_action_clear_user_mappings'); + this.testName = 'ClearMappings'; + this.isLegacy = true; + this.legacyDestination = 'clearMappings.php'; + this.runsOnRequest = true; + } + }); + + OCA.LDAP.Wizard.WizardDetectorClearUserMappings = WizardDetectorClearUserMappings; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorEmailAttribute.js b/apps/user_ldap/js/wizard/wizardDetectorEmailAttribute.js new file mode 100644 index 00000000000..5f177734681 --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorEmailAttribute.js @@ -0,0 +1,38 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc let's the wizard backend count the available users + * + * @constructor + */ + var WizardDetectorEmailAttribute = OCA.LDAP.Wizard.WizardDetectorFilterSimpleRequestAbstract.subClass({ + init: function() { + this.setTargetKey('ldap_user_count'); + this.wizardMethod = 'detectEmailAttribute'; + this.runsOnRequest = true; + }, + + /** + * @inheritdoc + */ + run: function(model, configID) { + if(model.configuration.ldap_email_attr) { + // a value is already set. Don't overwrite and don't ask LDAP + // without reason. + return false; + } + this._super(model, configID); + } + }); + + OCA.LDAP.Wizard.WizardDetectorEmailAttribute = WizardDetectorEmailAttribute; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorFeatureAbstract.js b/apps/user_ldap/js/wizard/wizardDetectorFeatureAbstract.js new file mode 100644 index 00000000000..e025d8d6242 --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorFeatureAbstract.js @@ -0,0 +1,52 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc abstract detector for detecting groups and object classes + * + * @constructor + */ + var WizardDetectorFeatureAbstract = OCA.LDAP.Wizard.WizardDetectorGeneric.subClass({ + /** + * runs the detector, if port is not set. + * + * @param {OCA.LDAP.Wizard.ConfigModel} model + * @param {string} configID - the configuration prefix + * @returns {boolean|jqXHR} + * @abstract + */ + run: function(model, configID) { + model.notifyAboutDetectionStart(this.getTargetKey()); + var params = OC.buildQueryString({ + action: this.wizardMethod, + ldap_serverconfig_chooser: configID + }); + return model.callWizard(params, this.processResult, this); + }, + + /** + * @inheritdoc + */ + processResult: function(model, detector, result) { + if(result.status === 'success') { + var payload = { + feature: detector.featureName, + data: result.options[detector.getTargetKey()] + }; + model.inform(payload); + } + + this._super(model, detector, result); + } + }); + + OCA.LDAP.Wizard.WizardDetectorFeatureAbstract = WizardDetectorFeatureAbstract; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorFilterGroup.js b/apps/user_ldap/js/wizard/wizardDetectorFilterGroup.js new file mode 100644 index 00000000000..cca889839e4 --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorFilterGroup.js @@ -0,0 +1,31 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc a Port Detector. It executes the auto-detection of the port + * by the ownCloud server, if requirements are met. + * + * @constructor + */ + var WizardDetectorFilterGroup = OCA.LDAP.Wizard.WizardDetectorFilterSimpleRequestAbstract.subClass({ + init: function() { + this.setTrigger([ + 'ldap_groupfilter_groups', + 'ldap_groupfilter_objectclass' + ]); + this.setTargetKey('ldap_group_filter'); + + this.wizardMethod = 'getGroupFilter'; + } + }); + + OCA.LDAP.Wizard.WizardDetectorFilterGroup = WizardDetectorFilterGroup; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorFilterLogin.js b/apps/user_ldap/js/wizard/wizardDetectorFilterLogin.js new file mode 100644 index 00000000000..310f261e05e --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorFilterLogin.js @@ -0,0 +1,32 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc a Port Detector. It executes the auto-detection of the port + * by the ownCloud server, if requirements are met. + * + * @constructor + */ + var WizardDetectorFilterLogin = OCA.LDAP.Wizard.WizardDetectorFilterSimpleRequestAbstract.subClass({ + init: function() { + this.setTrigger([ + 'ldap_loginfilter_username', + 'ldap_loginfilter_email', + 'ldap_loginfilter_attributes' + ]); + this.setTargetKey('ldap_login_filter'); + + this.wizardMethod = 'getUserLoginFilter'; + } + }); + + OCA.LDAP.Wizard.WizardDetectorFilterLogin = WizardDetectorFilterLogin; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorFilterUser.js b/apps/user_ldap/js/wizard/wizardDetectorFilterUser.js new file mode 100644 index 00000000000..63dff4e2985 --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorFilterUser.js @@ -0,0 +1,31 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc a Port Detector. It executes the auto-detection of the port + * by the ownCloud server, if requirements are met. + * + * @constructor + */ + var WizardDetectorFilterUser = OCA.LDAP.Wizard.WizardDetectorFilterSimpleRequestAbstract.subClass({ + init: function() { + this.setTrigger([ + 'ldap_userfilter_groups', + 'ldap_userfilter_objectclass' + ]); + this.setTargetKey('ldap_userlist_filter'); + + this.wizardMethod = 'getUserListFilter'; + } + }); + + OCA.LDAP.Wizard.WizardDetectorFilterUser = WizardDetectorFilterUser; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorGeneric.js b/apps/user_ldap/js/wizard/wizardDetectorGeneric.js new file mode 100644 index 00000000000..fd80018943e --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorGeneric.js @@ -0,0 +1,117 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + /** + * @classdesc a generic (abstract) Detector template. A Detector's task is + * to kick off server side detection of certain LDAP features. It is invoked + * when changes to specified configuration keys happen. + * + * @constructor + */ + var WizardDetectorGeneric = OCA.LDAP.Wizard.WizardObject.subClass({ + /** + * initializes the instance. Always call it after creating the instance. + */ + init: function() { + this.setTrigger([]); + this.targetKey = ''; + this.runsOnRequest = false; + }, + + /** + * sets the configuration keys the detector is listening on + * + * @param {string[]} triggers + */ + setTrigger: function(triggers) { + this.triggers = triggers; + }, + + /** + * tests whether the detector is triggered by the provided key + * + * @param {string} key + * @returns {boolean} + */ + triggersOn: function(key) { + return ($.inArray(key, this.triggers) >= 0); + }, + + /** + * whether the detector runs on explicit request + * + * @param {string} key + * @returns {boolean} + */ + runsOnFeatureRequest: function(key) { + return !!(this.runsOnRequest && this.targetKey === key); + }, + + /** + * sets the configuration key the detector is attempting to auto-detect + * + * @param {string} key + */ + setTargetKey: function(key) { + this.targetKey = key; + }, + + /** + * returns the configuration key the detector is attempting to + * auto-detect + */ + getTargetKey: function() { + return this.targetKey; + }, + + /** + * runs the detector. This method is supposed to be implemented by the + * concrete detector. + * + * Must return false if the detector decides not to run. + * Must return a jqXHR object otherwise, which is provided by the + * model's callWizard() + * + * @param {OCA.LDAP.Wizard.ConfigModel} model + * @param {string} configID - the configuration prefix + * @returns {boolean|jqXHR} + * @abstract + */ + run: function(model, configID) { + // to be implemented by subClass + return false; + }, + + /** + * processes the result of the ownCloud server + * + * @param {OCA.LDAP.Wizard.ConfigModel} model + * @param {WizardDetectorGeneric} detector + * @param {object} result + */ + processResult: function(model, detector, result) { + model['notifyAboutDetectionCompletion'](detector.getTargetKey()); + if(result.status === 'success') { + for (var id in result.changes) { + // update and not set method, as values are already stored + model['update'](id, result.changes[id]); + } + } else { + var payload = { relatedKey: detector.targetKey }; + if(!_.isUndefined(result.message)) { + payload.message = result.message; + } + model.gotServerError(payload); + } + } + }); + + OCA.LDAP.Wizard.WizardDetectorGeneric = WizardDetectorGeneric; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorGroupCount.js b/apps/user_ldap/js/wizard/wizardDetectorGroupCount.js new file mode 100644 index 00000000000..12d7df7514b --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorGroupCount.js @@ -0,0 +1,27 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc a Port Detector. It executes the auto-detection of the port + * by the ownCloud server, if requirements are met. + * + * @constructor + */ + var WizardDetectorGroupCount = OCA.LDAP.Wizard.WizardDetectorFilterSimpleRequestAbstract.subClass({ + init: function() { + this.setTargetKey('ldap_group_count'); + this.wizardMethod = 'countGroups'; + this.runsOnRequest = true; + } + }); + + OCA.LDAP.Wizard.WizardDetectorGroupCount = WizardDetectorGroupCount; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorGroupObjectClasses.js b/apps/user_ldap/js/wizard/wizardDetectorGroupObjectClasses.js new file mode 100644 index 00000000000..6d6048b7986 --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorGroupObjectClasses.js @@ -0,0 +1,29 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc discovers object classes for the groups tab + * + * @constructor + */ + var WizardDetectorGroupObjectClasses = OCA.LDAP.Wizard.WizardDetectorFeatureAbstract.subClass({ + /** @inheritdoc */ + init: function() { + // given, it is not a configuration key + this.setTargetKey('ldap_groupfilter_objectclass'); + this.wizardMethod = 'determineGroupObjectClasses'; + this.featureName = 'GroupObjectClasses'; + this.runsOnRequest = true; + } + }); + + OCA.LDAP.Wizard.WizardDetectorGroupObjectClasses = WizardDetectorGroupObjectClasses; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorGroupsForGroups.js b/apps/user_ldap/js/wizard/wizardDetectorGroupsForGroups.js new file mode 100644 index 00000000000..fbb3f02e10a --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorGroupsForGroups.js @@ -0,0 +1,29 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc detects groups for the groups tab + * + * @constructor + */ + var WizardDetectorGroupsForGroups = OCA.LDAP.Wizard.WizardDetectorFeatureAbstract.subClass({ + /** @inheritdoc */ + init: function() { + // given, it is not a configuration key + this.setTargetKey('ldap_groupfilter_groups'); + this.wizardMethod = 'determineGroupsForGroups'; + this.featureName = 'GroupsForGroups'; + this.runsOnRequest = true; + } + }); + + OCA.LDAP.Wizard.WizardDetectorGroupsForGroups = WizardDetectorGroupsForGroups; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorGroupsForUsers.js b/apps/user_ldap/js/wizard/wizardDetectorGroupsForUsers.js new file mode 100644 index 00000000000..fe67854c794 --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorGroupsForUsers.js @@ -0,0 +1,29 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc detects groups for the users tab + * + * @constructor + */ + var WizardDetectorGroupsForUsers = OCA.LDAP.Wizard.WizardDetectorFeatureAbstract.subClass({ + /** @inheritdoc */ + init: function() { + // given, it is not a configuration key + this.setTargetKey('ldap_userfilter_groups'); + this.wizardMethod = 'determineGroupsForUsers'; + this.featureName = 'GroupsForUsers'; + this.runsOnRequest = true; + } + }); + + OCA.LDAP.Wizard.WizardDetectorGroupsForUsers = WizardDetectorGroupsForUsers; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorPort.js b/apps/user_ldap/js/wizard/wizardDetectorPort.js new file mode 100644 index 00000000000..ba075189667 --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorPort.js @@ -0,0 +1,44 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc a Port Detector. It executes the auto-detection of the port + * by the ownCloud server, if requirements are met. + * + * @constructor + */ + var WizardDetectorPort = OCA.LDAP.Wizard.WizardDetectorGeneric.subClass({ + /** @inheritdoc */ + init: function() { + this.setTargetKey('ldap_port'); + this.runsOnRequest = true; + }, + + /** + * runs the detector, if port is not set. + * + * @param {OCA.LDAP.Wizard.ConfigModel} model + * @param {string} configID - the configuration prefix + * @returns {boolean|jqXHR} + * @abstract + */ + run: function(model, configID) { + model.notifyAboutDetectionStart('ldap_port'); + var params = OC.buildQueryString({ + action: 'guessPortAndTLS', + ldap_serverconfig_chooser: configID + }); + return model.callWizard(params, this.processResult, this); + } + }); + + OCA.LDAP.Wizard.WizardDetectorPort = WizardDetectorPort; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorQueue.js b/apps/user_ldap/js/wizard/wizardDetectorQueue.js new file mode 100644 index 00000000000..448dfc18036 --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorQueue.js @@ -0,0 +1,89 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + /** + * @classdesc only run detector is allowed to run at a time. Basically + * because we cannot have parallel LDAP connections per session. This + * queue is takes care of running all the detectors one after the other. + * + * @constructor + */ + var WizardDetectorQueue = OCA.LDAP.Wizard.WizardObject.subClass({ + /** + * initializes the instance. Always call it after creating the instance. + */ + init: function() { + this.queue = []; + this.isRunning = false; + }, + + /** + * empties the queue and cancels a possibly running request + */ + reset: function() { + this.queue = []; + if(!_.isUndefined(this.runningRequest)) { + this.runningRequest.abort(); + delete this.runningRequest; + } + this.isRunning = false; + }, + + /** + * a parameter-free callback that eventually executes the run method of + * the detector. + * + * @callback detectorCallBack + * @see OCA.LDAP.Wizard.ConfigModel._processSetResult + */ + + /** + * adds a detector to the queue and attempts to trigger to run the + * next job, because it might be the first. + * + * @param {detectorCallBack} callback + */ + add: function(callback) { + this.queue.push(callback); + this.next(); + }, + + /** + * Executes the next detector if none is running. This method is also + * automatically invoked after a detector finished. + */ + next: function() { + if(this.isRunning === true || this.queue.length === 0) { + return; + } + + this.isRunning = true; + var callback = this.queue.shift(); + var request = callback(); + + // we receive either false or a jqXHR object + // false in case the detector decided against executing + if(request === false) { + this.isRunning = false; + this.next(); + return; + } + this.runningRequest = request; + + var detectorQueue = this; + $.when(request).then(function() { + detectorQueue.isRunning = false; + detectorQueue.next(); + }); + } + }); + + OCA.LDAP.Wizard.WizardDetectorQueue = WizardDetectorQueue; +})(); \ No newline at end of file diff --git a/apps/user_ldap/js/wizard/wizardDetectorSimpleRequestAbstract.js b/apps/user_ldap/js/wizard/wizardDetectorSimpleRequestAbstract.js new file mode 100644 index 00000000000..37e41f42a64 --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorSimpleRequestAbstract.js @@ -0,0 +1,44 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc a Port Detector. It executes the auto-detection of the port + * by the ownCloud server, if requirements are met. + * + * @constructor + */ + var WizardDetectorFilterSimpleRequestAbstract = OCA.LDAP.Wizard.WizardDetectorGeneric.subClass({ + runsOnRequest: true, + + /** + * runs the detector, if port is not set. + * + * @param {OCA.LDAP.Wizard.ConfigModel} model + * @param {string} configID - the configuration prefix + * @returns {boolean|jqXHR} + * @abstract + */ + run: function(model, configID) { + if(_.isUndefined(this.wizardMethod)) { + console.warn('wizardMethod not set! ' + this.constructor); + return false; + } + model.notifyAboutDetectionStart(this.targetKey); + var params = OC.buildQueryString({ + action: this.wizardMethod, + ldap_serverconfig_chooser: configID + }); + return model.callWizard(params, this.processResult, this); + } + }); + + OCA.LDAP.Wizard.WizardDetectorFilterSimpleRequestAbstract = WizardDetectorFilterSimpleRequestAbstract; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorTestAbstract.js b/apps/user_ldap/js/wizard/wizardDetectorTestAbstract.js new file mode 100644 index 00000000000..df0b0a2200a --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorTestAbstract.js @@ -0,0 +1,63 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc a Port Detector. It executes the auto-detection of the port + * by the ownCloud server, if requirements are met. + * + * @constructor + */ + var WizardDetectorTestAbstract = OCA.LDAP.Wizard.WizardDetectorGeneric.subClass({ + isLegacy: false, + + /** + * runs the test + * + * @param {OCA.LDAP.Wizard.ConfigModel} model + * @param {string} configID - the configuration prefix + * @param {Object} params - additional parameters needed to send to the + * wizard + * @returns {boolean|jqXHR} + * @abstract + */ + run: function(model, configID, params) { + if(_.isUndefined(this.wizardMethod) && !this.isLegacy) { + console.warn('wizardMethod not set! ' + this.constructor); + return false; + } + model.notifyAboutDetectionStart(this.getTargetKey()); + params = params || {}; + params = OC.buildQueryString($.extend({ + action: this.wizardMethod, + ldap_serverconfig_chooser: configID + }, params)); + if(!this.isLegacy) { + return model.callWizard(params, this.processResult, this); + } else { + return model.callAjax(this.legacyDestination, params, this.processResult, this); + } + }, + + /** + * @inheritdoc + */ + processResult: function(model, detector, result) { + model['notifyAboutDetectionCompletion'](detector.getTargetKey()); + var payload = { + feature: detector.testName, + data: result + }; + model.inform(payload); + } + }); + + OCA.LDAP.Wizard.WizardDetectorTestAbstract = WizardDetectorTestAbstract; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorTestBaseDN.js b/apps/user_ldap/js/wizard/wizardDetectorTestBaseDN.js new file mode 100644 index 00000000000..52848819bd8 --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorTestBaseDN.js @@ -0,0 +1,29 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc Tests, how many objects reside in the given base DN(s) + * + * @constructor + */ + var WizardDetectorTestBaseDN = OCA.LDAP.Wizard.WizardDetectorTestAbstract.subClass({ + /** @inheritdoc */ + init: function() { + // given, it is not a configuration key + this.setTargetKey('ldap_test_base'); + this.testName = 'TestBaseDN'; + this.wizardMethod = 'countInBaseDN'; + this.runsOnRequest = true; + } + }); + + OCA.LDAP.Wizard.WizardDetectorTestBaseDN = WizardDetectorTestBaseDN; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorTestConfiguration.js b/apps/user_ldap/js/wizard/wizardDetectorTestConfiguration.js new file mode 100644 index 00000000000..1308c182909 --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorTestConfiguration.js @@ -0,0 +1,31 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc a Port Detector. It executes the auto-detection of the port + * by the ownCloud server, if requirements are met. + * + * @constructor + */ + var WizardDetectorTestConfiguration = OCA.LDAP.Wizard.WizardDetectorTestAbstract.subClass({ + /** @inheritdoc */ + init: function() { + // given, it is not a configuration key + this.setTargetKey('ldap_action_test_connection'); + this.testName = 'TestConfiguration'; + this.isLegacy = true; + this.legacyDestination = 'testConfiguration.php'; + this.runsOnRequest = true; + } + }); + + OCA.LDAP.Wizard.WizardDetectorTestConfiguration = WizardDetectorTestConfiguration; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorTestLoginName.js b/apps/user_ldap/js/wizard/wizardDetectorTestLoginName.js new file mode 100644 index 00000000000..cf992df43b3 --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorTestLoginName.js @@ -0,0 +1,30 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc a Port Detector. It executes the auto-detection of the port + * by the ownCloud server, if requirements are met. + * + * @constructor + */ + var WizardDetectorTestLoginName = OCA.LDAP.Wizard.WizardDetectorTestAbstract.subClass({ + /** @inheritdoc */ + init: function() { + // given, it is not a configuration key + this.setTargetKey('ldap_test_loginname'); + this.testName = 'TestLoginName'; + this.wizardMethod = 'testLoginName'; + this.runsOnRequest = true; + } + }); + + OCA.LDAP.Wizard.WizardDetectorTestLoginName = WizardDetectorTestLoginName; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorUserCount.js b/apps/user_ldap/js/wizard/wizardDetectorUserCount.js new file mode 100644 index 00000000000..bcff2cf3b10 --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorUserCount.js @@ -0,0 +1,26 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc let's the wizard backend count the available users + * + * @constructor + */ + var WizardDetectorUserCount = OCA.LDAP.Wizard.WizardDetectorFilterSimpleRequestAbstract.subClass({ + init: function() { + this.setTargetKey('ldap_user_count'); + this.wizardMethod = 'countUsers'; + this.runsOnRequest = true; + } + }); + + OCA.LDAP.Wizard.WizardDetectorUserCount = WizardDetectorUserCount; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorUserDisplayNameAttribute.js b/apps/user_ldap/js/wizard/wizardDetectorUserDisplayNameAttribute.js new file mode 100644 index 00000000000..ae734480c1c --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorUserDisplayNameAttribute.js @@ -0,0 +1,39 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc let's the wizard backend count the available users + * + * @constructor + */ + var WizardDetectorUserDisplayNameAttribute = OCA.LDAP.Wizard.WizardDetectorFilterSimpleRequestAbstract.subClass({ + init: function() { + this.setTargetKey('ldap_user_count'); + this.wizardMethod = 'detectUserDisplayNameAttribute'; + this.runsOnRequest = true; + }, + + /** + * @inheritdoc + */ + run: function(model, configID) { + // default value has capital N. Detected values are always lowercase + if(model.configuration.ldap_display_name && model.configuration.ldap_display_name !== 'displayName') { + // a value is already set. Don't overwrite and don't ask LDAP + // without reason. + return false; + } + this._super(model, configID); + } + }); + + OCA.LDAP.Wizard.WizardDetectorUserDisplayNameAttribute = WizardDetectorUserDisplayNameAttribute; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorUserGroupAssociation.js b/apps/user_ldap/js/wizard/wizardDetectorUserGroupAssociation.js new file mode 100644 index 00000000000..953a0b909a6 --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorUserGroupAssociation.js @@ -0,0 +1,40 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc let's the wizard backend count the available users + * + * @constructor + */ + var WizardDetectorUserGroupAssociation = OCA.LDAP.Wizard.WizardDetectorFilterSimpleRequestAbstract.subClass({ + init: function() { + this.setTargetKey('ldap_group_count'); + this.wizardMethod = 'determineGroupMemberAssoc'; + this.runsOnRequest = true; + }, + + /** + * @inheritdoc + */ + run: function(model, configID) { + // TODO: might be better with configuration marker as uniqueMember + // is a valid value (although probably less common then member and memberUid). + if(model.configuration.ldap_group_member_assoc_attribute && model.configuration.ldap_group_member_assoc_attribute !== 'uniqueMember') { + // a value is already set. Don't overwrite and don't ask LDAP + // without reason. + return false; + } + this._super(model, configID); + } + }); + + OCA.LDAP.Wizard.WizardDetectorUserGroupAssociation = WizardDetectorUserGroupAssociation; +})(); diff --git a/apps/user_ldap/js/wizard/wizardDetectorUserObjectClasses.js b/apps/user_ldap/js/wizard/wizardDetectorUserObjectClasses.js new file mode 100644 index 00000000000..0fa324a0809 --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardDetectorUserObjectClasses.js @@ -0,0 +1,29 @@ + +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc discovers object classes for the users tab + * + * @constructor + */ + var WizardDetectorUserObjectClasses = OCA.LDAP.Wizard.WizardDetectorFeatureAbstract.subClass({ + /** @inheritdoc */ + init: function() { + // given, it is not a configuration key + this.setTargetKey('ldap_userfilter_objectclass'); + this.wizardMethod = 'determineUserObjectClasses'; + this.featureName = 'UserObjectClasses'; + this.runsOnRequest = true; + } + }); + + OCA.LDAP.Wizard.WizardDetectorUserObjectClasses = WizardDetectorUserObjectClasses; +})(); diff --git a/apps/user_ldap/js/wizard/wizardFilterOnType.js b/apps/user_ldap/js/wizard/wizardFilterOnType.js new file mode 100644 index 00000000000..f3f1368982b --- /dev/null +++ b/apps/user_ldap/js/wizard/wizardFilterOnType.js @@ -0,0 +1,76 @@ +/** + * Copyright (c) 2015, Arthur Schiwon + * This file is licensed under the Affero General Public License version 3 or later. + * See the COPYING-README file. + */ + +OCA = OCA || {}; + +(function() { + + /** + * @classdesc filters a select box when a text element is typed in + */ + var FilterOnType = OCA.LDAP.Wizard.WizardObject.subClass({ + /** + * initializes a type filter on a text input for a select element + * + * @param {jQuery} $select + * @param {jQuery} $textInput + */ + init: function($select, $textInput) { + this.$select = $select; + this.$textInput = $textInput; + this.updateOptions(); + this.lastSearch = ''; + + var fity = this; + $textInput.bind('change keyup', function () { + if(fity.runID) { + window.clearTimeout(fity.runID); + } + fity.runID = window.setTimeout(function() { + fity.filter(fity); + }, 250); + }); + }, + + /** + * the options will be read in again. Should be called after a + * configuration switch. + */ + updateOptions: function() { + var options = []; + this.$select.find('option').each(function() { + options.push({ + value: $(this).val(), + normalized: $(this).val().toLowerCase() + } + ); + }); + this._options = options; + }, + + /** + * the actual search or filter method + * + * @param {FilterOnType} fity + */ + filter: function(fity) { + var filterVal = fity.$textInput.val().toLowerCase(); + if(filterVal === fity.lastSearch) { + return; + } + fity.lastSearch = filterVal; + fity.$select.empty(); + $.each(fity._options, function() { + if(!filterVal || this.normalized.indexOf(filterVal) > -1) { + fity.$select.append($('