Ext.onReady(function () {
if (Ext.firefoxVersion >= 18) {
var noArgs = [];
var callOverrideParent = function () {
var method = callOverrideParent.caller.caller; // skip callParent (our caller)
try {
} catch (e) {
} // FF 18 fix
return method.$owner.prototype[method.$name].apply(this, arguments);
};
Ext.override = function (target, overrides) {
if (target.$isClass) {
target.override(overrides);
} else if (typeof target == 'function') {
Ext.apply(target.prototype, overrides);
} else {
var owner = target.self, name, value;
if (owner && owner.$isClass) { // if (instance of Ext.define'd class)
for (name in overrides) {
if (overrides.hasOwnProperty(name)) {
value = overrides[name];
if (typeof value == 'function') {
value.$name = name;
value.$owner = owner;
value.$previous = target.hasOwnProperty(name) ? target[name] : callOverrideParent;
}
target[name] = value;
}
}
} else {
Ext.apply(target, overrides);
}
}
return target;
};
Ext.apply(Ext.Base, {
callParent: function (args) {
var method,
superMethod = (method = this.callParent.caller) && (method.$previous || ((method = method.$owner ?
method :
method.caller) && method.$owner.superclass[method.$name]));
try {
} catch (e) {
}
return superMethod.apply(this, args || noArgs);
},
callSuper: function (args) {
var method, superMethod = (method = this.callSuper.caller) &&
((method = method.$owner ? method : method.caller) &&
method.$owner.superclass[method.$name]);
try {
} catch (e) {
} // Firefox 18 fix
return superMethod.apply(this, args || noArgs);
},
statics: function () {
var self = this.self, method = this.statics.caller;
try {
} catch (e) {
} // Firefox 18 fix
if (!method) return self;
return method.$owner;
}
});
Ext.apply(Ext.Error, {
raise: function (err) {
err = err || {};
if (Ext.isString(err)) {
err = { msg: err };
}
var msg, method = this.raise.caller;
try {
} catch (e) {
} // Firefox 18 fix
if (method) {
if (method.$name) {
err.sourceMethod = method.$name;
}
if (method.$owner) {
err.sourceClass = method.$owner.$className;
}
}
if (Ext.Error.handle(err) !== true) {
msg = Ext.Error.prototype.toString.call(err);
Ext.log({
msg: msg,
level: 'error',
dump: err,
stack: true
});
throw new Ext.Error(err);
}
}
});
}
});
;(function(Manager, global) {
Manager.isCreated = function(className) {
var existCache = this.existCache,
i, ln, part, root, parts;
if (this.classes[className] || existCache[className]) {
return true;
}
root = global;
parts = this.parseNamespace(className);
for (i = 0, ln = parts.length; i < ln; i++) {
part = parts[i];
if (typeof part != 'string') {
root = part;
} else {
if (!root || !root[part]) {
return false;
}
root = root[part];
}
}
if (/^.*\.apps\./.test(className) && typeof root != 'function') {
return false;
}
existCache[className] = true;
this.triggerCreated(className);
return true;
};
Manager.createOverride = function(className, data, createdFn) {
var me = this,
overriddenClassName = data.override,
requires = data.requires,
uses = data.uses,
check = true,
classReady = function () {
var cls, temp;
if (requires) {
temp = requires;
requires = null; // do the real thing next time (which may be now)
Ext.Loader.require(temp, classReady);
} else {
cls = me.get(overriddenClassName);
if(data.override === 'Shopware.apps.Article.view.detail.Window') {
check = me.checkOverride(cls, data);
}
delete data.override;
delete data.requires;
delete data.uses;
if(!check) {
data = { '_invalidPlugin': true, '_invalidClassName': className };
} else {
data['_invalidPlugin'] = false;
}
Ext.override(cls, data);
me.triggerCreated(className);
if (uses) {
Ext.Loader.addUsedClasses(uses); // get these classes too!
}
if (createdFn) {
createdFn.call(cls); // last but not least!
}
}
};
me.existCache[className] = true;
me.onCreated(classReady, me, overriddenClassName);
return me;
};
Manager.checkOverride = function(cls, data) {
var match = true, fnName, fn;
for(fnName in data) {
fn = data[fnName].toString();
if(fn.match(/createMainTabPanel/i)) {
match = false;
break;
}
}
if(!match) {
for(fnName in data) {
fn = data[fnName].toString();
if(fn.match(/registerAdditionalTab/i)) {
match = true;
break;
}
}
}
return match;
};
})(Ext.ClassManager, Ext.global);
Ext.define('Ext.data.proxy.Server-Shopware', {
override: 'Ext.data.proxy.Server',
processResponse: function(success, operation, request, response, callback, scope) {
var me = this,
reader,
result;
if (success === true) {
reader = me.getReader();
reader.applyDefaults = operation.action === 'read';
result = reader.read(me.extractResponseData(response));
if (result.success !== false) {
Ext.apply(operation, {
response: response,
resultSet: result
});
operation.commitRecords(result.records);
operation.setCompleted();
operation.setSuccessful();
} else {
operation.setException(result.message);
me.fireEvent('exception', this, response, operation);
}
} else {
if(response.status == 401) {
window.location.reload()
}
else {
me.setException(operation, response);
me.fireEvent('exception', this, response, operation);
Ext.MessageBox.alert(operation.error.status + ' - ' + operation.error.statusText, Ext.util.Format.stripTags(response.responseText));
}
}
if (typeof callback == 'function') {
callback.call(scope || me, operation);
}
me.afterRequest(request, success);
},
encodeFilters: function(filters) {
var min = [],
length = filters.length,
i = 0;
for (; i < length; i++) {
min[i] = {
property: filters[i].property,
value : filters[i].value,
operator: filters[i].operator,
expression: filters[i].expression
};
}
return this.applyEncoding(min);
}
});
Ext.override(Ext.app.Application, {
loadingMessage: '[0] wird geladen ...',
addController: function(controller, skipInit) {
if (Ext.isDefined(controller.name)) {
var name = controller.name;
delete controller.name;
controller.id = controller.id || name;
controller = Ext.create(name, controller);
}
var me = this,
controllers = me.controllers;
controllers.add(controller);
if (!skipInit) {
controller.init();
}
return controller;
},
removeController: function(controller, removeListeners) {
removeListeners = removeListeners || true;
var me = this,
controllers = me.controllers;
controllers.remove(controller);
if (removeListeners) {
var bus = me.eventbus;
bus.uncontrol([controller.id]);
}
},
addSubApplication: function(subapp, skipInit, fn, showLoadMask) {
skipInit = (skipInit === undefined) ? false : true;
subapp.app = this;
if(subapp.hasOwnProperty('showLoadMask')) {
showLoadMask = subapp.showLoadMask;
}
showLoadMask = (showLoadMask === undefined) ? true : showLoadMask;
if(showLoadMask) {
this.moduleLoadMask = new Ext.LoadMask(Ext.getBody(), {
msg: Ext.String.format(this.loadingMessage, (subapp.localizedName) ? subapp.localizedName : subapp.name),
hideModal: true
});
this.moduleLoadMask.show();
}
fn = fn || Ext.emptyFn;
Ext.require(subapp.name, Ext.bind(function() {
this.addController(subapp, skipInit);
fn(subapp);
}, this));
},
getActiveWindows: function(deprecated) {
var activeWindows = [];
if (deprecated === undefined) {
deprecated = true;
}
Ext.each(Ext.WindowManager.zIndexStack, function (item) {
if (typeof(item) !== 'undefined') {
var className = item.$className;
if ((className == 'Ext.window.Window' || className == 'Enlight.app.Window' || className == 'Ext.Window' || (deprecated && className == 'Shopware.apps.Deprecated.view.main.Window')) && className != "Ext.window.MessageBox") {
activeWindows.push(item);
}
className = item.alternateClassName;
if ((className == 'Ext.window.Window' || className == 'Enlight.app.Window' || className == 'Ext.Window' || (deprecated && className == 'Shopware.apps.Deprecated.view.main.Window')) && className != "Ext.window.MessageBox") {
activeWindows.push(item);
}
}
});
return activeWindows;
}
});
Ext.override(Ext.app.Controller, {
getController: function(name) {
if(this.subApplication) {
return this.subApplication.getController(name);
}
return this.callParent(arguments);
},
getStore: function(name) {
if(this.subApplication) {
return this.subApplication.getStore(name);
}
return this.callParent(arguments);
},
getModel: function(model) {
if(this.subApplication) {
return this.subApplication.getModel(model);
}
return this.callParent(arguments);
},
getView: function(view) {
if(this.subApplication) {
return this.subApplication.getView(view);
}
return this.callParent(arguments);
},
control: function(selectors, listeners) {
var me = this;
if(me.subApplication) {
me.subApplication.control(selectors, listeners, me);
} else {
me.application.control(selectors, listeners, me);
}
},
getRef: function(ref, info, config) {
this.refCache = this.refCache || {};
info = info || {};
config = config || {};
Ext.apply(info, config);
if (info.forceCreate) {
return Ext.ComponentManager.create(info, 'component');
}
var me = this,
cached;
me.refCache[ref] = cached = me.getActiveReference(info.selector);
if (!cached && info.autoCreate) {
me.refCache[ref] = cached = Ext.ComponentManager.create(info, 'component');
}
if (cached) {
cached.on('beforedestroy', function() {
me.refCache[ref] = null;
});
}
return cached;
},
getActiveReference: function(selector) {
var me = this,
subApp = me.subApplication,
refs = Ext.ComponentQuery.query(selector),
windowManager, activeRef;
if(!subApp) {
return refs[0];
}
windowManager = subApp.windowManager;
if(!windowManager) {
return refs[0];
}
activeRef = windowManager.getActive();
var returnRef = me.getActiveWindowReference(refs, activeRef);
if(returnRef) {
return returnRef;
}
Ext.each(refs, function(ref) {
if(returnRef) return false;
var win = ref.up('window');
if(!win) return false;
var foundedWindow = me.getActiveWindowReference(win, activeRef);
if(foundedWindow) {
returnRef = ref;
return false;
}
});
return returnRef || refs[0];
},
getActiveWindowReference: function(refs, activeRef) {
var returnRef = false;
Ext.each(refs, function(ref) {
if(returnRef) {
return false;
}
if(ref === activeRef) {
returnRef = ref;
return false;
}
});
return returnRef;
}
});
(function() {
var requestMap = {};
var getRequestKey = Ext.bind(function(path, files) {
files = (typeof files == 'string') ? [files] : files;
return path + ',' + files.join(',');
}, Ext.Loader);
var abortAsyncRequest = Ext.bind(function(requestInfo) {
switch(requestInfo.mode) {
case 'xhr':
Ext.Ajax.abort(requestInfo.identifier);
this.numPendingFiles -= requestInfo.fileCount;
break;
default:
Ext.Error.raise("Unknown requestInfo type. Can not abort");
}
}, Ext.Loader);
var cleanIfAsyncRequestExists = Ext.bind(function(requestKey) {
if (requestMap.hasOwnProperty(requestKey)) {
abortAsyncRequest(requestMap[requestKey]);
delete requestMap[requestKey];
}
}, Ext.Loader);
var loadNamespacedClasses = Ext.bind(function(namespaces) {
var host = window.location.protocol + "//" + window.location.hostname;
Ext.iterate(namespaces, function(key, namespace){
var path = namespace.path,
cacheKey,
disableCachingValue = this.getConfig('disableCachingValue'),
requestMethod = "post",
tmpPath,
maxLength = maxParameterLength - 50,
files = [];
if (maxLength <= 0) {
maxLength = 1950;
}
if (namespace.files.length <= 1 && namespace.files[0].indexOf('?file') !== -1) {
path += namespace.files[0];
requestMethod = "get";
} else {
tmpPath = path;
tmpPath += "?f=";
files = [];
Ext.each(namespace.files, function (file) {
file = file.replace(/^model\//, 'm/');
file = file.replace(/^controller\//, 'c/');
file = file.replace(/^view\//, 'v/');
files.push(file);
});
tmpPath += files.join('|');
if (tmpPath.length + host.length < maxLength) {
requestMethod = "get";
path = tmpPath;
}
}
if (!this.getConfig('caching')) {
path += (requestMethod === 'get') ? '&' : '?';
path += this.getConfig('disableCachingParam') + '=' + disableCachingValue;
}
cacheKey = getRequestKey(path, namespace.files);
if (this.syncModeEnabled) {
cleanIfAsyncRequestExists(cacheKey);
} else {
if (requestMap.hasOwnProperty(cacheKey)) {
return;
}
}
var xhr = Ext.Ajax.request({
url: path,
method: requestMethod,
disableCaching: false,
async: !this.syncModeEnabled,
params: (requestMethod === 'get')
? (null)
: ({ 'file[]': namespace.files }),
scope: this,
success: function(response) {
try {
Ext.globalEval(response.responseText + "\n//@ sourceURL=" + path);
} catch(err) {
Shopware.app.Application.fireEvent('Ext.Loader:evalFailed', err, response, namespace, requestMethod);
}
this.onFilesLoaded(namespace.classNames);
if (requestMap.hasOwnProperty(cacheKey)) {
delete requestMap[cacheKey];
}
},
failure: function(xhr) {
Shopware.app.Application.fireEvent('Ext.Loader:xhrFailed', xhr, namespace, requestMethod);
cleanIfAsyncRequestExists(cacheKey);
}
});
if (!this.syncModeEnabled) {
requestMap[cacheKey] = {
mode: 'xhr',
identifier: xhr,
fileCount: namespace.files.length
};
}
}, this);
}, Ext.Loader);
Ext.Loader.getPath = function(className, prefix) {
var path = '',
paths = this.config.paths,
suffix = this.config.suffixes[prefix] !== undefined ? this.config.suffixes[prefix] : '.js';
if (prefix.length > 0) {
if (prefix === className) {
return paths[prefix];
}
path = paths[prefix];
className = className.substring(prefix.length + 1);
}
if (path.length > 0) {
path = path.replace(/\/+$/, '') + '/';
}
return [path.replace(/\/\.\//g, '/'), className.replace(/\./g, "/") + suffix];
};
Ext.Loader.config.disableCaching = false;
Ext.Loader.config.caching = true;
Ext.Loader.requestQueue = [];
Ext.Loader.require = function(expressions, fn, scope, excludes) {
var Manager = Ext.ClassManager;
var filePath, expression, exclude, className, excluded = {},
excludedClassNames = [],
possibleClassNames = [],
possibleClassName, classNames = [],
namespaces = {}, separatedPath, prefix,
i, j, ln, subLn;
if(!this.getConfig('disableCachingValue')) {
this.setConfig('disableCachingValue', Ext.Date.now());
}
if(this.getConfig('disableCaching')) {
this.setConfig('caching', false);
this.setConfig('disableCaching', false);
}
var disableCachingValue = this.getConfig('disableCachingValue'),
disableCaching = !this.getConfig('caching');
expressions = Ext.Array.from(expressions);
excludes = Ext.Array.from(excludes);
fn = fn || Ext.emptyFn;
scope = scope || Ext.global;
for (i = 0, ln = excludes.length; i < ln; i++) {
exclude = excludes[i];
if (typeof exclude === 'string' && exclude.length > 0) {
excludedClassNames = Manager.getNamesByExpression(exclude);
for (j = 0, subLn = excludedClassNames.length; j < subLn; j++) {
excluded[excludedClassNames[j]] = true;
}
}
}
for (i = 0, ln = expressions.length; i < ln; i++) {
expression = expressions[i];
if (typeof expression === 'string' && expression.length > 0) {
possibleClassNames = Manager.getNamesByExpression(expression);
for (j = 0, subLn = possibleClassNames.length; j < subLn; j++) {
possibleClassName = possibleClassNames[j];
if (!excluded.hasOwnProperty(possibleClassName) && !Manager.isCreated(possibleClassName)) {
Ext.Array.include(classNames, possibleClassName);
}
}
}
}
if (!this.config.enabled) {
if (classNames.length > 0) {
Ext.Error.raise({
sourceClass: "Ext.Loader",
sourceMethod: "require",
msg: "Ext.Loader is not enabled, so dependencies cannot be resolved dynamically. " +
"Missing required class" + ((classNames.length > 1) ? "es" : "") + ": " + classNames.join(', ')
});
}
}
if (classNames.length === 0) {
fn.call(scope);
return this;
}
if (!this.syncModeEnabled) {
this.queue.push({
requires: classNames,
callback: fn,
scope: scope
});
}
classNames = classNames.slice();
for (i = 0, ln = classNames.length; i < ln; i++) {
className = classNames[i];
if (!this.isFileLoaded.hasOwnProperty(className) || !this.isFileLoaded[className]) {
this.isFileLoaded[className] = false;
prefix = this.getPrefix(className);
separatedPath = this.getPath(className, prefix);
filePath = separatedPath.join('');
this.numPendingFiles++;
if(!namespaces[prefix]) {
namespaces[prefix] = { 'prefix': prefix, 'path': separatedPath[0], 'files': [], 'classNames': [] };
}
namespaces[prefix]['files'].push(separatedPath[1]);
namespaces[prefix]['classNames'].push(className);
} else {
if (!this.syncModeEnabled) {
this.refreshQueue();
}
}
}
loadNamespacedClasses(namespaces);
if (this.syncModeEnabled) {
fn.call(scope);
}
return this;
};
Ext.Loader.onFilesLoaded = function(classNames) {
var me = this;
Ext.iterate(classNames, function(className){
me.numLoadedFiles++;
me.isFileLoaded[className] = true;
me.numPendingFiles--;
});
me.refreshQueue();
};
Ext.Loader.setPath = function(name, path, suffix, bulk) {
this.config.paths[name] = path;
if(this.config.suffixes === undefined) {
this.config.suffixes = [];
}
if(suffix !== undefined) {
this.config.suffixes[name] = suffix;
}
return this;
};
})();
Ext.override(Ext.app.EventBus, {
dispatch: function(ev, target, args) {
var bus = this.bus,
selectors = bus[ev],
selector, controllers, id, events, event, i, ln;
if(target && typeof(target.up) === 'function') {
try {
var win = (target.isMainWindow || target.isSubWindow ? target : target.up('window'));
if(win && win.subApplication) {
bus = win.subApplication.eventbus.bus;
selectors = bus[ev];
} else {
var pnl = target.up('panel') || target;
if(pnl && pnl.subApplication) {
bus = pnl.subApplication.eventbus.bus;
selectors = bus[ev];
}
}
} catch(e) { }
}
if (selectors) {
for (selector in selectors) {
if (selectors.hasOwnProperty(selector) && target.is(selector)) {
controllers = selectors[selector];
for (id in controllers) {
if (controllers.hasOwnProperty(id)) {
events = controllers[id];
for (i = 0, ln = events.length; i < ln; i++) {
event = events[i];
if (event.fire.apply(event, Array.prototype.slice.call(args, 1)) === false) {
return false;
}
}
}
}
}
}
}
return true;
},
uncontrol: function(controllerArray) {
var me = this,
bus = me.bus,
deleteThis, idx;
Ext.iterate(bus, function(ev, controllers) {
Ext.iterate(controllers, function(query, controller) {
deleteThis = false;
Ext.iterate(controller, function(controlName) {
idx = controllerArray.indexOf(controlName);
if (idx >= 0) {
deleteThis = true;
}
});
if (deleteThis) {
delete controllers[query];
}
});
});
}
});
Ext.override(Ext.button.Button, {
dataSuffix: 'action',
afterRender: function() {
var me = this;
me.callOverridden(arguments);
if(me.action) {
var dom = me.getEl().dom.children[0].children[0];
dom.setAttribute('data-' + me.dataSuffix, me.action);
}
},
initComponent: function() {
var me = this;
me.callParent(arguments);
me.addEvents(
'click',
'toggle',
'mouseover',
'mouseout',
'menushow',
'menuhide',
'menutriggerover',
'menutriggerout'
);
if (me.menu) {
me.split = true
me.menu = Ext.menu.Manager.get(me.menu);
if(me.menuCls && me.menuCls.length) {
me.menu.setUI('default shopware-ui');
me.menu.addCls(me.menuCls);
}
me.menu.ownerCt = me;
}
if (me.url) {
me.href = me.url;
}
if (me.href && !me.hasOwnProperty('preventDefault')) {
me.preventDefault = false;
}
if (Ext.isString(me.toggleGroup)) {
me.enableToggle = true;
}
},
showMenu: function() {
var me = this;
if (me.rendered && me.menu) {
if (me.tooltip && me.getTipAttr() != 'title') {
Ext.tip.QuickTipManager.getQuickTip().cancelShow(me.btnEl);
}
if (me.menu.isVisible()) {
me.menu.hide();
}
if(me.menu && me.menuOffset) {
me.menu.showBy(me.el, me.menuAlign, me.menuOffset);
} else {
me.menu.showBy(me.el, me.menuAlign);
}
}
return me;
}
});
Ext.define('Ext.LoadMask-Shopware', {
override: 'Ext.LoadMask',
_delayedTask: null,
hideLoadingMsg: false,
hideModal: false,
bindComponent: function(comp){
var me = this,
listeners = {
scope: this,
resize: me.sizeMask,
added: me.onComponentAdded,
removed: me.onComponentRemoved
},
hierarchyEventSource = Ext.container.Container.hierarchyEventSource;
me.hideLoadingMsg = comp.hideLoadingMsg || false;
if (comp.floating) {
listeners.move = me.sizeMask;
me.activeOwner = comp;
} else if (comp.ownerCt) {
me.onComponentAdded(comp.ownerCt);
} else {
me.preventBringToFront = true;
}
me.mon(comp, listeners);
me.mon(hierarchyEventSource, {
show: me.onContainerShow,
hide: me.onContainerHide,
expand: me.onContainerExpand,
collapse: me.onContainerCollapse,
scope: me
});
},
bindStore : function(store, initial) {
var me = this;
me.hideLoadingMsg = me.hideLoadingMsg || false;
if(!me.hideLoadingMsg) {
me.mixins.bindable.bindStore.apply(me, arguments);
}
store = me.store;
if (store && store.isLoading() && !me.hideLoadingMsg) {
me.onBeforeLoad();
}
},
initComponent: function() {
var me = this;
try {
me.callOverridden(arguments);
} catch(err) { }
if(me.delay && me.delay > 0) {
me._delayedTask = new Ext.util.DelayedTask(function() {
me.hide();
});
me._delayedTask.delay(me.delay);
}
},
hide: function() {
try {
this.callOverridden(arguments);
} catch(err) { }
if(this._delayedTask) {
this._delayedTask.cancel();
this._delayedTask = null;
}
},
show: function() {
var me = this;
if (this.isElement) {
this.ownerCt.mask(this.useMsg ? this.msg : '', this.msgCls);
this.fireEvent('show', this);
if(me.hideModal) {
var mask = Ext.get(Ext.getBody().query('.x-mask')[0]);
mask.hide();
}
return;
}
return this.callParent(arguments);
}
});
Ext.override(Ext.form.Field,
{
supportText: '',
helpText: '',
helpWidth: null,
helpTitle: null,
helpTooltipDelay: 250,
helpTooltipDismissDelay: 10000,
supportTextEl: null,
helpIconEl: null,
afterRender: function () {
var me = this;
me.callParent(arguments);
if(me.helpText) {
me.createHelp();
}
if(me.supportText) {
me.createSupport();
}
},
createSupport:function () {
var me = this,
row = new Ext.Element(document.createElement('tr')),
fillCell = new Ext.Element(document.createElement('td')),
cell = new Ext.Element(document.createElement('td')),
supportText = new Ext.Element(document.createElement('div'));
supportText.set({
cls: Ext.baseCSSPrefix +'form-support-text'
});
if(me.supportText) {
supportText.update(me.supportText);
}
supportText.appendTo(cell);
var element = me.getEl().select('tbody');
if(element.elements.length > 1) {
element = element.elements[0];
}
if(me.fieldLabel || !me.hideEmptyLabel) {
fillCell.appendTo(row);
}
cell.appendTo(row);
if(me.helpText) {
var tmpCell = new Ext.Element(document.createElement('td'));
tmpCell.appendTo(row);
}
row.appendTo(element);
me.supportTextEl = supportText;
return supportText;
},
createHelp:function () {
var me = this,
helpIcon = new Ext.Element(document.createElement('span')),
row = new Ext.Element(document.createElement('td'));
row.set({ width: 24, valign: 'top' });
helpIcon.set({ cls: Ext.baseCSSPrefix + 'form-help-icon' });
helpIcon.appendTo(row);
Ext.tip.QuickTipManager.register({
target:helpIcon,
cls: Ext.baseCSSPrefix + 'form-tooltip',
title:(me.helpTitle) ? me.helpTitle : '',
text:me.helpText,
width:(me.helpWidth) ? me.helpWidth : 225,
anchorToTarget: true,
anchor: 'right',
anchorSize: {
width: 24,
height: 24
},
defaultAlign: 'tr',
showDelay: me.helpTooltipDelay,
dismissDelay: me.helpTooltipDismissDelay
});
row.appendTo(this.inputRow);
this.helpIconEl = helpIcon;
return helpIcon;
}
});
Ext.override(Ext.toolbar.Paging, {
getPagingItems: function() {
var me = this;
return [{
itemId: 'first',
tooltip: me.firstText,
overflowText: me.firstText,
iconCls: Ext.baseCSSPrefix + 'tbar-page-first',
action: 'firstPage',
disabled: true,
handler: me.moveFirst,
scope: me
},{
itemId: 'prev',
tooltip: me.prevText,
overflowText: me.prevText,
iconCls: Ext.baseCSSPrefix + 'tbar-page-prev',
action: 'prevPage',
disabled: true,
handler: me.movePrevious,
scope: me
},
'-',
me.beforePageText,
{
xtype: 'numberfield',
itemId: 'inputItem',
name: 'inputItem',
cls: Ext.baseCSSPrefix + 'tbar-page-number',
allowDecimals: false,
minValue: 1,
hideTrigger: true,
enableKeyEvents: true,
selectOnFocus: true,
submitValue: false,
width: me.inputItemWidth,
margins: '-1 2 3 2',
listeners: {
scope: me,
keydown: me.onPagingKeyDown,
blur: me.onPagingBlur
}
},{
xtype: 'tbtext',
itemId: 'afterTextItem',
text: Ext.String.format(me.afterPageText, 1)
},
'-',
{
itemId: 'next',
tooltip: me.nextText,
overflowText: me.nextText,
iconCls: Ext.baseCSSPrefix + 'tbar-page-next',
action: 'nextPage',
disabled: true,
handler: me.moveNext,
scope: me
},{
itemId: 'last',
tooltip: me.lastText,
overflowText: me.lastText,
iconCls: Ext.baseCSSPrefix + 'tbar-page-last',
action: 'lastPage',
disabled: true,
handler: me.moveLast,
scope: me
},
'-',
{
itemId: 'refresh',
tooltip: me.refreshText,
overflowText: me.refreshText,
iconCls: Ext.baseCSSPrefix + 'tbar-loading',
action: 'refreshPage',
handler: me.doRefresh,
scope: me
}];
},
doRefresh : function(){
var me = this,
current = me.store.currentPage,
refreshButton = me.child('#refresh');
if(refreshButton) {
refreshButton.disable();
}
if (me.fireEvent('beforechange', me, current) !== false) {
me.store.loadPage(current);
}
}
});
Ext.override(Ext.Template, {
re: /[{\[]([\w\-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?[}\]]/g
});
Ext.override(Ext.String, {
format: function(format) {
var formatRe = /[{\[](\d+)[}\]]/g;
var args = Ext.Array.toArray(arguments, 1);
return format.replace(formatRe, function(m, i) {
return args[i];
});
}
});
Ext.override(Ext.form.Basic, {
loadRecord: function(record) {
var me = this;
if(record && record.associations && record.associations.length) {
var data = record.getAssociatedData(),
values = Ext.clone(record.data);
Ext.each(record.associations.items, function(item) {
if(!Ext.isObject(item)) {
return;
}
if (data[item.name] !== Ext.undefined) {
var model = Ext.create(item.associatedName, data[item.name][0]);
Ext.each(model.fields.keys, function(key) {
values[item.associationKey + '[' + key + ']'] = model.data[key];
});
}
});
me.setValues(values);
}
if(record) {
me.callOverridden(arguments);
} else {
me._record = undefined;
me.reset();
}
me.fireEvent('recordchange', me, record);
},
updateRecord: function(record) {
record = record || this._record;
var values = this.getValues(),
fields = record.fields,
data = {}, associationModel, associationUpdated;
record.associations.each(function(association) {
var associationStore = record[association.storeName];
associationUpdated = false;
if (!(associationStore instanceof Ext.data.Store)) {
associationStore = Ext.create('Ext.data.Store', {
model: association.associatedName
});
}
if (associationStore.getCount() > 0) {
associationModel = associationStore.first()
} else {
associationModel = Ext.create(association.associatedName);
}
Ext.each(associationModel.fields.keys, function(key) {
var fieldName = association.associationKey + '['+ key +']';
if (fieldName in values) {
associationModel.set(key, values[fieldName]);
associationUpdated = true;
delete values[fieldName];
}
});
if (associationStore.getCount() === 0 && associationUpdated) {
associationStore.add(associationModel);
}
record[association.storeName] = associationStore;
});
fields.each(function(field) {
var name = field.name;
if (name in values) {
data[name] = values[name];
}
});
record.beginEdit();
record.set(data);
record.endEdit();
return this;
}
});
Ext.define('Ext.data.writer.Json-Shopware', {
override: 'Ext.data.writer.Json',
getRecordData: function (record) {
var me = this, data, associationData;
data = me.getRecordFieldData(record);
if (record.associations && record.associations.length > 0) {
me.setRecordAssociationData(record, data);
}
return data;
},
getRecordFieldData: function(record) {
var data = {};
Ext.each(record.fields.keys, function(key) {
data[key] = record.data[key];
});
return data;
},
setRecordAssociationData: function(record, data) {
var me = this, associationStores, associatedData;
record.associations.each(function(association) {
var associationStore = record[association.storeName];
if (associationStore instanceof Ext.data.Store && associationStore.getCount() > 0) {
data[association.associationKey] = [];
associationStore.each(function(associatedRecord) {
if (associatedRecord instanceof Ext.data.Model) {
associatedData = me.getRecordFieldData(associatedRecord);
if (associatedRecord.associations && associatedRecord.associations.length > 0) {
me.setRecordAssociationData(associatedRecord, associatedData);
}
data[association.associationKey].push(associatedData);
}
});
} else {
data[association.associationKey] = [];
}
});
}
});
Ext.override(Ext.grid.column.Action, {
dataSuffix: 'action',
constructor: function(config) {
var me = this,
cfg = Ext.apply({}, config),
items = cfg.items || [me],
l = items.length,
i,
item;
delete cfg.items;
me.callParent([cfg]);
me.items = items;
me.renderer = function(v, meta) {
v = Ext.isFunction(cfg.renderer) ? cfg.renderer.apply(this, arguments)||'' : '';
meta.tdCls += ' ' + Ext.baseCSSPrefix + 'action-col-cell';
for (i = 0; i < l; i++) {
item = items[i];
item.disable = Ext.Function.bind(me.disableAction, me, [i]);
item.enable = Ext.Function.bind(me.enableAction, me, [i]);
var dataString = '';
if (item.action) {
dataString = ' data-' + me.dataSuffix + '="' + item.action + '" ';
}
v += ' +
')
';
}
return v;
};
}
});
Ext.override(Ext.view.BoundList,
{
dataSuffix: 'action',
afterRender: function() {
var me = this;
me.callOverridden(arguments);
if(me.el.dom && me.pickerField) {
var dom = me.el.dom,
value = me.action || me.pickerField.name;
dom.setAttribute('data-' + me.dataSuffix, value);
}
}
});
Ext.override(Ext.form.field.ComboBox,
{
dataSuffix: 'action',
valueSuffix: '-table',
afterRender: function() {
var me = this;
me.callOverridden(arguments);
if(me.el.dom) {
var dom = me.el.dom,
value = (me.listConfig) ? me.listConfig.action : me.name;
dom.setAttribute('data-' + me.dataSuffix, value + me.valueSuffix);
}
}
});
Ext.override(Ext.tree.Panel, {
animate: Ext.isChrome,
initComponent: function() {
var me = this;
me.animate = Ext.isChrome;
me.callOverridden(arguments);
}
});
Ext.override(Ext.panel.Panel, {
animCollapse: Ext.isChrome,
initComponent: function() {
var me = this;
me.animCollapse = Ext.isChrome;
me.callOverridden(arguments);
},
ghost: function(cls, windowMoving) {
var me = this,
ghostPanel = me.ghostPanel,
box = me.getBox(),
header;
if (!ghostPanel) {
ghostPanel = new Ext.panel.Panel({
renderTo: document.body,
floating: {
shadow: false
},
frame: me.frame && !me.alwaysFramed,
alwaysFramed: me.alwaysFramed,
overlapHeader: me.overlapHeader,
headerPosition: me.headerPosition,
baseCls: me.baseCls,
cls: me.baseCls + '-ghost ' + (cls ||'')
});
me.ghostPanel = ghostPanel;
}
ghostPanel.floatParent = me.floatParent;
if (me.floating) {
ghostPanel.setZIndex(Ext.Number.from(me.el.getStyle('zIndex'), (windowMoving) ? -10 : 0));
} else {
if(!windowMoving) {
ghostPanel.toFront();
}
}
if (!(me.preventHeader || (me.header === false))) {
header = ghostPanel.header;
if (header) {
header.suspendLayouts();
Ext.Array.forEach(header.query('tool'), header.remove, header);
header.resumeLayouts();
}
ghostPanel.addTool(me.ghostTools());
ghostPanel.setTitle(me.title);
ghostPanel.setIconCls(me.iconCls);
}
ghostPanel.el.show();
ghostPanel.setPagePosition(box.x, box.y);
Ext.defer(function() {
ghostPanel.setSize(box.width, box.height);
}, 10, me);
me.el.hide();
return ghostPanel;
},
unghost: function(show, matchPosition, windowMoving) {
var me = this;
if (!me.ghostPanel) {
return;
}
if (show !== false) {
me.el.show();
if (matchPosition !== false) {
me.setPagePosition(me.ghostPanel.el.getXY());
if (me.hideMode == 'offsets') {
delete me.el.hideModeStyles;
}
}
if(!windowMoving) {
Ext.defer(me.focus, 10, me);
}
}
me.ghostPanel.el.hide();
},
});
Ext.override(Ext.ZIndexManager, {
_showModalMask: function(comp) {
var me = this,
zIndex = comp.el.getStyle('zIndex') - 4,
maskTarget = comp.floatParent ? comp.floatParent.getTargetEl() : comp.container,
viewSize = maskTarget.getBox(),
viewport = Shopware.app.Application.viewport;
if (maskTarget.dom === document.body) {
viewSize.height = Math.max(document.body.scrollHeight, Ext.dom.Element.getDocumentHeight()) + 1000;
viewSize.width = Math.max(document.body.scrollWidth, viewSize.width);
}
if (!me.mask && !Shopware.app.Application.globalMask) {
var body = Ext.getBody();
if(viewport) {
body = viewport.getActiveDesktop().getEl();
}
me.mask = body.createChild({
cls: Ext.baseCSSPrefix + 'mask'
});
me.mask.setVisibilityMode(Ext.Element.DISPLAY);
me.mask.on('click', me._onMaskClick, me);
Shopware.app.Application.globalMask = me.mask;
}
me.mask = me.mask || Shopware.app.Application.globalMask;
me.mask.insertAfter(comp.el);
me.mask.maskTarget = maskTarget;
maskTarget.addCls(Ext.baseCSSPrefix + 'body-masked');
me.mask.setBox(viewSize);
me.mask.setStyle('zIndex', zIndex);
me.mask.show();
},
register : function(comp, skipGlobalRegister, skipInit) {
var me = this;
skipInit = skipInit || false;
skipGlobalRegister = skipGlobalRegister || false;
if (comp.zIndexManager && !skipGlobalRegister) {
comp.zIndexManager.unregister(comp);
}
if(!skipInit) {
comp.zIndexManager = me;
}
me.list[comp.id] = comp;
me.zIndexStack.push(comp);
comp.on('hide', me.onComponentHide, me);
}
});
Ext.override(Ext.MessageBox, {
afterRender: function() {
var me = this,
toolbar = me.dockedItems.getAt(1);
toolbar.addCls('shopware-toolbar');
toolbar.setUI('shopware-ui');
Ext.each(me.msgButtons, function(button) {
if(button.itemId === 'ok' || button.itemId === 'yes') {
button.addCls('primary')
} else {
button.addCls('secondary');
}
});
me.callOverridden(arguments);
}
})
Ext.override(Ext.grid.RowEditor, {
getFloatingButtons: function() {
var me = this,
cssPrefix = Ext.baseCSSPrefix,
btnsCss = cssPrefix + 'grid-row-editor-buttons',
plugin = me.editingPlugin,
btns;
if (!me.floatingButtons) {
btns = me.floatingButtons = new Ext.Container({
renderTpl: [
'',
'',
'',
'',
'',
'{%this.renderContainer(out,values)%}'
],
width: 200,
renderTo: me.el,
baseCls: btnsCss,
layout: {
type: 'hbox',
align: 'middle'
},
defaults: {
flex: 1,
margins: '0 1 0 1'
},
items: [{
itemId: 'update',
xtype: 'button',
cls: 'primary small',
handler: plugin.completeEdit,
scope: plugin,
text: me.saveBtnText,
disabled: !me.isValid,
minWidth: Ext.panel.Panel.prototype.minButtonWidth
}, {
xtype: 'button',
handler: plugin.cancelEdit,
scope: plugin,
cls: 'secondary small',
text: me.cancelBtnText,
minWidth: Ext.panel.Panel.prototype.minButtonWidth
}]
});
me.mon(btns.el, {
mousedown: Ext.emptyFn,
click: Ext.emptyFn,
stopEvent: true
});
}
return me.floatingButtons;
}
})
Ext.override(Ext.picker.Date, {
beforeRender: function () {
var me = this;
me.callOverridden();
if(me.todayBtn) {
me.todayBtn.addCls('small').addCls('secondary');
}
}
});
Ext.define('Ext.data.association.HasMany-Shopware', {
override: 'Ext.data.association.HasMany',
lazyLoading: true,
relation: undefined,
storeClass: undefined,
field: undefined,
createStore: function() {
var that = this,
associatedModel = that.associatedModel,
storeName = that.storeName,
foreignKey = that.foreignKey,
primaryKey = that.primaryKey,
filterProperty = that.filterProperty,
autoLoad = that.autoLoad,
storeConfig = that.storeConfig || {};
return function() {
var me = this,
config, filter,
modelDefaults = {};
if (me[storeName] === undefined) {
if (filterProperty) {
filter = {
property : filterProperty,
value : me.get(filterProperty),
exactMatch: true
};
} else {
filter = {
property : foreignKey,
value : me.get(primaryKey),
exactMatch: true
};
}
modelDefaults[foreignKey] = me.get(primaryKey);
config = Ext.apply({}, storeConfig, {
model : associatedModel,
filters : [filter],
remoteFilter : false,
modelDefaults: modelDefaults,
association : that
});
if (that.hasOwnProperty('storeClass')) {
config.extraParams = {
id: me.get(primaryKey),
association: that.associationKey
};
me[storeName] = Ext.create(that.storeClass, config);
} else {
me[storeName] = Ext.data.AbstractStore.create(config);
if (autoLoad) {
me[storeName].load();
}
}
}
return me[storeName];
};
}
});
Ext.define('Enlight.app.Window', {
ui: 'default',
width: 800,
height: 600,
maximizable: true,
minimizable: true,
stateful: true,
border: false,
minimized: false,
focusable: true,
hideOnClose: true,
forceToFront: false,
extend: 'Ext.window.Window',
requires: [ 'Ext.WindowManager' ],
footerButton: true,
isWindowOnFront: false,
activeCls: Ext.baseCSSPrefix + 'window-active',
isMainWindow: false,
isSubWindow: false,
onAfterRenderComponent: function() {
var me = this,
subApp = me.subApplication || me.subApp, windowManager, windowCount;
if(!subApp) {
return;
}
windowManager = subApp.windowManager;
windowCount = windowManager.subWindows.getCount();
windowManager.register(me, true, true);
if(windowManager.zIndexStack.length == 1) {
var mainWindow = me;
mainWindow.isMainWindow = true;
windowManager.mainWindow = mainWindow;
mainWindow.on({
beforeclose: me.onBeforeDestroyMainWindow,
scope: me
});
} else {
if(!windowManager.multipleSubWindows && windowCount == 1) {
if(Ext.isDefined(Ext.global.console)) {
Ext.global.console.warn('Enlight.app.Window: The sub application is configured to only support one opened sub window at once.');
}
}
this.$subWindowId = Ext.id();
windowManager.subWindows.add(this.$subWindowId, this);
me.isSubWindow = true;
me.on({
scope: me,
beforedestroy: function() {
windowManager.subWindows.removeAtKey(this.$subWindowId);
}
});
}
windowManager.bringToFront(me);
},
onBeforeDestroyMainWindow: function () {
var me = this,
subApp = me.subApplication,
windowManager, count, subWindows,
subWindowConfirmationBlackList = [ 'Shopware.apps.Category', 'Shopware.apps.Voucher' ];
if (!subApp.hasOwnProperty('windowManager') || !subApp.windowManager) {
return true;
}
windowManager = subApp.windowManager;
count = windowManager.subWindows.getCount();
if (!count) {
if (Ext.isFunction(me.hide)) {
me.hide();
return true;
}
}
subWindows = windowManager.subWindows.items;
if (Ext.Array.contains(subWindowConfirmationBlackList, me.subApplication.$className)) {
me.closeSubWindows(subWindows, windowManager);
return true;
}
Ext.Msg.confirm('Modul schließen', 'Sollen alle Unterfenster vom "' + me.title + '"-Modul geschlossen werden?', function (button) {
if (button == 'yes') {
me.closeSubWindows(subWindows, windowManager);
me.destroy();
}
});
return false;
},
initComponent: function() {
var me = this;
me.subApplication = me.initialConfig.subApp || this.subApp;
delete this.subApp;
if(!me.preventHeader) {
me.constrain = true;
me.isWindow = true;
}
me.on({
dragstart: me.onMoveStart,
dragend: me.onMoveEnd
}, me);
var viewport = Shopware.app.Application.viewport;
if(viewport && Shopware.apps.Index && me.forceToFront == false) {
var activeDesktop = viewport.getActiveDesktop(),
activeEl = activeDesktop.getEl();
me.desktop = activeDesktop;
me.desktopPosition = viewport.getActiveDesktopPosition();
me.renderTo = activeEl;
me.constrainTo = activeEl;
} else {
me.renderTo = Ext.getBody();
}
if(!me.footerButton) {
me.maximizable = false;
me.minimizable = false;
}
if(me.forceToFront) {
me.minimizable = false;
}
me.callParent(arguments);
me.isWindowOnFront = true;
me.center();
},
afterShow: function() {
var me = this;
me.callParent(arguments);
Ext.Function.defer(function() {
window.scrollTo(0, 0);
}, 10);
if(me.forceToFront) {
var el = me.getEl(), elDom;
if(!el) {
return false;
}
elDom = el.dom;
el.dom.style.zIndex = "999999";
}
},
afterRender: function() {
var me = this;
me.callParent(arguments);
me.onAfterRenderComponent.call(me);
if(me.footerButton) {
Shopware.WindowManagement.addItem(me.title, me);
}
},
minimize: function() {
this.fireEvent('minimize', this);
this.minimized = true;
this.hide();
if(this._toolbarBtn) {
this._toolbarBtn.toggle(false, true);
}
},
doClose: function() {
var me = this;
if(me.hideOnClose) {
me.hideOnClose = false;
me.hide(me.animateTarget, me.doClose, me);
}
if (me.hidden) {
me.fireEvent('close', me);
if (me.closeAction == 'destroy') {
this.destroy();
}
} else {
me.hide(me.animateTarget, me.doClose, me);
}
if(this._toolbarBtn) {
Shopware.WindowManagement.removeItem(this._toolbarBtn);
}
},
onMoveStart: function() {
var me = this, activeWindows = Shopware.app.Application.getActiveWindows(), viewport = Shopware.app.Application.viewport;
if(viewport) {
me.hiddenLayer = viewport.getHiddenLayer();
me.hiddenLayer.setStyle('z-index', '9999999');
me.hiddenLayer.appendTo(Ext.getBody());
}
Ext.each(activeWindows, function(window) {
if(window != me) {
if(window.$className !== 'Shopware.apps.Deprecated.view.main.Window') {
window.ghost('', true);
}
}
});
},
onMoveEnd: function() {
var me = this, activeWindows = Shopware.app.Application.getActiveWindows(), viewport = Shopware.app.Application.viewport;
Ext.each(activeWindows, function(window) {
if(!window.minimized && window != me) {
if(window.$className !== 'Shopware.apps.Deprecated.view.main.Window') {
window.unghost(true, true, true);
}
}
});
Ext.WindowManager.bringToFront(me);
if(viewport) {
viewport.jumpTo(me.desktopPosition, true);
me.hiddenLayer.setStyle('z-index', null);
Ext.removeNode(me.hiddenLayer.dom);
}
},
onMouseDown: function() {
var me = this,
subApp = me.subApplication || me.subApp,
windowManager = subApp.windowManager;
try {
windowManager.bringToFront(me);
} catch(e) {}
me.callParent(arguments);
},
fitContainer: function() {
var me = this,
parent = me.floatParent,
container = parent ? parent.getTargetEl() : me.container,
size = container.getViewSize(false);
size.height = size.height - 20;
me.setSize(size);
me.setPosition.apply(me, [0, 0]);
},
maximize: function() {
var me = this;
if (!me.maximized) {
me.expand(false);
if (!me.hasSavedRestore) {
me.restoreSize = me.getSize();
me.restorePos = me.getPosition(true);
}
if (me.maximizable) {
me.header.tools.maximize.hide();
me.header.tools.restore.show();
}
me.maximized = true;
me.el.disableShadow();
if (me.dd) {
me.dd.disable();
}
if (me.resizer) {
me.resizer.disable();
}
if (me.collapseTool) {
me.collapseTool.hide();
}
me.el.addCls(Ext.baseCSSPrefix + 'window-maximized');
me.container.addCls(Ext.baseCSSPrefix + 'window-maximized-ct');
me.syncMonitorWindowResize();
me.fitContainer();
me.fireEvent('maximize', me);
}
return me;
},
restore: function() {
var me = this,
header = me.header,
tools = header.tools;
if (me.maximized) {
delete me.hasSavedRestore;
me.removeCls(Ext.baseCSSPrefix + 'window-maximized');
if (tools.restore) {
tools.restore.hide();
}
if (tools.maximize) {
tools.maximize.show();
}
if (me.collapseTool) {
me.collapseTool.show();
}
me.maximized = false;
me.setPosition(me.restorePos);
me.setSize(me.restoreSize);
delete me.restorePos;
delete me.restoreSize;
me.el.enableShadow(true);
if (me.dd) {
me.dd.enable();
if (header) {
header.addCls(header.indicateDragCls)
}
}
if (me.resizer) {
me.resizer.enable();
}
me.container.removeCls(Ext.baseCSSPrefix + 'window-maximized-ct');
me.syncMonitorWindowResize();
me.doConstrain();
me.fireEvent('restore', me);
}
return me;
},
closeSubWindows: function(subWindows, windowManager) {
Ext.each(subWindows, function(subWindow) {
if(subWindow) {
windowManager.subWindows.removeAtKey(subWindow.$subWindowId);
subWindow.destroy();
}
});
}
});
Ext.define('Enlight.app.SubWindow', {
extend: 'Enlight.app.Window',
alias: 'widget.subwindow',
footerButton: false,
isSubWindow: true
});
Ext.define('Enlight.app.SubApplication', {
extend: 'Ext.app.Controller',
requires: [
'Ext.ModelManager',
'Ext.data.Model',
'Ext.data.StoreManager',
'Ext.ComponentManager',
'Ext.app.EventBus',
'Ext.ZIndexManager',
'Enlight.app.Window'
],
scope : undefined,
beforeLaunch : Ext.emptyFn,
launch : Ext.emptyFn,
initControllers: true,
eventbus: null,
multipleSubWindows: true,
constructor: function(config){
config = config || {};
var me = this,
controllers = Ext.Array.from(config.controllers);
me.eventbus = Ext.create('Ext.app.EventBus');
me.windowManager = Ext.create('Ext.ZIndexManager');
me.windowManager.multipleSubWindows = me.multipleSubWindows;
Ext.apply(config, {
documentHead : Ext.getHead(),
id : config.id
});
Ext.apply(me, {
appControllers : (controllers.length) ? controllers : me.controllers,
controllers : Ext.create('Ext.util.MixedCollection'),
stores : Ext.create('Ext.util.MixedCollection'),
eventbus : me.eventbus,
windowManager : me.windowManager
});
me.callParent(arguments);
},
init: function() {
var me = this;
Shopware.app.Application.fireEvent('subAppLoaded', me);
me.onBeforeLaunch();
},
addController: function(controller, skipInit) {
var me = this,
app = me.app,
controllers = me.controllers,
prefix = Ext.Loader.getPrefix(controller.name);
controller.application = app;
controller.subApplication = me;
controller.id = controller.id || controller.name;
if (prefix === '' || prefix === controller.name) {
controller.name = this.name + '.controller.' + controller.name;
}
if (Ext.isDefined(controller.name)) {
var name = controller.name;
delete controller.name;
controller = Ext.create(name, controller);
}
controller.$controllerId = Ext.id()
controllers.add(controller.$controllerId, controller);
if (!skipInit) {
controller.init();
}
return controller;
},
removeController: function(controller, removeListeners) {
removeListeners = removeListeners || true;
var me = this,
controllers = me.controllers;
var key = controllers.indexOf(controller);
controllers.removeAt(key);
if (removeListeners) {
var bus = me.eventbus;
bus.uncontrol([controller.id]);
}
},
addSubApplication: function(subapp) {
var me = this,
app = me.app,
subapps = app.subApplications;
subapp.$subAppId = Ext.id();
subapps.add(subapp.$subAppId, subapp);
return subapp;
},
removeSubApplication: function(subapp) {
var me = this,
app = me.app,
subapps = app.subApplications;
var key = subapps.indexOf(subapp);
subapps.removeAt(key);
},
onBeforeLaunch: function() {
var me = this,
app = me.app,
controllers = me.appControllers,
windowManager = me.windowManager,
controller, cmp;
if(!windowManager.hasOwnProperty('mainWindow')) {
windowManager.mainWindow = null;
}
if(!windowManager.hasOwnProperty('subWindows')) {
windowManager.subWindows = Ext.create('Ext.util.MixedCollection');
}
if (app) {
Ext.each(controllers, function(controlName) {
controller = me.addController({
name: controlName
}, !me.initControllers);
});
delete me.appControllers;
Ext.applyIf(app, {
subApplications : Ext.create('Ext.util.MixedCollection')
});
me.addSubApplication(me);
}
if(Shopware.app.Application.moduleLoadMask) {
Shopware.app.Application.moduleLoadMask.hide();
}
me.beforeLaunch.call(me.scope || me);
cmp = me.launch.call(me.scope || me);
if (cmp) {
me.cmp = cmp;
me.cmp.on('destroy', me.handleSubAppDestroy, me, { single: true });
}
},
handleSubAppDestroy: function(cmp) {
var me = this,
controllers = me.controllers;
controllers.each(function(controller) {
me.removeController(controller);
});
me.removeSubApplication(me);
me.eventbus = null;
me.windowManager = null;
me = null;
},
getModuleClassName: function(name, type) {
var namespace = Ext.Loader.getPrefix(name);
if (namespace.length > 0 && namespace !== name) {
return name;
}
return this.name + '.' + type + '.' + name;
},
getController: function(name) {
var controller = this.controllers.findBy(function(item) {
if(item.id === name) {
return true;
}
}, this);
if (!controller) {
return this.addController({ name: name});
}
return controller;
},
getStore: function(name) {
var store = this.stores.get(name);
if (!store) {
store = Ext.StoreManager.get(name);
if(store && !store.autoLoad) {
store = null;
}
}
if (!store) {
store = Ext.create(this.getModuleClassName(name, 'store'), {
application: this,
storeId: name,
id: name
});
this.stores.add(store);
}
return store;
},
getModel: function(model) {
model = this.getModuleClassName(model, 'model');
return Ext.ModelManager.getModel(model);
},
getView: function(view) {
view = this.getModuleClassName(view, 'view');
var cls = Ext.ClassManager.get(view);
cls.prototype.subApp = this;
return cls;
},
control: function(selectors, listeners, controller) {
if(this.hasOwnProperty('eventbus') && this.eventbus) {
this.eventbus.control(selectors, listeners, controller);
} else {
return false;
}
},
setAppWindow: function(win) {
var me = this;
if(win.isSubWindow) {
win.isSubWindow = false;
me.windowManager.subWindows.removeAtKey(win.$subWindowId);
delete win.$subWindowId;
}
if(me.cmp) {
me.un('beforeclose', me.cmp.onBeforeDestroyMainWindow, me);
me.un('destory', me.handleSubAppDestroy, me);
}
me.cmp = win;
me.cmp.on({
destroy: me.handleSubAppDestroy,
scope: me
});
me.cmp.on({
beforeclose: me.cmp.onBeforeDestroyMainWindow,
scope: me.cmp
});
win.mainWindow = true;
me.windowManager.bringToFront(win);
return me.windowManager.mainWindow = win;
}
});
Ext.Class.registerPreprocessor('shopware.subappLoader', function(cls, data, hooks, fn) {
var className = Ext.getClassName(cls),
match = className.match(/^(Shopware|Enlight)\.controller\.|(.*)\.apps\./),
requires = [],
modules = ['model', 'view', 'store', 'controller'],
prefix;
if (!data.hasOwnProperty('extend') || data.extend.prototype.$className != 'Enlight.app.SubApplication' || match === null) {
return true;
}
var i, ln, module,
items, j, subLn, item;
if(data.name === undefined) {
data.name = className;
}
if(data.loadPath !== undefined) {
Ext.Loader.setPath(data.name, data.loadPath, '', data.bulkLoad);
}
for (i = 0,ln = modules.length; i < ln; i++) {
module = modules[i];
items = Ext.Array.from(data[module + 's']);
for (j = 0,subLn = items.length; j < subLn; j++) {
item = items[j];
prefix = Ext.Loader.getPrefix(item);
if (prefix === '' || prefix === item) {
requires.push(data.name + '.' + module + '.' + item);
} else {
requires.push(item);
}
}
}
Ext.require(requires, Ext.pass(fn, [cls, data, hooks], this));
return false;
}, true, 'after', 'loader');
Ext.define('Enlight.app.Controller', {
extend: 'Ext.app.Controller',
getController: function(name) {
return this.subApplication.getController(name);
},
getStore: function(name) {
return this.subApplication.getStore(name);
},
getModel: function(model) {
return this.subApplication.getModel(model);
},
getView: function(view) {
return this.subApplication.getView(view);
},
getEventBus: function() {
return this.subApplication.eventbus;
},
control: function(selectors, listeners) {
var me = this;
if(me.subApplication) {
me.subApplication.control(selectors, listeners, me);
} else {
me.application.control(selectors, listeners, me);
}
}
});
Ext.define('Ext.util.FileUpload', {
extend:'Ext.container.Container',
alternateClassName: [ 'Ext.FileUpload', 'Shopware.app.FileUpload' ],
alias:'widget.html5fileupload',
padding:20,
requestURL: null,
supportsFileAPI: !!window.FileReader,
showInput:true,
checkAmount: true,
maxAmount: 3,
maxAmountErrorFunction: Ext.emptyFn,
checkType: true,
validTypes: [
'gif', 'png', 'tiff',
'jpeg', 'jpg', 'jpe',
'rar', 'zip', 'tar'
],
validTypeErrorFunction: Ext.emptyFn,
checkSize: false,
maxSize: 2097152,
maxSizeErrorFunction: Ext.emptyFn,
afterUploadFunction: Ext.emptyFn,
fileInputConfig:{
name:'images[]',
fieldLabel: 'Bild(er) auswählen',
buttonText:'Bild(er) selektieren',
labelStyle:'font-weight: 700',
labelWidth:125,
allowBlank:true,
width: 450,
buttonConfig: {
cls: 'secondary small',
iconCls: 'sprite-inbox-image'
}
},
inputConfig: {},
dropZoneTpl: [
'',
'',
'',
"{actualQuantity} " + "{snippet name=file_upload/progress_bar_text default='from' namespace='backend/component/file_upload'}von{/snippet}" + " {totalQuantity} ",
'',
'{text}',
'',
'
'
],
dropZoneCls:'-dropzone',
dropZoneOverCls:'dropzone-over',
dropZoneDropCls:'dropzone-drop',
dropZoneText: 'oder drag & drop die Dateien hier rein',
dropItemCls: 'dropzone-item',
dropItemImageCls: 'dropzone-item-image',
dropItemInfoCls: 'dropzone-item-info',
dropItemTpl: [
'',
'
Name: {name:ellipsis(30)}
',
'
Größe: {size}kB
',
'
',
'',
'',
"{actualQuantity} " + "{snippet name=file_upload/progress_bar_text default='from' namespace='backend/component/file_upload'}von{/snippet}" + " {totalQuantity} ",
'',
'{text}',
'',
'
'
);
},
createDropZoneEvents:function () {
var me = this, el = me.dropZone.getEl().dom;
el.addEventListener('dragenter', function (event) {
me.dropZone.getEl().addCls(me.dropZoneOverCls);
event.preventDefault();
event.stopPropagation();
}, false);
el.addEventListener('dragover', function (event) {
event.preventDefault();
event.stopPropagation();
}, false);
el.addEventListener('dragleave', function (event) {
var target = event.target;
if (target && target === el) {
me.dropZone.getEl().removeCls(me.dropZoneOverCls);
}
event.preventDefault();
event.stopPropagation();
}, false);
el.addEventListener('drop', function (event) {
var dropEl = me.dropZone.getEl(), files;
event.preventDefault();
event.stopPropagation();
if (dropEl.hasCls(me.dropZoneOverCls)) {
dropEl.removeCls(me.dropZoneOverCls);
}
dropEl.addCls(me.dropZoneDropCls);
if (event.dataTransfer && event.dataTransfer.files) {
files = event.dataTransfer.files;
}
me.iterateFiles(files);
}, false);
},
createFileInputField:function () {
var me = this, file, el, ret;
var config = Ext.apply(me.inputConfig, me.fileInputConfig);
config.name = me.fileField;
file = me.inputFileCmp = Ext.create('Ext.form.field.File', config);
ret = file;
file.on('afterrender', function () {
el = file.fileInputEl.dom;
if(!me.showLegacyBrowserNotice) {
el.setAttribute('multiple', 'multiple');
el.setAttribute('size', '5');
}
}, me);
if(Ext.isIE || Ext.isSafari) {
me.form = Ext.create('Ext.form.Panel', {
unstyled: true,
layout: 'anchor',
url: me.requestURL,
items: [ file ]
});
ret = me.form;
}
file.on('change', function(field) {
var fileField = field.getEl().down('input[type=file]').dom;
if(Ext.isIE || Ext.isSafari) {
me.form.getForm().submit({
method: 'POST',
success: function() {
me.fireEvent('uploadReady', null);
}
});
return false;
}
Ext.each(fileField.files, function(file) {
var timeout = window.setTimeout(function() {
me.uploadFile(file, 0, null, fileField.files.length);
clearTimeout(timeout);
timeout = null;
}, 10);
});
}, me);
return ret;
},
iterateFiles:function (files) {
var me = this;
if (typeof(files) === 'undefined') {
return false;
}
if(me.checkAmount) {
if(files.length > me.maxAmount) {
if(me.maxAmountErrorFunction) {
me.maxAmountErrorFunction.call();
}
return false;
}
}
if (me.enablePreviewImage) {
for (var i = 0, l = files.length; i < l; i++) {
me.createPreviewImage(files[i]);
}
} else {
me.createPreview(files);
}
},
createPreview: function(files) {
var me = this;
if(me.dropZone !== Ext.undefined) {
me.dropZone.removeAll();
var text = Ext.create('Ext.Component', {
renderTpl: me.dropZoneTpl,
tpl: me.dropZoneTpl,
renderData: {
actualQuantity: '0',
totalQuantity: files.length,
text: me.snippets.uploadReady
}
});
text.addClass('small-padding');
var progressBar = Ext.create('Ext.Component', {
cls: me.progressBarCls,
tpl: me.progressBarTpl
});
progressBar.update({ percent: 0 });
progressBar.value = 0;
var infoPnl = Ext.create('Ext.panel.Panel', {
ui: 'plain',
cls: me.dropItemCls,
items: [ progressBar ]
});
me.dropZone.add(text);
me.dropZone.add(infoPnl);
}
Ext.each(files, function(file) {
var timeout = window.setTimeout(function() {
me.uploadFile(file, progressBar, text, files.length);
clearTimeout(timeout);
timeout = null;
}, 10);
});
},
createPreviewImage: function (file) {
var reader = new FileReader, img, me = this;
reader.onload = (function() {
return function(event) {
var format, progressBar, kbValue, info, infoPnl;
if(me.checkType) {
format = file.type;
format = format.replace(/(.*\/)/i, '');
if(!me.in_array(format, me.validTypes)) {
if(me.validTypeErrorFunction) {
me.validTypeErrorFunction.call();
}
return false;
}
}
if(me.checkSize && me.maxSize < file.size) {
if(me.maxSizeErrorFunction) {
me.maxSizeErrorFunction.call(me, file.size);
}
return false;
}
if(me.initial) {
me.dropZone.removeAll();
me.initial = false;
}
progressBar = Ext.create('Ext.Component', {
cls: me.progressBarCls,
tpl: me.progressBarTpl
});
progressBar.update({ percent: 0 });
progressBar.addClass(me.previewEnabledCls);
kbValue = ~~(file.size / 1000);
info = Ext.create('Ext.Component', {
renderTpl: me.dropItemTpl,
columnWidth: .7,
renderData: {
infoCls: me.dropItemInfoCls,
name: file.name,
size: kbValue
},
items: [ progressBar ]
});
if((/image/i).test(file.type)) {
img = Ext.create('Ext.container.Container', {
cls: me.dropItemImageCls,
layout: 'column',
items: [{
xtype: 'image',
columnWidth: .3,
src: event.target.result
}, info ]
});
} else {
img = Ext.create('Ext.container.Container', {
cls: me.dropItemImageCls,
layout: 'column',
items: [{
xtype: 'container',
cls: 'ico-package',
columnWidth: .3
}, info ]
});
}
infoPnl = Ext.create('Ext.panel.Panel', {
ui: 'plain',
cls: me.dropItemCls,
items: [ img, progressBar ]
});
me.dropZone.add(infoPnl);
me.uploadFile(file, progressBar, infoPnl);
}
}(img));
reader.readAsDataURL(file);
},
uploadFile: function (file, progressBar, infoText, count) {
var xhr = new XMLHttpRequest(),
me = this;
progressBar = progressBar || 0;
infoText = infoText || null;
xhr.open("post", me.requestURL, false);
xhr.addEventListener('load', function(e) {
var target = e.target,
response = Ext.decode(target.responseText);
if (response.success == false && response.blacklist == true) {
Shopware.Notification.createGrowlMessage(me.snippets.blackListTitle, Ext.String.format(me.snippets.blackListMessage, response.extension));
}
if(me.checkSize && me.maxSize < file.size) {
if(me.maxSizeErrorFunction) {
me.maxSizeErrorFunction.call(me, file.size);
}
return false;
}
if (me.enablePreviewImage) {
progressBar.update({ percent: 100 });
} else {
if(Ext.isNumeric(progressBar)) {
progressBar++;
} else {
progressBar.value++;
progressBar.update( { percent: (progressBar.value / count) * 100 } );
}
if(infoText) {
infoText.tpl = me.createDropZoneTemplate();
infoText.renderTpl = me.createDropZoneTemplate();
try {
infoText.update({
actualQuantity: progressBar.value,
totalQuantity: count,
text: me.snippets.uploadReady
});
} catch(e) {
}
}
}
if (target.readyState === 4 && target.status === 200) {
try {
me.fireEvent('fileUploaded', target);
} catch(e) {
}
}
if (infoText && progressBar.value === count) {
if(me.dropZone !== Ext.undefined) {
me.dropZone.removeAll();
var text = Ext.create('Ext.Component', {
renderTpl: me.dropZoneTpl,
tpl : me.dropZoneTpl,
renderData: {
text: me.dropZoneText
}
});
me.dropZone.add(text);
}
me.fireEvent('uploadReady', target);
if (response.success) {
Shopware.Msg.createGrowlMessage(me.snippets.messageTitle, Ext.String.format(me.snippets.messageText, count), 'Media-Manager');
}else{
Ext.Msg.alert(me.snippets.maxUploadSizeTitle, me.snippets.maxUploadSizeText);
}
} else {
me.fireEvent('uploadReady', target);
}
}, false);
var formData = new FormData();
formData.append(this.fileField, file);
xhr.send(formData);
},
in_array: function(needle, haystack, argStrict) {
var key = '',
strict = !! argStrict;
if (strict) {
for (key in haystack) {
if (haystack[key] === needle) {
return true;
}
}
} else {
for (key in haystack) {
if (haystack[key] == needle) {
return true;
}
}
}
return false;
}
});
Ext.define('Enlight.app.WindowManagement', {
alternateClassName: [ 'Shopware.app.WindowManagement', 'Shopware.WindowManagement' ],
singleton: true,
extend: 'Ext.app.Controller',
requires: [ 'Ext.WindowManager' ],
defaultCls: 'footer-btn',
defaultIconCls: 'closeable',
initial: true,
view: null,
footer: null,
viewport: null,
init: function(footer) {
var me = this;
if(me.initial) {
me.view = Ext.create('Ext.container.Container', {
cls: 'window-management-holder',
autoScroll: true
});
me.footer = footer;
me.viewport = footer.ownerCt;
me.footer.add(me.view);
me.inital = false;
}
footer.on('afterrender', me.onFooterRendered, me);
me.callParent(arguments);
},
addItem: function(text, view) {
var btn, me = this;
if(!me.view) {
return btn;
}
view = view || {};
btn = Ext.create('Ext.button.Button', {
cls: me.defaultCls,
iconCls: me.defaultIconCls,
text: text || 'Window',
responsibleView: view,
handler: me.onButtonClick
});
view._toolbarBtn = btn;
me.view.add(btn);
me.setActiveItem(btn);
view.on('destroy', function() {
if(view._toolbarBtn) {
view._toolbarBtn.destroy();
}
}, me);
return btn;
},
setActiveItem: function(btn) {
if(this.view.items.items && this.view.items.items.length > 0) {
Ext.each(this.view.items.items, function(item) {
item.toggle(false, true);
});
}
btn.toggle(true, true);
return btn;
},
removeItem: function(btn) {
this.view.remove(btn, true);
return true;
},
removeAt: function(key) {
this.view.remove(key, true);
return true;
},
getAt: function(key) {
return this.view.items.items[key];
},
getAllItems: function() {
return this.view.items.items;
},
removeAllItems: function() {
this.view.removeAll(true);
return true;
},
onButtonClick: function(btn, e) {
if(!btn.responsibleView) {
return false;
}
var view = btn.responsibleView,
viewport = Shopware.app.Application.viewport,
icn = btn.btnIconEl,
minHeight = icn.getY(),
maxHeight = icn.getY() + icn.getHeight(),
minWidth = icn.getX(),
maxWidth = icn.getX() + icn.getWidth();
if(e.getY() >= minHeight && e.getY() <= maxHeight &&
e.getX() >= minWidth && e.getX() <= maxWidth) {
if(view.closeAction == 'destroy') {
view.destroy();
} else {
view.hide();
}
return false;
}
if(viewport.getActiveDesktopPosition() !== view.desktop) {
viewport.jumpTo(view.desktopPosition);
}
if(view.minimized) {
view.show();
btn.toggle(true, true);
view.minimized = false;
}
var isModal = false;
Ext.each(Ext.WindowManager.zIndexStack, function(item) {
if(item && item.modal && item.modal === true && item.getEl().isVisible()) {
isModal = true;
}
});
if(!isModal) {
Ext.WindowManager.bringToFront(view);
}
Shopware.app.WindowManagement.setActiveItem(btn);
},
onFooterRendered: function(cmp) {
this.viewport = cmp.ownerCt;
},
minimizeAll: function() {
var wins = this.getActiveWindows();
Ext.each(wins, function(win) {
win.minimize();
});
return true;
},
closeAll: function() {
var wins = this.getActiveWindows();
Ext.each(wins, function(win) {
win.destroy();
});
Shopware.app.WindowManagement.removeAllItems();
return true;
},
stackVertical: function() {
var activeWindows = this.getActiveWindows(),
viewport = Shopware.app.WindowManagement.viewport,
footer = Shopware.app.WindowManagement.footer,
size = viewport.getSize(), count, windowHeight,
footerSize = footer.getSize();
count = activeWindows.length;
windowHeight = (Ext.Element.getViewportHeight() - (footerSize.height * 2)) / count;
Ext.each(activeWindows, function(window, index) {
window.setSize({ width: size.width, height: windowHeight });
window.setPosition(0, windowHeight * index);
});
return true;
},
stackHorizontal: function() {
var activeWindows = this.getActiveWindows(),
viewport = Shopware.app.WindowManagement.viewport,
footer = Shopware.app.WindowManagement.footer,
size = viewport.getSize(), count, windowWidth,
footerSize = footer.getSize();
count = activeWindows.length;
windowWidth = (Ext.Element.getViewportWidth()) / count;
Ext.each(activeWindows, function(window, index) {
window.setSize({ width: windowWidth, height: size.height - (footerSize.height * 2) });
window.setPosition(windowWidth * index, 0);
window.show();
});
return true;
},
getActiveWindows: function () {
var activeWindows = [];
Ext.each(Shopware.app.Application.subApplications.items, function (subApp) {
if(!subApp.windowManager || !subApp.windowManager.hasOwnProperty('zIndexStack')) {
return;
}
Ext.each(subApp.windowManager.zIndexStack, function (item) {
if (typeof(item) !== 'undefined' && item.$className === 'Ext.window.Window' || item.$className === 'Shopware.apps.Deprecated.view.main.Window' || item.$className === 'Enlight.app.Window' || item.$className == 'Ext.Window' && item.$className !== "Ext.window.MessageBox") {
activeWindows.push(item);
}
if (item.alternateClassName === 'Ext.window.Window' || item.alternateClassName === 'Shopware.apps.Deprecated.view.main.Window' || item.alternateClassName === 'Enlight.app.Window' || item.alternateClassName == 'Ext.Window' && item.$className !== "Ext.window.MessageBox") {
activeWindows.push(item);
}
});
});
return activeWindows;
}
});
Ext.define('Enlight.app.SubWindow', {
extend: 'Enlight.app.Window',
alias: 'widget.subwindow',
footerButton: false,
isSubWindow: true
});
Ext.define('Ext.ux.DataView.DragSelector', {
requires: ['Ext.dd.DragTracker', 'Ext.util.Region'],
init: function(dataview) {
this.dataview = dataview;
dataview.mon(dataview, {
beforecontainerclick: this.cancelClick,
scope: this,
render: {
fn: this.onRender,
scope: this,
single: true
}
});
},
reInit: function() {
this.destroy();
this.init(this.dataview);
},
destroy: function() {
if (this.proxy) {
this.proxy.destroy();
this.proxy = null;
}
},
onRender: function() {
this.tracker = Ext.create('Ext.dd.DragTracker', {
dataview: this.dataview,
el: this.dataview.el,
dragSelector: this,
onBeforeStart: this.onBeforeStart,
onStart: this.onStart,
onDrag : this.onDrag,
onEnd : this.onEnd
});
this.dragRegion = Ext.create('Ext.util.Region');
},
onBeforeStart: function(e) {
return e.target == this.dataview.getEl().dom;
},
onStart: function(e) {
var dragSelector = this.dragSelector,
dataview = this.dataview;
this.dragging = true;
dragSelector.fillRegions();
dragSelector.getProxy().show();
dataview.getSelectionModel().deselectAll();
},
cancelClick: function() {
return !this.tracker.dragging;
},
onDrag: function(e) {
var dragSelector = this.dragSelector,
selModel = dragSelector.dataview.getSelectionModel(),
dragRegion = dragSelector.dragRegion,
bodyRegion = dragSelector.bodyRegion,
proxy = dragSelector.getProxy(),
regions = dragSelector.regions,
length = regions.length,
startXY = this.startXY,
currentXY = this.getXY(),
minX = Math.min(startXY[0], currentXY[0]),
minY = Math.min(startXY[1], currentXY[1]),
width = Math.abs(startXY[0] - currentXY[0]),
height = Math.abs(startXY[1] - currentXY[1]),
region, selected, i;
Ext.apply(dragRegion, {
top: minY,
left: minX,
right: minX + width,
bottom: minY + height
});
dragRegion.constrainTo(bodyRegion);
proxy.setRegion(dragRegion);
for (i = 0; i < length; i++) {
region = regions[i];
selected = dragRegion.intersect(region);
if (selected) {
selModel.select(i, true);
} else {
selModel.deselect(i);
}
}
},
onEnd: Ext.Function.createDelayed(function(e) {
var dataview = this.dataview,
selModel = dataview.getSelectionModel(),
dragSelector = this.dragSelector;
this.dragging = false;
dragSelector.getProxy().hide();
}, 1),
getProxy: function() {
if (!this.proxy) {
this.proxy = this.dataview.getEl().createChild({
tag: 'div',
cls: 'x-view-selector'
});
}
return this.proxy;
},
fillRegions: function() {
var dataview = this.dataview,
regions = this.regions = [];
dataview.all.each(function(node) {
regions.push(node.getRegion());
});
this.bodyRegion = dataview.getEl().getRegion();
}
});
Ext.define('Ext.ux.DataView.LabelEditor', {
extend: 'Ext.Editor',
alignment: 'tl-tl',
completeOnEnter: true,
cancelOnEsc: true,
shim: false,
autoSize: {
width: 'boundEl',
height: 'field'
},
labelSelector: 'x-editable',
requires: [
'Ext.form.field.Text'
],
constructor: function(config) {
config.field = config.field || Ext.create('Ext.form.field.Text', {
allowBlank: false,
selectOnFocus:true
});
this.callParent([config]);
},
init: function(view) {
this.view = view;
this.mon(view, 'render', this.bindEvents, this);
this.on('complete', this.onSave, this);
},
bindEvents: function() {
this.mon(this.view.getEl(), {
click: {
fn: this.onClick,
scope: this
}
});
},
onClick: function(e, target) {
var me = this,
item, record;
if (Ext.fly(target).hasCls(me.labelSelector) && !me.editing && !e.ctrlKey && !e.shiftKey) {
e.stopEvent();
item = me.view.findItemByChild(target);
record = me.view.store.getAt(me.view.indexOf(item));
me.startEdit(target, record.data[me.dataIndex]);
me.activeRecord = record;
} else if (me.editing) {
me.field.blur();
e.preventDefault();
}
},
onSave: function(ed, value) {
this.activeRecord.set(this.dataIndex, value);
}
});
Ext.define('Ext.ux.form.field.BoxSelect', {
extend:'Ext.form.field.ComboBox',
alias: ['widget.comboboxselect', 'widget.boxselect'],
requires: ['Ext.selection.Model', 'Ext.data.Store'],
multiSelect: true,
forceSelection: true,
selectOnFocus: true,
triggerOnClick: true,
createNewOnEnter: false,
createNewOnBlur: false,
encodeSubmitValue: false,
stacked: false,
pinList: true,
grow: true,
growMin: false,
growMax: false,
componentLayout: 'boxselectfield',
initComponent: function() {
var me = this,
typeAhead = me.typeAhead;
if (typeAhead && !me.editable) {
Ext.Error.raise('If typeAhead is enabled the combo must be editable: true -- please change one of those settings.');
}
Ext.apply(me, {
typeAhead: false
});
me.callParent(arguments);
me.typeAhead = typeAhead;
me.selectionModel = new Ext.selection.Model({
store: me.valueStore,
mode: 'MULTI',
onSelectChange: function(record, isSelected, suppressEvent, commitFn) {
commitFn();
}
});
if (!Ext.isEmpty(me.delimiter) && me.multiSelect) {
me.delimiterEndingRegexp = new RegExp(String(me.delimiter).replace(/[$%()*+.?\[\\\]{|}]/g, "\\$&") + "$");
}
},
initEvents: function() {
var me = this;
me.callParent(arguments);
if (!me.enableKeyEvents) {
me.mon(me.inputEl, 'keydown', me.onKeyDown, me);
}
me.mon(me.itemList, 'click', me.onItemListClick, me);
me.mon(me.selectionModel, 'selectionchange', me.applyMultiselectItemMarkup, me);
},
bindStore: function(store, initial) {
var me = this;
if (me.oldStore) {
me.mun(me.store, 'beforeload', me.onBeforeLoad, me);
if (me.valueStore) {
me.mun(me.valueStore, 'datachanged', me.applyMultiselectItemMarkup, me);
me.valueStore = null;
}
me.oldStore = null;
}
me.oldStore = true;
me.callParent(arguments);
if (me.store) {
if(me.valueStore) {
me.valueStore = Ext.StoreManager.get(me.valueStore);
} else {
me.valueStore = new Ext.data.Store({
model: me.store.model,
proxy: {
type: 'memory'
}
});
}
me.mon(me.valueStore, 'datachanged', me.applyMultiselectItemMarkup, me);
me.mon(me.store, 'beforeload', me.onBeforeLoad, me);
}
},
createPicker: function() {
var me = this,
picker = me.callParent(arguments);
me.mon(picker, {
'beforerefresh': me.onBeforeListRefresh,
'show': function(pick) {
var listEl = picker.listEl,
ch = listEl.getHeight();
if (ch > picker.maxHeight) {
listEl.setHeight(picker.maxHeight);
}
},
scope: me
});
return picker;
},
onDestroy: function() {
var me = this;
Ext.destroyMembers(me, 'selectionModel', 'valueStore');
me.callParent(arguments);
},
afterRender: function() {
var me = this;
if (Ext.supports.Placeholder && me.inputEl && me.emptyText) {
delete me.inputEl.dom.placeholder;
}
if (me.stacked === true) {
me.itemList.addCls('x-boxselect-stacked');
}
if (me.grow) {
if (Ext.isNumber(me.growMin) && (me.growMin > 0)) {
me.itemList.applyStyles('min-height:'+me.growMin+'px');
}
if (Ext.isNumber(me.growMax) && (me.growMax > 0)) {
me.itemList.applyStyles('max-height:'+me.growMax+'px');
}
}
me.applyMultiselectItemMarkup();
me.callParent(arguments);
},
findRecord: function(field, value) {
var ds = this.store,
rec = false,
idx;
if (ds.snapshot) {
idx = ds.snapshot.findIndexBy(function(rec) {
return rec.get(field) === value;
});
rec = (idx !== -1) ? ds.snapshot.getAt(idx) : false;
} else {
idx = ds.findExact(field, value);
rec = (idx !== -1) ? ds.getAt(idx) : false;
}
return rec;
},
onBeforeLoad: function() {
this.ignoreSelection++;
},
onLoad: function() {
var me = this,
valueField = me.valueField,
valueStore = me.valueStore,
changed = false;
if (valueStore) {
if (!Ext.isEmpty(me.value) && (valueStore.getCount() == 0)) {
me.setValue(me.value, false, true);
}
valueStore.suspendEvents();
valueStore.each(function(rec) {
var r = me.findRecord(valueField, rec.get(valueField)),
i = r ? valueStore.indexOf(rec) : -1;
if (i >= 0) {
valueStore.removeAt(i);
valueStore.insert(i, r);
changed = true;
}
});
valueStore.resumeEvents();
if (changed) {
valueStore.fireEvent('datachanged', valueStore);
}
}
me.callParent(arguments);
me.ignoreSelection = Ext.Number.constrain(me.ignoreSelection - 1, 0);
me.alignPicker();
},
isFilteredRecord: function(record) {
var me = this,
store = me.store,
valueField = me.valueField,
storeRecord,
filtered = false;
storeRecord = store.findExact(valueField, record.get(valueField));
filtered = ((storeRecord === -1) && (!store.snapshot || (me.findRecord(valueField, record.get(valueField)) !== false)));
filtered = filtered || (!filtered && (storeRecord === -1) && (me.forceSelection !== true) &&
(me.valueStore.findExact(valueField, record.get(valueField)) >= 0));
return filtered;
},
doRawQuery: function() {
var me = this,
rawValue = me.inputEl.dom.value;
if (me.multiSelect) {
rawValue = rawValue.split(me.delimiter).pop();
}
this.doQuery(rawValue, false, true);
},
onBeforeListRefresh: function() {
this.ignoreSelection++;
},
onListRefresh: function() {
this.callParent(arguments);
this.ignoreSelection = Ext.Number.constrain(this.ignoreSelection - 1, 0);
},
onListSelectionChange: function(list, selectedRecords) {
var me = this,
valueStore = me.valueStore,
mergedRecords = [],
i;
if ((me.ignoreSelection <= 0) && me.isExpanded) {
valueStore.each(function(rec) {
if (Ext.Array.contains(selectedRecords, rec) || me.isFilteredRecord(rec)) {
mergedRecords.push(rec);
}
});
mergedRecords = Ext.Array.merge(mergedRecords, selectedRecords);
i = Ext.Array.intersect(mergedRecords, valueStore.getRange()).length;
if ((i != mergedRecords.length) || (i != me.valueStore.getCount())) {
me.setValue(mergedRecords, false);
if (!me.multiSelect || !me.pinList) {
Ext.defer(me.collapse, 1, me);
}
if (valueStore.getCount() > 0) {
me.fireEvent('select', me, valueStore.getRange());
}
}
me.inputEl.focus();
if (!me.pinList) {
me.inputEl.dom.value = '';
}
if (me.selectOnFocus) {
me.inputEl.dom.select();
}
}
},
syncSelection: function() {
var me = this,
picker = me.picker,
valueField = me.valueField,
pickStore, selection, selModel;
if (picker) {
pickStore = picker.store;
selection = [];
if (me.valueStore) {
me.valueStore.each(function(rec) {
var i = pickStore.findExact(valueField, rec.get(valueField));
if (i >= 0) {
selection.push(pickStore.getAt(i));
}
});
}
me.ignoreSelection++;
selModel = picker.getSelectionModel();
selModel.deselectAll();
if (selection.length > 0) {
selModel.select(selection);
}
me.ignoreSelection = Ext.Number.constrain(me.ignoreSelection - 1, 0);
}
},
alignPicker: function() {
var me = this,
picker, isAbove,
aboveSfx = '-above';
if(me.itemList) {
var itemBox = me.itemList.getBox(false, true);
}
if (this.isExpanded) {
picker = me.getPicker();
var pickerScrollPos = picker.getTargetEl().dom.scrollTop;
if (me.matchFieldWidth) {
picker.setSize(itemBox.width, picker.store && picker.store.getCount() ? null : 0);
}
if (picker.isFloating()) {
picker.alignTo(me.itemList, me.pickerAlign, me.pickerOffset);
isAbove = picker.el.getY() < me.inputEl.getY();
me.bodyEl[isAbove ? 'addCls' : 'removeCls'](me.openCls + aboveSfx);
picker.el[isAbove ? 'addCls' : 'removeCls'](picker.baseCls + aboveSfx);
}
}
},
getCursorPosition: function() {
var cursorPos;
if (Ext.isIE) {
cursorPos = document.selection.createRange();
cursorPos.collapse(true);
cursorPos.moveStart("character", -this.inputEl.dom.value.length);
cursorPos = cursorPos.text.length;
} else {
cursorPos = this.inputEl.dom.selectionStart;
}
return cursorPos;
},
hasSelectedText: function() {
var sel, range;
if (Ext.isIE) {
sel = document.selection;
range = sel.createRange();
return (range.parentElement() == this.inputEl.dom);
} else {
return this.inputEl.dom.selectionStart != this.inputEl.dom.selectionEnd;
}
},
onKeyDown: function(e, t) {
var me = this,
key = e.getKey(),
rawValue = me.inputEl.dom.value,
valueStore = me.valueStore,
selModel = me.selectionModel,
stopEvent = false,
rec, i;
if (me.readOnly || me.disabled || !me.editable) {
return;
}
if ((valueStore.getCount() > 0) &&
((rawValue == '') || ((me.getCursorPosition() === 0) && !me.hasSelectedText()))) {
if ((key == e.BACKSPACE) || (key == e.DELETE)) {
if (selModel.getCount() > 0) {
me.valueStore.remove(selModel.getSelection());
} else {
me.valueStore.remove(me.valueStore.last());
}
me.setValue(me.valueStore.getRange());
selModel.deselectAll();
stopEvent = true;
} else if ((key == e.RIGHT) || (key == e.LEFT)) {
if ((selModel.getCount() === 0) && (key == e.LEFT)) {
selModel.select(valueStore.last());
stopEvent = true;
} else if (selModel.getCount() > 0) {
rec = selModel.getLastFocused() || selModel.getLastSelected();
if (rec) {
i = valueStore.indexOf(rec);
if (key == e.RIGHT) {
if (i < (valueStore.getCount() - 1)) {
selModel.select(i + 1, e.shiftKey);
stopEvent = true;
} else if (!e.shiftKey) {
selModel.deselect(rec);
stopEvent = true;
}
} else if ((key == e.LEFT) && (i > 0)) {
selModel.select(i - 1, e.shiftKey);
stopEvent = true;
}
}
}
} else if (key == e.A && e.ctrlKey) {
selModel.selectAll();
stopEvent = e.A;
}
me.inputEl.focus();
}
if (stopEvent) {
me.preventKeyUpEvent = stopEvent;
e.stopEvent();
return;
}
if (me.isExpanded && (key == e.ENTER) && me.picker.highlightedItem) {
me.preventKeyUpEvent = true;
}
if (me.enableKeyEvents) {
me.callParent(arguments);
}
if (!e.isSpecialKey() && !e.hasModifier()) {
me.selectionModel.deselectAll();
me.inputEl.focus();
}
},
onKeyUp: function(e, t) {
var me = this,
rawValue = me.inputEl.dom.value,
rec;
if (me.preventKeyUpEvent) {
e.stopEvent();
if ((me.preventKeyUpEvent === true) || (e.getKey() === me.preventKeyUpEvent)) {
delete me.preventKeyUpEvent;
}
return;
}
if (me.multiSelect && (me.delimiterEndingRegexp && me.delimiterEndingRegexp.test(rawValue)) ||
((me.createNewOnEnter === true) && e.getKey() == e.ENTER)) {
rawValue = rawValue.replace(me.delimiterEndingRegexp, '');
if (!Ext.isEmpty(rawValue)) {
rec = me.valueStore.findExact(me.valueField, rawValue);
if (rec >= 0) {
rec = me.valueStore.getAt(rec);
} else {
rec = me.store.findExact(me.valueField, rawValue);
if (rec >= 0) {
rec = me.store.getAt(rec);
} else {
rec = false;
}
}
if (!rec && !me.forceSelection) {
rec = {};
rec[me.valueField] = rawValue;
rec[me.displayField] = rawValue;
rec = new me.valueStore.model(rec);
}
if (rec) {
me.collapse();
me.setValue(me.valueStore.getRange().concat(rec));
me.inputEl.dom.value = '';
me.inputEl.focus();
}
}
}
me.callParent([e,t]);
Ext.Function.defer(me.alignPicker, 10, me);
},
onTypeAhead: function() {
var me = this,
displayField = me.displayField,
inputElDom = me.inputEl.dom,
record = me.store.findRecord(displayField, inputElDom.value),
boundList = me.getPicker(),
newValue, len, selStart;
if (record) {
newValue = record.get(displayField);
len = newValue.length;
selStart = inputElDom.value.length;
boundList.highlightItem(boundList.getNode(record));
if (selStart !== 0 && selStart !== len) {
inputElDom.value = newValue;
me.selectText(selStart, newValue.length);
}
}
},
onItemListClick: function(evt, el, o) {
var me = this,
itemEl = evt.getTarget('.x-boxselect-item'),
closeEl = itemEl ? evt.getTarget('.x-boxselect-item-close') : false;
if (me.readOnly || me.disabled) {
return;
}
evt.stopPropagation();
if (itemEl) {
if (closeEl) {
me.removeByListItemNode(itemEl);
} else {
me.toggleSelectionByListItemNode(itemEl, evt.shiftKey);
}
me.inputEl.focus();
} else if (me.triggerOnClick) {
me.onTriggerClick();
}
},
getMultiSelectItemMarkup: function() {
var me = this;
if (!me.multiSelectItemTpl) {
if (!me.labelTpl) {
me.labelTpl = Ext.create('Ext.XTemplate',
'{[values.' + me.displayField + ']}'
);
} else if (Ext.isString(me.labelTpl)) {
me.labelTpl = Ext.create('Ext.XTemplate', me.labelTpl);
}
me.multiSelectItemTpl = [
'',
'',
' selected',
'',
'" qtip="{[typeof values === "string" ? values : values.' + me.displayField + ']}">' ,
'{[typeof values === "string" ? values : this.getItemLabel(values)]}
',
'' ,
'' ,
'',
{
compile: true,
disableFormats: true,
isSelected: function(value) {
var i = me.valueStore.findExact(me.valueField, value);
if (i >= 0) {
return me.selectionModel.isSelected(me.valueStore.getAt(i));
}
},
getItemLabel: function(values) {
return me.getTpl('labelTpl').apply(values);
}
}
];
}
return this.getTpl('multiSelectItemTpl').apply(Ext.Array.pluck(this.valueStore.getRange(), 'data'));
},
applyMultiselectItemMarkup: function() {
var me = this,
itemList = me.itemList,
item;
if (itemList) {
while ((item = me.inputElCt.prev()) != null) {
item.remove();
}
me.inputElCt.insertHtml('beforeBegin', me.getMultiSelectItemMarkup());
}
},
getRecordByListItemNode: function(itemEl) {
var me = this,
itemIdx = 0,
searchEl = me.itemList.dom.firstChild;
while (searchEl && searchEl.nextSibling) {
if (searchEl == itemEl) {
break;
}
itemIdx++;
searchEl = searchEl.nextSibling;
}
itemIdx = (searchEl == itemEl) ? itemIdx : false;
if (itemIdx === false) {
return false;
}
return me.valueStore.getAt(itemIdx);
},
toggleSelectionByListItemNode: function(itemEl, keepExisting) {
var me = this,
rec = me.getRecordByListItemNode(itemEl);
if (rec) {
if (me.selectionModel.isSelected(rec)) {
me.selectionModel.deselect(rec);
} else {
me.selectionModel.select(rec, keepExisting);
}
}
},
removeByListItemNode: function(itemEl) {
var me = this,
rec = me.getRecordByListItemNode(itemEl);
if (rec) {
me.valueStore.remove(rec);
me.setValue(me.valueStore.getRange());
}
},
getRawValue: function() {
var me = this,
inputEl = me.inputEl,
result;
me.inputEl = false;
result = me.callParent(arguments);
me.inputEl = inputEl;
return result;
},
setRawValue: function(value) {
var me = this,
inputEl = me.inputEl,
result;
me.inputEl = false;
result = me.callParent([value]);
me.inputEl = inputEl;
return result;
},
addValue: function(valueMixed) {
var me = this;
if (valueMixed) {
me.setValue(Ext.Array.merge(me.value, Ext.Array.from(valueMixed)));
}
},
removeValue: function(valueMixed) {
var me = this;
if (valueMixed) {
me.setValue(Ext.Array.difference(me.value, Ext.Array.from(valueMixed)));
}
},
setValue: function(value, doSelect, skipLoad) {
var me = this,
valueStore = me.valueStore,
valueField = me.valueField,
record, len, i, valueRecord, h,
unknownValues = [];
if (Ext.isEmpty(value)) {
value = null;
}
if (Ext.isString(value) && me.multiSelect) {
value = value.split(me.delimiter);
}
value = Ext.Array.from(value);
for (i = 0, len = value.length; i < len; i++) {
record = value[i];
if (!record || !record.isModel) {
valueRecord = valueStore.findExact(valueField, record);
if (valueRecord >= 0) {
value[i] = valueStore.getAt(valueRecord);
} else {
valueRecord = me.findRecord(valueField, record);
if (!valueRecord) {
if (me.forceSelection) {
unknownValues.push(record);
} else {
valueRecord = {};
valueRecord[me.valueField] = record;
valueRecord[me.displayField] = record;
valueRecord = new me.valueStore.model(valueRecord);
}
}
if (valueRecord) {
value[i] = valueRecord;
}
}
}
}
if ((skipLoad !== true) && (unknownValues.length > 0) && (me.queryMode === 'remote')) {
var params = {};
params[me.valueField] = unknownValues.join(me.delimiter);
me.store.load({
params: params,
callback: function() {
if(me.itemList) {
me.itemList.unmask();
}
me.setValue(value, doSelect, true);
me.autoSize();
}
});
return false;
}
if (!me.multiSelect && (value.length > 0)) {
value = value[value.length - 1];
}
me.callParent([value, doSelect]);
},
getValueRecords: function() {
return this.valueStore.getRange();
},
getSubmitData: function() {
var me = this,
val = me.callParent(arguments);
if (me.multiSelect && me.encodeSubmitValue && val && val[me.name]) {
val[me.name] = Ext.encode(val[me.name]);
}
return val;
},
beforeBlur: function() {
var me = this;
me.doQueryTask.cancel();
me.assertValue();
me.collapse();
},
mimicBlur: function() {
var me = this;
if (me.selectOnTab && me.picker && me.picker.highlightedItem) {
me.inputEl.dom.value = '';
}
me.callParent(arguments);
},
assertValue: function() {
var me = this,
rawValue = me.inputEl.dom.value,
rec = !Ext.isEmpty(rawValue) ? me.findRecordByDisplay(rawValue) : false,
value = false;
if (!rec && !me.forceSelection && me.createNewOnBlur && !Ext.isEmpty(rawValue)) {
value = rawValue;
} else if (rec) {
value = rec;
}
if (value) {
me.addValue(value);
}
me.inputEl.dom.value = '';
me.collapse();
},
checkChange: function() {
if (!this.suspendCheckChange && !this.isDestroyed) {
var me = this,
valueStore = me.valueStore,
lastValue = me.lastValue,
valueField = me.valueField,
newValue = Ext.Array.map(Ext.Array.from(me.value), function(val) {
if (val.isModel) {
return val.get(valueField);
}
return val;
}, this).join(this.delimiter);
if (!me.isEqual(newValue, lastValue)) {
valueStore.suspendEvents();
valueStore.removeAll();
if (Ext.isArray(me.valueModels)) {
valueStore.add(me.valueModels);
}
valueStore.resumeEvents();
valueStore.fireEvent('datachanged', valueStore);
me.lastValue = newValue;
me.fireEvent('change', me, newValue, lastValue);
me.onChange(newValue, lastValue)
}
}
},
applyEmptyText : function() {
var me = this,
emptyText = me.emptyText,
inputEl, isEmpty;
if (me.rendered && emptyText) {
isEmpty = Ext.isEmpty(me.value) && !me.hasFocus;
inputEl = me.inputEl;
if (isEmpty) {
inputEl.dom.value = emptyText;
inputEl.addCls(me.emptyCls);
} else {
if (inputEl.dom.value === emptyText) {
inputEl.dom.value = '';
}
inputEl.removeCls(me.emptyCls);
}
}
},
preFocus : function(){
var me = this,
inputEl = me.inputEl,
emptyText = me.emptyText,
isEmpty;
if (emptyText && inputEl.dom.value === emptyText) {
inputEl.dom.value = '';
isEmpty = true;
inputEl.removeCls(me.emptyCls);
}
if (me.selectOnFocus || isEmpty) {
inputEl.dom.select();
}
},
onFocus: function() {
var me = this,
focusCls = me.focusCls,
itemList = me.itemList;
if (focusCls && itemList) {
itemList.addCls(focusCls);
}
me.callParent(arguments);
},
onBlur: function() {
var me = this,
focusCls = me.focusCls,
itemList = me.itemList;
if (focusCls && itemList) {
itemList.removeCls(focusCls);
}
me.callParent(arguments);
},
renderActiveError: function() {
var me = this,
invalidCls = me.invalidCls,
itemList = me.itemList,
hasError = me.hasActiveError();
if (invalidCls && itemList) {
itemList[hasError ? 'addCls' : 'removeCls'](me.invalidCls + '-field');
}
me.callParent(arguments);
},
autoSize: function() {
var me = this,
height;
if (me.rendered) {
me.doComponentLayout();
if (me.grow) {
height = me.getHeight();
if (height !== me.lastInputHeight) {
me.alignPicker();
me.fireEvent('autosize', height);
me.lastInputHeight = height;
}
}
}
return me;
}
}, function() {
var useNewSelectors = !Ext.getVersion('extjs').isLessThan('4.0.5'),
overrides = {};
if (useNewSelectors) {
Ext.apply(overrides, {
fieldSubTpl: [
'',
{
compiled: true,
disableFormats: true
}
],
childEls: ['itemList', 'inputEl', 'inputElCt']
});
} else {
Ext.apply(overrides, {
fieldSubTpl: [
'',
{
compiled: true,
disableFormats: true
}
],
renderSelectors: {
itemList: 'ul.x-boxselect-list',
inputEl: 'input.x-boxselect-input-field',
inputElCt: 'li.x-boxselect-input'
}
});
}
Ext.override(this, overrides);
});
Ext.define('Ext.ux.layout.component.field.BoxSelectField', {
alias: ['layout.boxselectfield'],
extend: 'Ext.layout.component.field.Field',
type: 'boxselectfield',
beforeLayout: function(width, height) {
var me = this,
owner = me.owner,
lastValue = this.lastValue,
value = Ext.encode(owner.value);
this.lastValue = value;
return me.callParent(arguments) || (owner.grow && value !== lastValue);
},
sizeBodyContents: function(width, height) {
var me = this,
owner = me.owner,
triggerWrap = owner.triggerWrap,
triggerWidth = owner.getTriggerWidth(),
itemList, inputEl, inputElCt, lastEntry,
listBox, listWidth, inputWidth;
if (owner.hideTrigger || owner.readOnly || triggerWidth > 0) {
itemList = owner.itemList;
me.setElementSize(itemList, Ext.isNumber(width) ? width - triggerWidth : width, height);
triggerWrap.setWidth(triggerWidth);
inputEl = owner.inputEl;
inputElCt = owner.inputElCt;
listBox = itemList.getBox(true, true);
listWidth = listBox.width;
if ((owner.grow && owner.growMax && (itemList.dom.scrollHeight > (owner.growMax - 25))) ||
(owner.isFixedHeight() && (itemList.dom.scrollHeight > itemList.dom.clientHeight))) {
listWidth = listWidth - Ext.getScrollbarSize().width;
}
inputWidth = listWidth - 10;
lastEntry = inputElCt.dom.previousSibling;
if (lastEntry) {
inputWidth = inputWidth - (lastEntry.offsetLeft + Ext.fly(lastEntry).getWidth() + Ext.fly(lastEntry).getPadding('lr'));
}
if (inputWidth < 35) {
inputWidth = listWidth - 10;
}
if (inputWidth >= 0) {
me.setElementSize(inputEl, inputWidth);
if (owner.hasFocus) {
inputElCt.scrollIntoView(itemList);
}
}
}
}
});
Ext.define('Ext.ux.RowExpander', {
extend: 'Ext.AbstractPlugin',
requires: [
'Ext.grid.feature.RowBody',
'Ext.grid.feature.RowWrap'
],
alias: 'plugin.rowexpander',
rowBodyTpl: null,
expandOnEnter: true,
expandOnDblClick: true,
selectRowOnExpand: false,
rowBodyTrSelector: '.x-grid-rowbody-tr',
rowBodyHiddenCls: 'x-grid-row-body-hidden',
rowCollapsedCls: 'x-grid-row-collapsed',
rowsExpanded: new Ext.util.MixedCollection(),
renderer: function(value, metadata, record, rowIdx, colIdx) {
if (colIdx === 0) {
metadata.tdCls = 'x-grid-td-expander';
}
return '
';
},
constructor: function() {
this.callParent(arguments);
var grid = this.getCmp();
this.recordsExpanded = {};
if (!this.rowBodyTpl) {
Ext.Error.raise("The 'rowBodyTpl' config is required and is not defined.");
}
var rowBodyTpl = Ext.create('Ext.XTemplate', this.rowBodyTpl),
features = [{
ftype: 'rowbody',
columnId: this.getHeaderId(),
recordsExpanded: this.recordsExpanded,
rowBodyHiddenCls: this.rowBodyHiddenCls,
rowCollapsedCls: this.rowCollapsedCls,
getAdditionalData: this.getRowBodyFeatureData,
getRowBodyContents: function(data) {
return rowBodyTpl.applyTemplate(data);
}
},{
ftype: 'rowwrap'
}];
if (grid.features) {
grid.features = features.concat(grid.features);
} else {
grid.features = features;
}
},
init: function(grid) {
this.callParent(arguments);
grid.headerCt.insert(0, this.getHeaderConfig());
grid.on('render', this.bindView, this, { single: true });
},
getHeaderId: function() {
if (!this.headerId) {
this.headerId = Ext.id();
}
return this.headerId;
},
getRowBodyFeatureData: function(data, idx, record, orig) {
var o = Ext.grid.feature.RowBody.prototype.getAdditionalData.apply(this, arguments),
id = this.columnId;
o.rowBodyColspan = o.rowBodyColspan - 1;
o.rowBody = this.getRowBodyContents(data);
o.rowCls = this.recordsExpanded[record.internalId] ? '' : this.rowCollapsedCls;
o.rowBodyCls = this.recordsExpanded[record.internalId] ? '' : this.rowBodyHiddenCls;
o[id + '-tdAttr'] = ' valign="top" rowspan="2" ';
if (orig[id+'-tdAttr']) {
o[id+'-tdAttr'] += orig[id+'-tdAttr'];
}
return o;
},
bindView: function() {
var view = this.getCmp().getView(),
viewEl;
if (!view.rendered) {
view.on('render', this.bindView, this, { single: true });
} else {
viewEl = view.getEl();
if (this.expandOnEnter) {
this.keyNav = Ext.create('Ext.KeyNav', viewEl, {
'enter' : this.onEnter,
scope: this
});
}
if (this.expandOnDblClick) {
view.on('itemdblclick', this.onDblClick, this);
}
this.view = view;
}
},
onEnter: function(e) {
var view = this.view,
ds = view.store,
sm = view.getSelectionModel(),
sels = sm.getSelection(),
ln = sels.length,
i = 0,
rowIdx;
for (; i < ln; i++) {
rowIdx = ds.indexOf(sels[i]);
this.toggleRow(rowIdx);
}
},
toggleRow: function(rowIdx) {
var rowNode = this.view.getNode(rowIdx),
row = Ext.get(rowNode),
nextBd = Ext.get(row).down(this.rowBodyTrSelector),
record = this.view.getRecord(rowNode),
grid = this.getCmp();
if (row.hasCls(this.rowCollapsedCls)) {
row.removeCls(this.rowCollapsedCls);
nextBd.removeCls(this.rowBodyHiddenCls);
this.rowsExpanded.add(rowIdx.id, rowIdx);
this.recordsExpanded[record.internalId] = true;
this.view.fireEvent('expandbody', rowNode, record, nextBd.dom);
} else {
row.addCls(this.rowCollapsedCls);
nextBd.addCls(this.rowBodyHiddenCls);
this.rowsExpanded.removeAtKey(rowIdx.id);
this.recordsExpanded[record.internalId] = false;
this.view.fireEvent('collapsebody', rowNode, record, nextBd.dom);
}
},
collapseAll: function() {
var me = this;
if (me.rowsExpanded.length === 0) {
return;
}
me.rowsExpanded.each(function(item) {
var rowNode = me.view.getNode(item),
row = Ext.get(rowNode),
nextBd = Ext.get(row).down(me.rowBodyTrSelector),
record = me.view.getRecord(rowNode);
row.addCls(me.rowCollapsedCls);
nextBd.addCls(me.rowBodyHiddenCls);
if (record !== Ext.undefined) {
me.recordsExpanded[record.internalId] = false;
me.view.fireEvent('collapsebody', rowNode, record, nextBd.dom);
}
});
me.rowsExpanded.clear();
},
onDblClick: function(view, cell, rowIdx, cellIndex, e) {
this.toggleRow(rowIdx);
},
getHeaderConfig: function() {
var me = this,
toggleRow = Ext.Function.bind(me.toggleRow, me),
selectRowOnExpand = me.selectRowOnExpand;
return {
id: this.getHeaderId(),
width: 24,
sortable: false,
resizable: false,
draggable: false,
hideable: false,
menuDisabled: true,
cls: Ext.baseCSSPrefix + 'grid-header-special',
renderer: function(value, metadata) {
metadata.tdCls = Ext.baseCSSPrefix + 'grid-cell-special';
return '
';
},
processEvent: function(type, view, cell, recordIndex, cellIndex, e) {
if (type == "mousedown" && e.getTarget('.x-grid-row-expander')) {
var row = e.getTarget('.x-grid-row');
toggleRow(row);
return selectRowOnExpand;
}
}
};
}
});
Ext.define('Ext.ux.form.MultiSelect', {
extend: 'Ext.form.FieldContainer',
mixins: {
bindable: 'Ext.util.Bindable',
field: 'Ext.form.field.Field'
},
alternateClassName: 'Ext.ux.Multiselect',
alias: ['widget.multiselectfield', 'widget.multiselect'],
requires: ['Ext.panel.Panel', 'Ext.view.BoundList'],
uses: ['Ext.view.DragZone', 'Ext.view.DropZone'],
ddReorder: false,
appendOnly: false,
displayField: 'text',
allowBlank: true,
minSelections: 0,
layout: 'fit',
maxSelections: Number.MAX_VALUE,
blankText: 'This field is required',
minSelectionsText: 'Minimum {0} item(s) required',
maxSelectionsText: 'Minimum {0} item(s) required',
delimiter: ',',
ignoreSelectChange: 0,
initComponent: function(){
var me = this;
me.bindStore(me.store, true);
if (me.store.autoCreated) {
me.valueField = me.displayField = 'field1';
if (!me.store.expanded) {
me.displayField = 'field2';
}
}
if (!Ext.isDefined(me.valueField)) {
me.valueField = me.displayField;
}
Ext.apply(me, me.setupItems());
me.callParent();
me.initField();
me.addEvents('drop');
},
setupItems: function() {
var me = this;
me.boundList = Ext.create('Ext.view.BoundList', {
deferInitialRefresh: false,
multiSelect: true,
store: me.store,
height: me.listHeight,
overflowY:'auto',
displayField: me.displayField,
disabled: me.disabled,
border: 0
});
me.boundList.getSelectionModel().on('selectionchange', me.onSelectChange, me);
return {
tbar: me.tbar,
items: [{
xtype: 'panel',
dockedItems: me.dockedItems,
title: me.listTitle,
items: me.boundList
}]
};
},
onSelectChange: function(selModel, selections){
if (!this.ignoreSelectChange) {
this.setValue(selections);
}
},
getSelected: function(){
return this.boundList.getSelectionModel().getSelection();
},
isEqual: function(v1, v2) {
var fromArray = Ext.Array.from,
i = 0,
len;
v1 = fromArray(v1);
v2 = fromArray(v2);
len = v1.length;
if (len !== v2.length) {
return false;
}
for(; i < len; i++) {
if (v2[i] !== v1[i]) {
return false;
}
}
return true;
},
afterRender: function(){
var me = this;
me.callParent();
if (me.selectOnRender) {
++me.ignoreSelectChange;
me.boundList.getSelectionModel().select(me.getRecordsForValue(me.value));
--me.ignoreSelectChange;
delete me.toSelect;
}
if (me.ddReorder && !me.dragGroup && !me.dropGroup){
me.dragGroup = me.dropGroup = 'MultiselectDD-' + Ext.id();
}
if (me.draggable || me.dragGroup){
me.dragZone = Ext.create('Ext.view.DragZone', {
view: me.boundList,
ddGroup: me.dragGroup,
dragText: '{0} Item{1}'
});
}
if (me.droppable || me.dropGroup){
me.dropZone = Ext.create('Ext.view.DropZone', {
view: me.boundList,
ddGroup: me.dropGroup,
handleNodeDrop: function(data, dropRecord, position) {
var view = this.view,
store = view.getStore(),
records = data.records,
index;
data.view.store.remove(records);
index = store.indexOf(dropRecord);
if (position === 'after') {
index++;
}
store.insert(index, records);
view.getSelectionModel().select(records);
me.fireEvent('drop', me, records);
}
});
}
},
isValid : function() {
var me = this,
disabled = me.disabled,
validate = me.forceValidation || !disabled;
return validate ? me.validateValue(me.value) : disabled;
},
validateValue: function(value) {
var me = this,
errors = me.getErrors(value),
isValid = Ext.isEmpty(errors);
if (!me.preventMark) {
if (isValid) {
me.clearInvalid();
} else {
me.markInvalid(errors);
}
}
return isValid;
},
markInvalid : function(errors) {
var me = this,
oldMsg = me.getActiveError();
me.setActiveErrors(Ext.Array.from(errors));
if (oldMsg !== me.getActiveError()) {
me.updateLayout();
}
},
clearInvalid : function() {
var me = this,
hadError = me.hasActiveError();
me.unsetActiveError();
if (hadError) {
me.updateLayout();
}
},
getSubmitData: function() {
var me = this,
data = null,
val;
if (!me.disabled && me.submitValue && !me.isFileUpload()) {
val = me.getSubmitValue();
if (val !== null) {
data = {};
data[me.getName()] = val;
}
}
return data;
},
getSubmitValue: function() {
var me = this,
delimiter = me.delimiter,
val = me.getValue();
return Ext.isString(delimiter) ? val.join(delimiter) : val;
},
getValue: function(){
return this.value;
},
getRecordsForValue: function(value){
var me = this,
records = [],
all = me.store.getRange(),
valueField = me.valueField,
i = 0,
allLen = all.length,
rec,
j,
valueLen;
for (valueLen = value.length; i < valueLen; ++i) {
for (j = 0; j < allLen; ++j) {
rec = all[j];
if (rec.get(valueField) == value[i]) {
records.push(rec);
}
}
}
return records;
},
setupValue: function(value){
var delimiter = this.delimiter,
valueField = this.valueField,
i = 0,
out,
len,
item;
if (Ext.isDefined(value)) {
if (delimiter && Ext.isString(value)) {
value = value.split(delimiter);
} else if (!Ext.isArray(value)) {
value = [value];
}
for (len = value.length; i < len; ++i) {
item = value[i];
if (item && item.isModel) {
value[i] = item.get(valueField);
}
}
out = Ext.Array.unique(value);
} else {
out = [];
}
return out;
},
setValue: function(value){
var me = this,
selModel = me.boundList.getSelectionModel();
value = me.setupValue(value);
me.mixins.field.setValue.call(me, value);
if (me.rendered) {
++me.ignoreSelectChange;
selModel.deselectAll();
selModel.select(me.getRecordsForValue(value));
--me.ignoreSelectChange;
} else {
me.selectOnRender = true;
}
},
clearValue: function(){
this.setValue([]);
},
onEnable: function(){
var list = this.boundList;
this.callParent();
if (list) {
list.enable();
}
},
onDisable: function(){
var list = this.boundList;
this.callParent();
if (list) {
list.disable();
}
},
getErrors : function(value) {
var me = this,
format = Ext.String.format,
errors = [],
numSelected;
value = Ext.Array.from(value || me.getValue());
numSelected = value.length;
if (!me.allowBlank && numSelected < 1) {
errors.push(me.blankText);
}
if (numSelected < me.minSelections) {
errors.push(format(me.minSelectionsText, me.minSelections));
}
if (numSelected > me.maxSelections) {
errors.push(format(me.maxSelectionsText, me.maxSelections));
}
return errors;
},
onDestroy: function(){
var me = this;
me.bindStore(null);
Ext.destroy(me.dragZone, me.dropZone);
me.callParent();
},
onBindStore: function(store){
var boundList = this.boundList;
if (boundList) {
boundList.bindStore(store);
}
}
});
Ext.define('Ext.ux.form.ItemSelector', {
extend: 'Ext.ux.form.MultiSelect',
alias: ['widget.itemselectorfield', 'widget.itemselector'],
alternateClassName: ['Ext.ux.ItemSelector'],
requires: [
'Ext.button.Button',
'Ext.ux.form.MultiSelect'
],
hideNavIcons:false,
buttons: ['top', 'up', 'add', 'remove', 'down', 'bottom'],
buttonsText: {
top: "Move to Top",
up: "Move Up",
add: "Add to Selected",
remove: "Remove from Selected",
down: "Move Down",
bottom: "Move to Bottom"
},
initComponent: function() {
var me = this;
me.ddGroup = me.id + '-dd';
me.callParent();
me.bindStore(me.store);
},
createList: function(){
var me = this;
return Ext.create('Ext.ux.form.MultiSelect', {
submitValue: false,
flex: 1,
dragGroup: me.ddGroup,
dropGroup: me.ddGroup,
store: {
model: me.store.model,
data: []
},
displayField: me.displayField,
disabled: me.disabled,
listeners: {
boundList: {
scope: me,
itemdblclick: me.onItemDblClick,
drop: me.syncValue
}
}
});
},
setupItems: function() {
var me = this;
me.fromField = me.createList();
me.toField = me.createList();
return {
layout: {
type: 'hbox',
align: 'stretch'
},
items: [
me.fromField,
{
xtype: 'container',
margins: '0 4',
width: 22,
layout: {
type: 'vbox',
pack: 'center'
},
items: me.createButtons()
},
me.toField
]
};
},
createButtons: function(){
var me = this,
buttons = [];
if (!me.hideNavIcons) {
Ext.Array.forEach(me.buttons, function(name) {
buttons.push({
xtype: 'button',
tooltip: me.buttonsText[name],
handler: me['on' + Ext.String.capitalize(name) + 'BtnClick'],
cls: Ext.baseCSSPrefix + 'form-itemselector-btn',
iconCls: Ext.baseCSSPrefix + 'form-itemselector-' + name,
navBtn: true,
scope: me,
margin: '4 0 0 0'
});
});
}
return buttons;
},
getSelections: function(list){
var store = list.getStore(),
selections = list.getSelectionModel().getSelection();
return Ext.Array.sort(selections, function(a, b){
a = store.indexOf(a);
b = store.indexOf(b);
if (a < b) {
return -1;
} else if (a > b) {
return 1;
}
return 0;
});
},
onTopBtnClick : function() {
var list = this.toField.boundList,
store = list.getStore(),
selected = this.getSelections(list);
store.suspendEvents();
store.remove(selected, true);
store.insert(0, selected);
store.resumeEvents();
list.refresh();
this.syncValue();
list.getSelectionModel().select(selected);
},
onBottomBtnClick : function() {
var list = this.toField.boundList,
store = list.getStore(),
selected = this.getSelections(list);
store.suspendEvents();
store.remove(selected, true);
store.add(selected);
store.resumeEvents();
list.refresh();
this.syncValue();
list.getSelectionModel().select(selected);
},
onUpBtnClick : function() {
var list = this.toField.boundList,
store = list.getStore(),
selected = this.getSelections(list),
i = 0,
len = selected.length,
index = store.getCount();
for (; i < len; ++i) {
index = Math.min(index, store.indexOf(selected[i]));
}
if (index > 0) {
store.suspendEvents();
store.remove(selected, true);
store.insert(index - 1, selected);
store.resumeEvents();
list.refresh();
this.syncValue();
list.getSelectionModel().select(selected);
}
},
onDownBtnClick : function() {
var list = this.toField.boundList,
store = list.getStore(),
selected = this.getSelections(list),
i = 0,
len = selected.length,
index = 0;
for (; i < len; ++i) {
index = Math.max(index, store.indexOf(selected[i]));
}
if (index < store.getCount() - 1) {
store.suspendEvents();
store.remove(selected, true);
store.insert(index + 2 - len, selected);
store.resumeEvents();
list.refresh();
this.syncValue();
list.getSelectionModel().select(selected);
}
},
onAddBtnClick : function() {
var me = this,
fromList = me.fromField.boundList,
selected = this.getSelections(fromList);
fromList.getStore().remove(selected);
this.toField.boundList.getStore().add(selected);
this.syncValue();
},
onRemoveBtnClick : function() {
var me = this,
toList = me.toField.boundList,
selected = this.getSelections(toList);
toList.getStore().remove(selected);
this.fromField.boundList.getStore().add(selected);
this.syncValue();
},
syncValue: function() {
this.setValue(this.toField.store.getRange());
},
onItemDblClick: function(view, rec){
var me = this,
from = me.fromField.store,
to = me.toField.store,
current,
destination;
if (view === me.fromField.boundList) {
current = from;
destination = to;
} else {
current = to;
destination = from;
}
current.remove(rec);
destination.add(rec);
me.syncValue();
},
setValue: function(value){
var me = this,
fromStore = me.fromField.store,
toStore = me.toField.store,
selected;
if (!me.fromField.store.getCount()) {
me.fromField.store.on({
load: Ext.Function.bind(me.setValue, me, [value]),
single: true
});
return;
}
value = me.setupValue(value);
me.mixins.field.setValue.call(me, value);
selected = me.getRecordsForValue(value);
Ext.Array.forEach(toStore.getRange(), function(rec){
if (!Ext.Array.contains(selected, rec)) {
toStore.remove(rec);
fromStore.add(rec);
}
});
toStore.removeAll();
Ext.Array.forEach(selected, function(rec){
if (fromStore.indexOf(rec) > -1) {
fromStore.remove(rec);
}
toStore.add(rec);
});
},
onBindStore: function(store, initial) {
var me = this;
if (me.fromField) {
me.fromField.store.removeAll()
me.toField.store.removeAll();
if (store.getCount()) {
me.populateFromStore(store);
} else {
me.store.on('load', me.populateFromStore, me);
}
}
},
populateFromStore: function(store) {
this.fromField.store.add(store.getRange());
this.fromField.store.fireEvent('load', this.fromField.store);
},
onEnable: function(){
var me = this;
me.callParent();
me.fromField.enable();
me.toField.enable();
Ext.Array.forEach(me.query('[navBtn]'), function(btn){
btn.enable();
});
},
onDisable: function(){
var me = this;
me.callParent();
me.fromField.disable();
me.toField.disable();
Ext.Array.forEach(me.query('[navBtn]'), function(btn){
btn.disable();
});
},
onDestroy: function(){
this.bindStore(null);
this.callParent();
}
});
Ext.define('Shopware.model.Helper', {
getModelName: function (modelName) {
return modelName.substr(modelName.lastIndexOf(".") + 1);
},
getEventAlias: function (modelClass) {
return this.getModelName(modelClass).toLowerCase();
},
hasModelAction: function (model, action) {
return (model.proxy && model.proxy.api && model.proxy.api[action]);
},
camelCaseToWord: function (word) {
var newWord;
newWord = word.split(/(?=[A-Z])/).map(function (p) {
return p.charAt(0).toLowerCase() + p.slice(1);
}).join(' ');
return newWord.charAt(0).toUpperCase() + newWord.slice(1);
},
getHumanReadableWord: function(word) {
word = this.camelCaseToWord(word);
word = word.replace(' id', '');
return word;
},
getAssociations: function (className, conditions) {
var me = this,
associations = [],
model = Ext.create(className);
conditions = conditions || [];
if (model.associations.lenght <= 0) {
return associations;
}
Ext.each(model.associations.items, function (association) {
if (me.matchAssociationConditions(association, conditions)) {
associations.push(association);
}
});
return associations;
},
getAssociationStore: function (record, association) {
var store;
store = record[association.storeName];
if (!(store instanceof Ext.data.Store)) {
store = Ext.create('Ext.data.Store', {
model: association.associatedName
});
record[association.storeName] = store;
}
return store;
},
matchAssociationConditions: function (association, conditions) {
var associationInstance = Ext.create(association.associatedName),
match = false;
if (conditions && conditions.length <= 0) {
match = true;
}
Ext.each(conditions, function (condition) {
if (condition.associationKey && !Ext.Array.contains(condition.associationKey, association.associationKey)) {
return true;
}
if (condition.relation && condition.relation.toLowerCase() !== association.relation.toLowerCase()) {
return true;
}
if (condition.hasAssociations === true && associationInstance.associations.length <= 0) {
return true;
}
if (condition.hasAssociations === false && associationInstance.associations.length > 0) {
return true;
}
if (condition.associationTypes && associationInstance.association.length <= 0) {
return true;
}
if (condition.associationTypes) {
var typeMatch = false;
Ext.each(associationInstance.associations.items, function (item) {
Ext.each(condition.associationTypes, function (type) {
if (type.toLowerCase() === item.relation.toLowerCase()) {
typeMatch = true;
}
});
});
if (typeMatch === false) {
return true;
}
}
match = true;
return false; //cancel foreach
});
return match;
},
applyIntegerColumnConfig: function (column) {
column.xtype = 'numbercolumn';
column.renderer = this.integerColumnRenderer;
column.align = 'right';
column.editor = this.applyIntegerFieldConfig({});
return column;
},
applyStringColumnConfig: function (column) {
column.editor = this.applyStringFieldConfig({});
return column;
},
applyBooleanColumnConfig: function (column) {
column.xtype = 'booleancolumn';
column.renderer = this.booleanColumnRenderer;
column.editor = this.applyBooleanFieldConfig({});
return column;
},
applyDateColumnConfig: function (column, format) {
column.xtype = 'datecolumn';
if (format) {
column.format = format;
}
column.editor = this.applyDateFieldConfig({});
return column;
},
applyFloatColumnConfig: function (column) {
column.xtype = 'numbercolumn';
column.align = 'right';
column.editor = this.applyFloatFieldConfig({});
return column;
},
booleanColumnRenderer: function (value) {
var checked = 'sprite-ui-check-box-uncheck';
if (value === true) {
checked = 'sprite-ui-check-box';
}
return '';
},
integerColumnRenderer: function (value) {
return Ext.util.Format.number(value, '0');
},
applyIntegerFieldConfig: function (field) {
field.xtype = 'numberfield';
field.align = 'right';
return field;
},
applyStringFieldConfig: function (field) {
field.xtype = 'textfield';
return field;
},
applyBooleanFieldConfig: function (field) {
field.xtype = 'checkbox';
field.uncheckedValue = false;
field.inputValue = true;
return field;
},
applyDateFieldConfig: function (field) {
field.xtype = 'datefield';
return field;
},
applyFloatFieldConfig: function (field) {
field.xtype = 'numberfield';
field.align = 'right';
return field;
},
getComponentTypeOfAssociation: function(association) {
switch (association.relation.toLowerCase()) {
case 'onetoone':
return 'detail';
case 'onetomany':
return 'listing';
case 'manytomany':
return 'related';
case 'manytoone':
return 'field';
}
return false;
},
createAssociationSearchStore: function (model, associationKey, searchUrl) {
return Ext.create('Ext.data.Store', {
model: model,
proxy: {
type: 'ajax',
url: searchUrl,
reader: { type: 'json', root: 'data', totalProperty: 'total' },
extraParams: { association: associationKey }
}
});
},
getFieldByName: function(fields, name) {
var result = undefined;
Ext.each(fields, function(field) {
if (field.name == name) {
result = field;
return false;
}
});
return result;
},
throwException: function(message, title) {
title = title || "Shopware configuration error";
throw {
name: title,
message: message,
toString: function() { return this.name + ": " + this.message }
};
},
isLazyLoadingComponent: function(component) {
var me = this;
if (!(component.association)) {
return false;
}
if (!(component.association.lazyLoading)) {
return false;
}
if (typeof component.getStore !== 'function') {
return false;
}
if (component.getStore().getCount() > 0) {
return false;
}
return (component.getStore() instanceof Shopware.store.Association)
|| (me.hasModelAction(component.getStore(), 'read') !== undefined);
}
});
Ext.define('Shopware.grid.Controller', {
extend: 'Ext.app.Controller',
mixins: {
helper: 'Shopware.model.Helper'
},
statics: {
displayConfig: {
gridClass: undefined,
eventAlias: undefined,
deleteConfirmTitle: 'Einträge löschen',
deleteConfirmText: 'Sind Sie sicher, dass Sie die markierten Einträge löschen möchen?',
deleteInfoText: 'Die Einträge werden gelöscht.
Um den Prozess abzubrechen, können Sie den `Cancel process` Button verwenden. Abhänging von der Datenmenge kann dieser Prozess einige Minuten in Anspruch nehmen.',
deleteProgressBarText: 'Eintrag [0] von [1]'
},
getDisplayConfig: function (userOpts, definition) {
var config = { };
if (userOpts && typeof userOpts.configure == 'function') {
config = Ext.apply({ }, config, userOpts.configure());
}
if (definition && typeof definition.configure === 'function') {
config = Ext.apply({ }, config, definition.configure());
}
config = Ext.apply({ }, config, this.displayConfig);
return config;
},
setDisplayConfig: function (prop, val) {
var me = this;
if (!me.displayConfig.hasOwnProperty(prop)) {
return false;
}
me.displayConfig[prop] = val;
return true;
}
},
configure: function() {
return { };
},
constructor: function (opts) {
var me = this;
me._opts = me.statics().getDisplayConfig(opts, this);
me.callParent(arguments);
},
getConfig: function (prop) {
var me = this;
return me._opts[prop];
},
init: function () {
var me = this;
Shopware.app.Application.fireEvent(me.getEventName('before-init'), me);
if (me.$className !== 'Shopware.grid.Controller') {
me.checkRequirements();
}
if (me.getConfig('eventAlias') && me.getConfig('gridClass')) {
me.control(me.createControls());
me.registerEvents();
}
Shopware.app.Application.fireEvent(me.getEventName('after-init'), me);
me.callParent(arguments);
},
checkRequirements: function() {
var me = this;
if (!me.getConfig('eventAlias')) {
me.throwException(me.$className + ": Component requires the `eventAlias` property in the configure() function");
}
if (!me.getConfig('gridClass')) {
me.throwException(me.$className + ": Component requires the `gridClass` property in the configure() function");
}
},
reloadControls: function() {
var me = this;
me.checkRequirements();
me.control(me.createControls());
me.registerEvents();
},
registerEvents: function() {
var me = this;
this.addEvents(
me.getEventName('before-open-delete-window'),
me.getEventName('batch-delete-exception'),
me.getEventName('batch-delete-success'),
me.getEventName('after-selection-changed'),
me.getEventName('before-add-item'),
me.getEventName('before-search'),
me.getEventName('before-page-size-changed'),
me.getEventName('before-edit-item'),
me.getEventName('before-create-detail-window'),
me.getEventName('after-create-detail-window'),
me.getEventName('after-init'),
me.getEventName('after-create-controls'),
me.getEventName('after-create-listing-window-controls'),
me.getEventName('before-delete-items'),
me.getEventName('after-add-item'),
me.getEventName('after-search'),
me.getEventName('after-page-size-changed'),
me.getEventName('after-edit-item')
);
},
createControls: function () {
var me = this, alias, controls = {}, events = {};
alias = Ext.ClassManager.getAliasesByName(me.getConfig('gridClass'));
alias = alias[0];
alias = alias.replace('widget.', '');
controls[alias] = me.createListingWindowControls();
events[me.getConfig('eventAlias') + '-batch-delete-item'] = me.onBatchDeleteItem;
controls['shopware-progress-window'] = events;
Shopware.app.Application.fireEvent(me.getEventName('after-create-controls'), me, controls);
return controls;
},
createListingWindowControls: function () {
var me = this, events = {}, alias;
alias = me.getConfig('eventAlias');
events[alias + '-selection-changed'] = me.onSelectionChanged;
events[alias + '-add-item'] = me.onAddItem;
events[alias + '-delete-item'] = me.onDeleteItem;
events[alias + '-delete-items'] = me.onDeleteItems;
events[alias + '-edit-item'] = me.onEditItem;
events[alias + '-search'] = me.onSearch;
events[alias + '-change-page-size'] = me.onChangePageSize;
Shopware.app.Application.fireEvent(me.getEventName('after-create-listing-window-controls'), me, events, alias);
return events;
},
onDeleteItems: function (grid, records, button) {
var me = this, window,
text = me.getConfig('deleteConfirmText'),
title = me.getConfig('deleteConfirmTitle');
if (!Shopware.app.Application.fireEvent('before-delete-items', me, records, grid, title, text)) {
return false;
}
Ext.MessageBox.confirm(title, text, function (response) {
if (response !== 'yes') {
return false;
}
if (!me.hasModelAction(records[0], 'destroy')) {
grid.getStore().remove(records);
return true;
}
window = Ext.create('Shopware.window.Progress', {
configure: function() {
return {
infoText: me.getConfig('deleteInfoText'),
subApp: me.subApplication,
tasks: [
{
text: me.getConfig('deleteProgressBarText'),
event: me.getConfig('eventAlias') + '-batch-delete-item',
totalCount: records.length,
data: records
}
]
};
}
});
if (!Shopware.app.Application.fireEvent(me.getEventName('before-open-delete-window'), me, window, grid, records)) {
return false;
}
window.on('process-done', function() {
grid.getStore().load();
}, me, { single: true });
window.show();
});
},
onDeleteItem: function (grid, record) {
var me = this;
me.onDeleteItems(grid, [ record ], null);
},
onBatchDeleteItem: function (task, record, callback) {
var me = this, proxy = record.getProxy(), data;
callback = callback || Ext.emptyFn;
proxy.on('exception', function (proxy, response, operation) {
data = Ext.decode(response.responseText);
operation.setException(data.error);
if (!Shopware.app.Application.fireEvent(me.getEventName('batch-delete-exception'), me, record, task, response, operation)) {
return false;
}
callback(response, operation);
}, me, { single: true });
record.destroy({
success: function (result, operation) {
if (!Shopware.app.Application.fireEvent(me.getEventName('batch-delete-success'), me, record, task, result, operation)) {
return false;
}
callback(result, operation);
}
});
},
onSelectionChanged: function (grid, selModel, selection) {
var me = this;
if (!(grid instanceof Ext.grid.Panel)) {
return false;
}
if (!grid.deleteButton) {
return false;
}
grid.deleteButton.setDisabled(selection.length <= 0);
return Shopware.app.Application.fireEvent(me.getEventName('after-selection-changed'), me, grid, selModel, selection);
},
onAddItem: function (listing) {
var me = this, record, store = listing.getStore(), window;
record = Ext.create(store.model);
if (!Shopware.app.Application.fireEvent(me.getEventName('before-add-item'), me, listing, record)) {
return false;
}
me.checkRequirements();
window = me.createDetailWindow(
record,
listing.getConfig('detailWindow')
);
Shopware.app.Application.on(window.eventAlias + '-save-successfully', function() {
listing.getStore().load();
}, me);
Shopware.app.Application.fireEvent(me.getEventName('after-add-item'), me, window, record, listing);
return window;
},
onSearch: function (grid, searchField, value) {
var me = this, store = grid.getStore();
value = Ext.String.trim(value);
store.filters.clear();
store.currentPage = 1;
if (!Shopware.app.Application.fireEvent(me.getEventName('before-search'), me, grid, store, searchField, value)) {
return false;
}
store.on('load', function() {
Shopware.app.Application.fireEvent(me.getEventName('after-search'), me, grid, store, searchField, value);
}, me, { single: true });
if (value.length > 0) {
store.filter({ property: 'search', value: value });
} else {
store.load();
}
return true
},
onChangePageSize: function (grid, combo, records) {
var me = this,
store = grid.getStore();
if (!Shopware.app.Application.fireEvent(me.getEventName('before-page-size-changed'), me, grid, combo, records)) {
return false;
}
if (combo.getValue() > 0) {
store.pageSize = combo.getValue();
store.currentPage = 1;
store.load();
}
return Shopware.app.Application.fireEvent(me.getEventName('after-page-size-changed'), me, grid, combo, records);
},
onEditItem: function (listing, record) {
var me = this, window;
if (!(record instanceof Ext.data.Model)) {
return false;
}
if (!Shopware.app.Application.fireEvent(me.getEventName('before-edit-item'), me, listing, record)) {
return false;
}
me.checkRequirements();
if (me.hasModelAction(record, 'detail')) {
record.reload({
callback: function (result) {
window = me.createDetailWindow(
result,
listing.getConfig('detailWindow')
);
Shopware.app.Application.on(window.eventAlias + '-save-successfully', function() {
listing.getStore().load();
}, me, { single: true });
Shopware.app.Application.fireEvent(me.getEventName('after-edit-item'), me, window, listing, record);
}
});
return true;
} else {
window = me.createDetailWindow(
record,
listing.getConfig('detailWindow')
);
Shopware.app.Application.on(window.eventAlias + '-save-successfully', function() {
listing.getStore().load();
}, me, { single: true });
Shopware.app.Application.fireEvent(me.getEventName('after-edit-item'), me, window, listing, record);
return true;
}
},
createDetailWindow: function (record, detailWindowClass) {
var me = this, window;
if (!detailWindowClass) {
return false;
}
if (!Shopware.app.Application.fireEvent(me.getEventName('before-create-detail-window'), me, record)) {
return false;
}
window = me.getView(detailWindowClass).create({
record: record
});
if (!Shopware.app.Application.fireEvent(me.getEventName('after-create-detail-window'), me, record, window)) {
return false;
}
if (window) {
window.show();
}
return window;
},
getEventName: function (name) {
return this.getConfig('eventAlias') + '-' + name;
}
});
Ext.define('Shopware.grid.Panel', {
extend: 'Ext.grid.Panel',
alias: 'widget.shopware-grid-panel',
mixins: {
helper: 'Shopware.model.Helper'
},
toolbar: undefined,
addButton: undefined,
deleteButton: undefined,
searchField: undefined,
pageSizeCombo: undefined,
pagingbar: undefined,
controller: undefined,
model: undefined,
eventAlias: undefined,
statics: {
displayConfig: {
detailWindow: undefined,
eventAlias: undefined,
hasOwnController: false,
toolbar: true,
addButton: true,
deleteButton: true,
searchField: true,
pagingbar: true,
pageSize: true,
actionColumn: true,
editColumn: true,
deleteColumn: true,
rowNumbers: false,
rowEditing: false,
columns: { },
pageSizeLabel: 'Einträge pro Seite',
addButtonText: 'Hinzufügen',
deleteButtonText: 'Markierte Einträge löschen',
searchFieldText: 'Suche ...'
},
getDisplayConfig: function (userOpts, definition) {
var config = { };
if (userOpts && typeof userOpts.configure == 'function') {
config = Ext.apply({ }, config, userOpts.configure());
}
if (definition && typeof definition.configure === 'function') {
config = Ext.apply({ }, config, definition.configure());
}
config = Ext.apply({ }, config, this.displayConfig);
return config;
},
setDisplayConfig: function (prop, val) {
var me = this;
val = val || '';
if (!me.displayConfig.hasOwnProperty(prop)) {
return false;
}
me.displayConfig[prop] = val;
return true;
}
},
configure: function() {
return { };
},
getConfig: function (prop) {
var me = this;
return me._opts[prop];
},
constructor: function (opts) {
var me = this;
me._opts = me.statics().getDisplayConfig(opts, this);
me.callParent(arguments);
},
initComponent: function () {
var me = this;
me.checkRequirements();
me.model = me.store.model;
me.eventAlias = me.getConfig('eventAlias');
if (!me.eventAlias) me.eventAlias = me.getEventAlias(me.model.$className);
me.fieldAssociations = me.getAssociations(me.model.$className, [
{ relation: 'ManyToOne' }
]);
me.registerEvents();
me.fireEvent(me.eventAlias + '-before-init-component', me);
me.columns = me.createColumns();
me.plugins = me.createPlugins();
me.features = me.createFeatures();
me.selModel = me.createSelectionModel();
me.dockedItems = me.createDockedItems();
if (me.getConfig('hasOwnController') === false) {
me.createDefaultController();
}
me.fireEvent(me.eventAlias + '-after-init-component', me);
me.callParent(arguments);
},
checkRequirements: function() {
var me = this;
if (!(me.store instanceof Ext.data.Store)) {
me.throwException(me.$className + ": Component requires a configured store, which has to been passed in the class constructor.");
}
if (me.alias.length <= 0) {
me.throwException(me.$className + ": Component requires a configured Ext JS widget alias.");
}
if (me.alias.length === 1 && me.alias[0] === 'widget.shopware-grid-panel') {
me.throwException(me.$className + ": Component requires a configured Ext JS widget alias.");
}
},
createDefaultController: function () {
var me = this;
me.controller = me.subApp.getController('Shopware.grid.Controller');
me.controller._opts.gridClass = me.$className;
me.controller._opts.eventAlias = me.eventAlias;
me.controller.reloadControls();
return me.controller;
},
registerEvents: function () {
var me = this;
this.addEvents(
me.eventAlias + '-selection-changed',
me.eventAlias + '-add-item',
me.eventAlias + '-delete-item',
me.eventAlias + '-delete-items',
me.eventAlias + '-edit-item',
me.eventAlias + '-search',
me.eventAlias + '-change-page-size',
me.eventAlias + '-before-init-component',
me.eventAlias + '-after-init-component',
me.eventAlias + '-before-create-columns',
me.eventAlias + '-before-create-action-columns',
me.eventAlias + '-after-create-columns',
me.eventAlias + '-column-created',
me.eventAlias + '-action-column-created',
me.eventAlias + '-before-create-action-column-items',
me.eventAlias + '-after-create-action-column-items',
me.eventAlias + '-delete-action-column-created',
me.eventAlias + '-edit-action-column-created',
me.eventAlias + '-before-create-plugins',
me.eventAlias + '-after-create-plugins',
me.eventAlias + '-selection-model-created',
me.eventAlias + '-before-create-docked-items',
me.eventAlias + '-after-create-docked-items',
me.eventAlias + '-paging-bar-created',
me.eventAlias + '-page-size-combo-created',
me.eventAlias + '-before-create-page-sizes',
me.eventAlias + '-after-create-page-sizes',
me.eventAlias + '-toolbar-created',
me.eventAlias + '-before-create-toolbar-items',
me.eventAlias + '-before-create-right-toolbar-items',
me.eventAlias + '-after-create-toolbar-items',
me.eventAlias + '-add-button-created',
me.eventAlias + '-delete-button-created',
me.eventAlias + '-search-field-created',
me.eventAlias + '-before-reload-data',
me.eventAlias + '-after-reload-data',
me.eventAlias + '-before-create-features',
me.eventAlias + '-after-create-features'
);
},
createColumns: function () {
var me = this, model = null,
column = null,
configColumns = me.getConfig('columns'),
columns = [];
model = me.store.model.$className;
if (model.length > 0) {
model = Ext.create(model);
}
me.fireEvent(me.eventAlias + '-before-create-columns', me, columns);
if (me.getConfig('rowNumbers')) {
columns.push(me.createRowNumberColumn());
}
var keys = model.fields.keys;
if (Object.keys(configColumns).length > 0) keys = Object.keys(configColumns);
Ext.each(keys, function(key) {
var modelField = me.getFieldByName(model.fields.items, key);
column = me.createColumn(model, modelField);
if (column !== null) columns.push(column);
});
me.fireEvent(me.eventAlias + '-before-create-action-columns', me, columns);
if (me.getConfig('actionColumn')) {
column = me.createActionColumn();
if (column !== null) {
columns.push(column);
}
}
me.fireEvent(me.eventAlias + '-after-create-columns', me, columns);
return columns;
},
createColumn: function (model, field) {
var me = this, column = {}, config, customConfig;
if (model.idProperty === field.name) {
return null;
}
column.xtype = 'gridcolumn';
column.dataIndex = field.name;
column.header = me.getHumanReadableWord(field.name);
column.flex = 1;
var fieldAssociation = me.getFieldAssociation(field.name);
if (fieldAssociation === undefined) {
switch (field.type.type) {
case 'int':
column = me.applyIntegerColumnConfig(column);
break;
case 'string':
column = me.applyStringColumnConfig(column);
break;
case 'bool':
column = me.applyBooleanColumnConfig(column);
break;
case 'date':
column = me.applyDateColumnConfig(column, field.dateFormat);
break;
case 'float':
column = me.applyFloatColumnConfig(column);
break;
}
} else {
column.association = fieldAssociation;
column.renderer = me.associationColumnRenderer;
}
config = me.getConfig('columns');
customConfig = config[field.name] || {};
if (Ext.isString(customConfig)) customConfig = { header: customConfig };
if (Ext.isObject(customConfig)) {
column = Ext.apply(column, customConfig);
} else if (Ext.isFunction(customConfig)) {
column = customConfig.call(this, model, column, field, fieldAssociation);
}
me.fireEvent(me.eventAlias + '-column-created', me, column, model, field);
return column;
},
createActionColumn: function () {
var me = this, items, column;
items = me.createActionColumnItems();
column = {
xtype: 'actioncolumn',
width: 30 * items.length,
items: items
};
me.fireEvent(me.eventAlias + '-action-column-created', me, column);
return column;
},
createActionColumnItems: function () {
var me = this, items = [];
me.fireEvent(me.eventAlias + '-before-create-action-column-items', me, items);
if (me.getConfig('deleteColumn')) {
items.push(me.createDeleteColumn());
}
if (me.getConfig('editColumn')) {
items.push(me.createEditColumn());
}
me.fireEvent(me.eventAlias + '-after-create-action-column-items', me, items);
return items;
},
createDeleteColumn: function () {
var me = this, column;
column = {
action: 'delete',
iconCls: 'sprite-minus-circle-frame',
handler: function (view, rowIndex, colIndex, item, opts, record) {
me.fireEvent(me.eventAlias + '-delete-item', me, record, rowIndex, colIndex, item, opts);
}
};
me.fireEvent(me.eventAlias + '-delete-action-column-created', me, column);
return column;
},
createEditColumn: function () {
var me = this, column;
column = {
action: 'edit',
iconCls: 'sprite-pencil',
handler: function (view, rowIndex, colIndex, item, opts, record) {
me.fireEvent(me.eventAlias + '-edit-item', me, record, rowIndex, colIndex, item, opts);
}
};
me.fireEvent(me.eventAlias + '-edit-action-column-created', me, column);
return column;
},
createRowNumberColumn: function () {
return { xtype: 'rownumberer', width: 30 };
},
createPlugins: function () {
var me = this, items = [], item;
me.fireEvent(me.eventAlias + '-before-create-plugins', me, items);
if (me.getConfig('rowEditing')) {
item = Ext.create('Ext.grid.plugin.RowEditing', {
clicksToEdit: 2
});
items.push(item)
}
me.fireEvent(me.eventAlias + '-after-create-plugins', me, items);
return items;
},
createFeatures: function () {
var me = this, items = [];
me.fireEvent(me.eventAlias + '-before-create-features', me, items);
me.fireEvent(me.eventAlias + '-after-create-features', me, items);
return items;
},
createSelectionModel: function () {
var me = this, selModel;
selModel = Ext.create('Ext.selection.CheckboxModel', {
listeners: {
selectionchange: function (selModel, selection) {
return me.fireEvent(me.eventAlias + '-selection-changed', me, selModel, selection);
}
}
});
me.fireEvent(me.eventAlias + '-selection-model-created', me, selModel);
return selModel;
},
createDockedItems: function () {
var me = this, items = [];
me.fireEvent(me.eventAlias + '-before-create-docked-items', me, items);
if (me.getConfig('toolbar')) {
items.push(me.createToolbar());
}
if (me.getConfig('pagingbar')) {
items.push(me.createPagingbar());
}
me.fireEvent(me.eventAlias + '-after-create-docked-items', me, items);
return items;
},
createPagingbar: function () {
var me = this;
me.pagingbar = Ext.create('Ext.toolbar.Paging', {
store: me.store,
dock: 'bottom'
});
if (me.getConfig('pageSize')) {
var pageSizeCombo = me.createPageSizeCombo();
me.pagingbar.add('->', pageSizeCombo, { xtype: 'tbspacer', width: 6 });
}
me.fireEvent(me.eventAlias + '-paging-bar-created', me, me.pagingbar);
return me.pagingbar;
},
createPageSizeCombo: function () {
var me = this, value = 20;
if (me.store) {
value = me.store.pageSize;
}
me.pageSizeCombo = Ext.create('Ext.form.field.ComboBox', {
fieldLabel: me.getConfig('pageSizeLabel'),
labelWidth: 110,
queryMode: 'local',
value: value,
width: 200,
store: Ext.create('Ext.data.Store', {
fields: [ 'value', 'name' ],
data: me.createPageSizes()
}),
displayField: 'name',
valueField: 'value',
listeners: {
select: function (combo, records) {
me.fireEvent(me.eventAlias + '-change-page-size', me, combo, records);
}
}
});
me.fireEvent(me.eventAlias + '-page-size-combo-created', me, me.pageSizeCombo);
return me.pageSizeCombo;
},
createPageSizes: function () {
var me = this, data = [];
me.fireEvent(me.eventAlias + '-before-create-page-sizes', me, data);
for (var i = 1; i <= 10; i++) {
var count = i * 20;
data.push({ value: count, name: count + ' items' });
}
me.fireEvent(me.eventAlias + '-after-create-page-sizes', me, data);
return data;
},
createToolbar: function () {
var me = this;
me.toolbar = Ext.create('Ext.toolbar.Toolbar', {
dock: 'top',
ui: 'shopware-ui',
items: me.createToolbarItems()
});
me.fireEvent(me.eventAlias + '-toolbar-created', me, me.toolbar);
return me.toolbar;
},
createToolbarItems: function () {
var me = this, items = [];
me.fireEvent(me.eventAlias + '-before-create-toolbar-items', me, items);
if (me.getConfig('addButton')) {
items.push(me.createAddButton());
}
if (me.getConfig('deleteButton')) {
items.push(me.createDeleteButton())
}
me.fireEvent(me.eventAlias + '-before-create-right-toolbar-items', me, items);
if (me.getConfig('searchField')) {
items.push('->');
items.push(me.createSearchField());
}
me.fireEvent(me.eventAlias + '-after-create-toolbar-items', me, items);
return items;
},
createAddButton: function () {
var me = this;
me.addButton = Ext.create('Ext.button.Button', {
text: me.getConfig('addButtonText'),
iconCls: 'sprite-plus-circle-frame',
handler: function () {
me.fireEvent(me.eventAlias + '-add-item', me, this);
}
});
me.fireEvent(me.eventAlias + '-add-button-created', me, me.addButton);
return me.addButton;
},
createDeleteButton: function () {
var me = this;
me.deleteButton = Ext.create('Ext.button.Button', {
text: me.getConfig('deleteButtonText'),
disabled: true,
iconCls: 'sprite-minus-circle-frame',
handler: function () {
var selModel = me.getSelectionModel();
me.fireEvent(me.eventAlias + '-delete-items', me, selModel.getSelection(), this);
}
});
me.fireEvent(me.eventAlias + '-delete-button-created', me, me.deleteButton);
return me.deleteButton;
},
createSearchField: function () {
var me = this;
me.searchField = Ext.create('Ext.form.field.Text', {
cls: 'searchfield',
width: 170,
emptyText: me.getConfig('searchFieldText'),
enableKeyEvents: true,
checkChangeBuffer: 500,
listeners: {
change: function (field, value) {
me.fireEvent(me.eventAlias + '-search', me, field, value);
}
}
});
me.fireEvent(me.eventAlias + '-search-field-created', me, me.searchField);
return me.searchField;
},
reloadData: function(store, record) {
var me = this;
if (store instanceof Ext.data.Store) {
if (!me.fireEvent(me.eventAlias + '-before-reload-data', me, store, record)) {
return false;
}
me.reconfigure(store);
me.fireEvent(me.eventAlias + '-after-reload-data', me, store, record);
}
},
getFieldAssociation: function(fieldName) {
var me = this, fieldAssociation = undefined;
Ext.each(me.fieldAssociations, function(association) {
if (association.field === fieldName) {
fieldAssociation = association;
return false;
}
});
return fieldAssociation;
},
associationColumnRenderer: function(value, metaData, record, rowIndex, colIndex) {
var column = this.columns[colIndex], result;
if (!column.association) {
return value;
}
var associationStore = record[column.association.storeName];
if (!(associationStore instanceof Ext.data.Store) || associationStore.getCount() <= 0) {
return value;
}
var associationRecord = associationStore.first();
if (!(associationRecord instanceof Ext.data.Model)) {
return value;
}
result = associationRecord.get('name');
if (result) return result;
result = associationRecord.get('description');
if (result) return result;
return value;
}
});
Ext.define('Shopware.data.Model', {
extend: 'Ext.data.Model',
statics: {
displayConfig: {
controller: undefined,
listing: 'Shopware.grid.Panel',
detail: 'Shopware.model.Container',
related: 'Shopware.grid.Association',
field: 'Shopware.form.field.Search',
proxy: {
type: 'ajax',
api: {
detail: '/backend/base/detail',
create: '/backend/base/create',
update: '/backend/base/update',
destroy: '/backend/base/delete'
},
reader: {
type: 'json',
root: 'data',
totalProperty: 'total'
}
}
},
getDisplayConfig: function (userOpts, definition) {
var config = { };
if (userOpts && typeof userOpts.configure == 'function') {
config = Ext.apply({ }, config, userOpts.configure());
}
if (definition && typeof definition.configure === 'function') {
config = Ext.apply({ }, config, definition.configure());
}
config = Ext.apply({ }, config, this.displayConfig);
return config;
},
setDisplayConfig: function (prop, val) {
var me = this;
if (!me.displayConfig.hasOwnProperty(prop)) {
return false;
}
me.displayConfig[prop] = val;
return true;
}
},
configure: function() {
return { };
},
constructor: function (config) {
var me = this;
me._opts = me.statics().getDisplayConfig(config, this);
me.convertProxyApi();
me.callParent(arguments);
},
getConfig: function (prop) {
var me = this;
return me._opts[prop];
},
convertProxyApi: function () {
var me = this, value;
if (!me.getConfig('controller')) {
return;
}
me.setProxy(me.getConfig('proxy'));
Object.keys(me.proxy.api).forEach(function (key) {
value = me.proxy.api[key] + '';
value = value.replace(
'/backend/base/', '/backend/' + me.getConfig('controller') + '/'
);
me.proxy.api[key] = value;
});
},
reload: function (options) {
var me = this, proxy = me.proxy;
if (!Ext.isString(proxy.api.detail)) {
if (options && Ext.isFunction(options.callback)) {
options.callback(me);
} else {
return this;
}
}
proxy.api.read = proxy.api.detail;
var store = Ext.create('Ext.data.Store', {
model: me.__proto__.$className,
proxy: me.proxy
});
store.getProxy().extraParams.id = me.get('id');
try {
store.load({
callback: function (records, operation) {
var record = records[0];
if (options && Ext.isFunction(options.callback)) {
options.callback(record, operation);
}
}
});
} catch (e) {
return e;
}
}
});
Ext.define('Shopware.store.Listing', {
extend: 'Ext.data.Store',
mixins: {
helper: 'Shopware.model.Helper'
},
autoLoad: false,
batch: true,
remoteSort: true,
remoteFilter: true,
pageSize: 20,
statics: {
displayConfig: {
controller: undefined,
proxy: {
type: 'ajax',
api: {
read: '/backend/base/list'
},
reader: {
type: 'json',
root: 'data',
totalProperty: 'total'
}
}
},
getDisplayConfig: function (userOpts, definition) {
var config = { };
if (userOpts && typeof userOpts.configure == 'function') {
config = Ext.apply({ }, config, userOpts.configure());
}
if (definition && typeof definition.configure === 'function') {
config = Ext.apply({ }, config, definition.configure());
}
config = Ext.apply({ }, config, this.displayConfig);
return config;
},
setDisplayConfig: function (prop, val) {
var me = this;
if (!me.displayConfig.hasOwnProperty(prop)) {
return false;
}
me.displayConfig[prop] = val;
return true;
}
},
configure: function() {
return { };
},
getConfig: function (prop) {
var me = this;
return me._opts[prop];
},
constructor: function (config) {
var me = this;
me._opts = me.statics().getDisplayConfig(config, this);
me.convertProxyApi();
me.callParent(arguments);
},
convertProxyApi: function () {
var me = this, value;
me.checkRequirements();
me.setProxy(me.getConfig('proxy'));
Object.keys(me.proxy.api).forEach(function (key) {
value = me.proxy.api[key] + '';
value = value.replace(
'/backend/base/', '/backend/' + me.getConfig('controller') + '/'
);
me.proxy.api[key] = value;
});
},
checkRequirements: function() {
var me = this;
if (!me.getConfig('controller')) {
me.throwException(me.$className + ": Component requires the `controller` property in the configure() function.");
}
}
});
Ext.define('Shopware.window.Detail', {
extend: 'Enlight.app.Window',
layout: {
type: 'hbox',
align: 'stretch'
},
mixins: {
helper: 'Shopware.model.Helper'
},
width: 990,
height: '90%',
alias: 'widget.shopware-window-detail',
associationComponents: [],
eventAlias: undefined,
record: undefined,
controller: undefined,
tabPanel: undefined,
formPanel: undefined,
toolbar: undefined,
cancelButton: undefined,
saveButton: undefined,
statics: {
displayConfig: {
eventAlias: undefined,
associations: [],
hasOwnController: false,
cancelButtonText: 'Abbrechen',
saveButtonText: 'Speichern'
},
getDisplayConfig: function (userOpts, definition) {
var config = { };
if (userOpts && typeof userOpts.configure == 'function') {
config = Ext.apply({ }, config, userOpts.configure());
}
if (definition && typeof definition.configure === 'function') {
config = Ext.apply({ }, config, definition.configure());
}
config = Ext.apply({ }, config, this.displayConfig);
return config;
},
setDisplayConfig: function (prop, val) {
var me = this;
if (!me.displayConfig.hasOwnProperty(prop)) {
return false;
}
me.displayConfig[prop] = val;
return true;
}
},
configure: function() {
return { };
},
constructor: function (opts) {
var me = this;
me._opts = me.statics().getDisplayConfig(opts, this);
me.callParent(arguments);
},
getConfig: function (prop) {
var me = this;
return me._opts[prop];
},
initComponent: function () {
var me = this;
me.checkRequirements();
me.associationComponents = [];
me.eventAlias = me.getConfig('eventAlias');
if (!me.eventAlias) me.eventAlias = me.getEventAlias(me.record.$className);
me.items = [ me.createFormPanel() ];
me.dockedItems = me.createDockedItems();
if (me.getConfig('hasOwnController') === false) {
me.createDefaultController();
}
me.callParent(arguments);
me.loadRecord(me.record);
},
checkRequirements: function() {
var me = this;
if (!(me.record instanceof Shopware.data.Model)) {
me.throwException(me.$className + ": Component requires a passed Shopware.data.Model in the `record` property.");
}
if (me.alias.length <= 0) {
me.throwException(me.$className + ": Component requires a configured Ext JS widget alias.");
}
if (me.alias.length === 1 && me.alias[0] === 'widget.shopware-window-detail') {
me.throwException(me.$className + ": Component requires a configured Ext JS widget alias.");
}
},
registerEvents: function() {
var me = this;
me.addEvents(
me.getEventName('before-tab-changed'),
me.getEventName('after-tab-changed'),
me.getEventName('before-load-record'),
me.getEventName('after-load-record'),
me.getEventName('save'),
me.getEventName('before-load-lazy-loading-component'),
me.getEventName('after-load-lazy-loading-component'),
me.getEventName('before-load-associations'),
me.getEventName('after-load-associations'),
me.getEventName('before-load-association-component'),
me.getEventName('after-load-association-component'),
me.getEventName('before-create-toolbar-items'),
me.getEventName('after-create-toolbar-items'),
me.getEventName('before-create-tab-item'),
me.getEventName('after-create-tab-item'),
me.getEventName('before-create-tab-items'),
me.getEventName('after-create-tab-items')
);
},
createDefaultController: function() {
var me = this;
me.controller = me.subApp.getController('Shopware.detail.Controller');
me.controller._opts.detailWindow = me.$className;
me.controller._opts.eventAlias = me.eventAlias;
me.controller.reloadControls();
return me.controller;
},
destroy: function() {
var me = this;
if (!me.getConfig('hasOwnController') && me.controller) {
me.subApp.eventbus.uncontrol([me.controller.$className]);
}
return me.callParent(arguments);
},
createFormPanel: function () {
var me = this, items;
items = me.createTabItems();
if (items.length > 1) {
me.tabPanel = Ext.create('Ext.tab.Panel', {
flex: 1,
items: items,
listeners: {
tabchange: function (tabPanel, newCard, oldCard, eOpts) {
me.onTabChange(tabPanel, newCard, oldCard, eOpts);
}
}
});
items = [ me.tabPanel ];
}
me.formPanel = Ext.create('Ext.form.Panel', {
items: items,
flex: 1,
layout: {
type: 'hbox',
align: 'stretch'
}
});
return me.formPanel;
},
createTabItems: function () {
var me = this, item, items = [];
if (!me.fireEvent(me.getEventName('before-create-tab-items'), me, items)) {
return [];
}
Ext.each(me.getTabItemsAssociations(), function (association) {
item = me.createTabItem(association);
if (item) items.push(item);
});
me.fireEvent(me.getEventName('after-create-tab-items'), me, items);
return items;
},
getTabItemsAssociations: function () {
var me = this, associations, config = me.getConfig('associations') || [];
associations = me.getAssociations(me.record.$className, [
{ associationKey: config }
]);
associations = Ext.Array.insert(associations, 0, [
{ isBaseRecord: true, associationKey: 'baseRecord' }
]);
return associations;
},
createTabItem: function (association) {
var me = this, item;
if (!me.fireEvent(me.getEventName('before-create-tab-item'), me, association)) {
return false;
}
if (association.isBaseRecord) {
item = me.createAssociationComponent('detail', me.record, null, null, me.record);
} else {
item = me.createAssociationComponent(
me.getComponentTypeOfAssociation(association),
Ext.create(association.associatedName),
me.getAssociationStore(me.record, association),
association,
me.record
);
}
me.associationComponents[association.associationKey] = item;
me.fireEvent(me.getEventName('after-create-tab-item'), me, association, item);
if (item.title === undefined) {
item.title = me.getModelName(association.associatedName);
}
return item;
},
createAssociationComponent: function(type, model, store, association, baseRecord) {
var me = this, component = { };
if (!(model instanceof Shopware.data.Model)) {
me.throwException(model.$className + ' has to be an instance of Shopware.data.Model');
}
if (baseRecord && !(baseRecord instanceof Shopware.data.Model)) {
me.throwException(baseRecord.$className + ' has to be an instance of Shopware.data.Model');
}
var componentType = model.getConfig(type);
if (!me.fireEvent(me.getEventName('before-association-component-created'), me, component, type, model, store)) {
return component;
}
component = Ext.create(componentType, {
record: model,
store: store,
flex: 1,
subApp: this.subApp,
association: association,
configure: function() {
var config = { };
if (association) {
config.associationKey = association.associationKey;
}
if (baseRecord && baseRecord.getConfig('controller')) {
config.controller = baseRecord.getConfig('controller');
}
return config;
}
});
component.on('viewready', function() {
if (me.isLazyLoadingComponent(component)) {
if (!(me.fireEvent(me.getEventName('before-load-lazy-loading-component'), me, component))) {
return true;
}
component.getStore().load({
callback: function(records, operation) {
me.fireEvent(me.getEventName('after-load-lazy-loading-component'), me, component, records, operation);
}
});
}
});
me.fireEvent(me.getEventName('after-association-component-created'), me, component, type, model, store);
return component;
},
createDockedItems: function () {
var me = this;
return [
me.createToolbar()
];
},
createToolbar: function () {
var me = this;
me.toolbar = Ext.create('Ext.toolbar.Toolbar', {
items: me.createToolbarItems(),
dock: 'bottom'
});
return me.toolbar;
},
createToolbarItems: function() {
var me = this, items = [];
me.fireEvent(me.getEventName('before-create-toolbar-items'), me, items);
items.push({ xtype: 'tbfill' });
items.push(me.createCancelButton());
items.push(me.createSaveButton());
me.fireEvent(me.getEventName('after-create-toolbar-items'), me, items);
return items;
},
createCancelButton: function () {
var me = this;
me.cancelButton = Ext.create('Ext.button.Button', {
cls: 'secondary',
name: 'cancel-button',
text: me.getConfig('cancelButtonText'),
handler: function () {
me.onCancel();
}
});
return me.cancelButton;
},
createSaveButton: function () {
var me = this;
me.saveButton = Ext.create('Ext.button.Button', {
cls: 'primary',
name: 'detail-save-button',
text: me.getConfig('saveButtonText'),
handler: function () {
me.onSave();
}
});
return me.saveButton;
},
loadRecord: function (record) {
var me = this;
if (!(me.fireEvent(me.getEventName('before-load-record'), me, record))) {
return false;
}
if (this.formPanel instanceof Ext.form.Panel) {
this.formPanel.loadRecord(record);
}
me.fireEvent(me.getEventName('after-load-record'), me, record);
this.loadAssociationData(record);
},
loadAssociationData: function(record) {
var me = this, association, component, store;
if (!(me.fireEvent(me.getEventName('before-load-associations'), me, record))) {
return false;
}
Object.keys(me.associationComponents).forEach(function(key) {
component = me.associationComponents[key];
store = null;
association = null;
if (key != 'baseRecord') {
association = me.getAssociations(record.$className, [ { associationKey: [ key ] } ]);
store = me.getAssociationStore(record, association[0]);
}
if (!(me.fireEvent(me.getEventName('before-load-association-component'), me, record, component, store, association))) {
return true;
}
if (component && typeof component.reloadData === 'function') {
component.reloadData(
store,
record
);
}
if (me.isLazyLoadingComponent(component)) {
component.getStore().load();
}
me.fireEvent(me.getEventName('after-load-association-component'), me, record, component, store, association);
});
me.fireEvent(me.getEventName('after-load-associations'), me, record);
},
onTabChange: function (tabPanel, newCard, oldCard, eOpts) {
var me = this;
if (!(me.fireEvent(me.getEventName('before-tab-changed'), me, tabPanel, newCard, oldCard, eOpts))) {
return false;
}
me.fireEvent(me.getEventName('after-tab-changed'), me, tabPanel, newCard, oldCard, eOpts);
},
onSave: function () {
this.fireEvent(
this.getEventName('save'), this, this.record
);
},
onCancel: function () {
this.destroy();
},
getEventName: function (name) {
return this.eventAlias + '-' + name;
},
});
Ext.define('Shopware.window.Listing', {
extend: 'Enlight.app.Window',
mixins: {
helper: 'Shopware.model.Helper'
},
layout: 'border',
width: 990,
height: '50%',
alias: 'widget.shopware-window-listing',
eventAlias: undefined,
listingStore: undefined,
gridPanel: undefined,
statics: {
displayConfig: {
listingGrid: undefined,
listingStore: undefined,
eventAlias: undefined,
extensions: [ ]
},
getDisplayConfig: function (userOpts, definition) {
var config = { };
if (userOpts && typeof userOpts.configure == 'function') {
config = Ext.apply({ }, config, userOpts.configure());
}
if (definition && typeof definition.configure === 'function') {
config = Ext.apply({ }, config, definition.configure());
}
config = Ext.apply({ }, config, this.displayConfig);
return config;
},
setDisplayConfig: function (prop, val) {
var me = this;
if (!me.displayConfig.hasOwnProperty(prop)) {
return false;
}
me.displayConfig[prop] = val;
return true;
}
},
configure: function() {
return { };
},
constructor: function (opts) {
var me = this;
me._opts = me.statics().getDisplayConfig(opts, this);
me.callParent(arguments);
},
getConfig: function (prop) {
var me = this;
return me._opts[prop];
},
initComponent: function () {
var me = this;
me.checkRequirements();
me.listingStore = me.createListingStore();
me.eventAlias = me.getConfig('eventAlias');
if (!me.eventAlias) me.eventAlias = me.getEventAlias(me.listingStore.model.$className);
me.registerEvents();
me.fireEvent(me.eventAlias + '-before-init-component', me);
me.items = me.createItems();
me.fireEvent(me.eventAlias + '-after-init-component', me);
me.callParent(arguments);
},
checkRequirements: function() {
var me = this;
if (me.alias.length <= 0) {
me.throwException(me.$className + ": Component requires a configured Ext JS widget alias.");
}
if (me.alias.length === 1 && me.alias[0] === 'widget.shopware-window-listing') {
me.throwException(me.$className + ": Component requires a configured Ext JS widget alias.");
}
if (!me.getConfig('listingGrid')) {
me.throwException(me.$className + ": Component requires the configured `listingGrid` property in the configure() function.");
}
if (!me.getConfig('listingStore')) {
me.throwException(me.$className + ": Component requires the configured `listingStore` property in the configure() function.");
}
},
registerEvents: function() {
var me = this;
me.addEvents(
me.eventAlias + '-before-init-component',
me.eventAlias + '-before-create-items',
me.eventAlias + '-after-create-items',
me.eventAlias + '-after-extensions-loaded',
me.eventAlias + '-after-create-grid-panel',
me.eventAlias + '-after-init-component'
);
},
createListingStore: function() {
var me = this;
return Ext.create(this.getConfig('listingStore'));
},
createItems: function () {
var me = this, items = [];
me.fireEvent(me.eventAlias + '-before-create-items', me, items);
items.push(me.createGridPanel());
me.fireEvent(me.eventAlias + '-after-create-items', me, items);
Ext.each(me.getConfig('extensions'), function(extension) {
if (!extension) return true;
if (Ext.isString(extension)) extension = { xtype: extension };
extension.listingWindow = me;
items.push(extension);
});
me.fireEvent(me.eventAlias + '-after-extensions-loaded', me, items);
return items;
},
createGridPanel: function () {
var me = this;
me.listingStore.load();
me.gridPanel = Ext.create(me.getConfig('listingGrid'), {
store: me.listingStore,
flex: 1,
subApp: me.subApp
});
me.fireEvent(me.eventAlias + '-after-create-grid-panel', me, me.gridPanel);
return me.gridPanel;
}
});
Ext.define('Shopware.window.Progress', {
extend: 'Ext.window.Window',
title: 'Einträge löschen',
alias: 'widget.shopware-progress-window',
layout: {
type: 'vbox',
align: 'stretch'
},
width: 600,
modal: true,
bodyPadding: 20,
height: 360,
closable: false,
cancelProcess: false,
cancelButton: undefined,
closeButton: undefined,
resultStore: undefined,
resultGrid: undefined,
resultFieldSet: undefined,
statics: {
displayConfig: {
infoText: undefined,
tasks: [ ],
outputProperties: [ 'id', 'number', 'name' ],
displayResultGrid: true,
cancelButtonText: 'Prozess abbrechen',
closeButtonText: 'Fenster schließen',
successHeader: 'Erfolgreich',
requestHeader: 'Request',
errorHeader: 'Fehlermeldung',
requestResultTitle: 'Request Ergebnis',
processCanceledText: 'Prozess wurde an Position [0] von [1] unterbrochen'
},
getDisplayConfig: function (userOpts, definition) {
var config = { };
if (userOpts && typeof userOpts.configure == 'function') {
config = Ext.apply({ }, config, userOpts.configure());
}
if (definition && typeof definition.configure === 'function') {
config = Ext.apply({ }, config, definition.configure());
}
config = Ext.apply({ }, config, this.displayConfig);
return config;
},
setDisplayConfig: function (prop, val) {
var me = this;
if (!me.displayConfig.hasOwnProperty(prop)) {
return false;
}
me.displayConfig[prop] = val;
return true;
}
},
configure: function() {
return { };
},
getConfig: function (prop) {
var me = this;
return me._opts[prop];
},
constructor: function (opts) {
var me = this;
me._opts = me.statics().getDisplayConfig(opts, this);
me.callParent(arguments);
},
initComponent: function () {
var me = this;
me.registerEvents();
me.fireEvent('before-init-component', me);
me.cancelProcess = false;
me.items = me.createItems();
me.dockedItems = [ me.createToolbar() ];
me.fireEvent('after-init-component', me);
me.callParent(arguments);
me.fireEvent('before-start-sequential-process', me);
me.sequentialProcess(undefined, me.getConfig('tasks'));
},
registerEvents: function() {
var me = this;
me.addEvents(
'before-init-component',
'after-init-component',
'before-start-sequential-process',
'before-create-items',
'after-create-items',
'before-create-toolbar',
'after-create-toolbar',
'before-create-toolbar-items',
'after-create-toolbar-fill-item',
'after-create-toolbar-items',
'before-result-field-set-created',
'after-result-grid-created',
'after-result-field-set-created',
'task-toolbar-created',
'process-done'
);
},
createItems: function () {
var me = this, items = [], item;
var tasks = me.getConfig('tasks');
if (!me.fireEvent('before-create-items', me, items)) {
return items;
}
if (me.getConfig('infoText')) {
items.push(me.createInfoText());
}
Ext.each(tasks, function (task) {
item = me.createTaskProgressBar(task);
if (item) {
items.push(item);
}
});
if (me.getConfig('displayResultGrid')) {
items.push(me.createResultFieldSet());
}
me.fireEvent('after-create-items', me, items);
return items;
},
createToolbar: function () {
var me = this, toolbar = null;
if (!me.fireEvent('before-create-toolbar', me, toolbar)) {
return toolbar;
}
me.toolbar = Ext.create('Ext.toolbar.Toolbar', {
dock: 'bottom',
items: me.createToolbarItems()
});
me.fireEvent('after-create-toolbar', me, me.toolbar);
return me.toolbar;
},
createToolbarItems: function() {
var me = this, items = [];
if (!me.fireEvent('before-create-toolbar-items', me, items)) {
return items;
}
me.cancelButton = Ext.create('Ext.button.Button', {
cls: 'secondary',
text: me.getConfig('cancelButtonText'),
handler: function() {
me.cancelProcess = true;
}
});
me.closeButton = Ext.create('Ext.button.Button', {
cls: 'secondary',
text: me.getConfig('closeButtonText'),
disabled: true,
handler: function() { me.destroy() }
});
items.push('->');
me.fireEvent('after-create-toolbar-fill-item', me, items);
items.push(me.cancelButton);
items.push(me.closeButton);
me.fireEvent('after-create-toolbar-items', me, items);
return items;
},
createResultFieldSet: function () {
var me = this, fieldSet = null;
if (!me.fireEvent('before-result-field-set-created', me, fieldSet)) {
return fieldSet;
}
me.resultGrid = me.createResultGrid();
me.fireEvent('after-result-grid-created', me, me.resultGrid);
me.resultFieldSet = Ext.create('Ext.form.FieldSet', {
items: [ me.resultGrid ],
layout: 'fit',
collapsible: true,
collapsed: false,
flex: 1,
margin: '20 0 0',
title: me.getConfig('requestResultTitle')
});
me.fireEvent('after-result-field-set-created', me, me.resultFieldSet);
return me.resultFieldSet;
},
createResultGrid: function() {
var me = this;
me.resultStore = Ext.create('Ext.data.Store', {
model: 'Shopware.model.DataOperation'
});
return Ext.create('Ext.grid.Panel', {
border: false,
columns: [
{ xtype: 'rownumberer', width: 30 },
{ header: me.getConfig('successHeader'), dataIndex: 'success', width: 60, renderer: me.successRenderer },
{ header: me.getConfig('requestHeader'), dataIndex: 'request', flex: 1, renderer: me.requestRenderer, scope: me },
{ header: me.getConfig('errorHeader'), dataIndex: 'error', flex: 1 }
],
store: me.resultStore
});
},
createInfoText: function () {
return Ext.create('Ext.container.Container', {
html: this.getConfig('infoText'),
style: 'line-height:20px;'
});
},
createTaskProgressBar: function (task) {
var me = this;
task.progressBar = Ext.create('Ext.ProgressBar', {
animate: true,
text: Ext.String.format(task.text, 0, task.totalCount),
value: 0,
height: 20,
margin: '15 0 0'
});
me.fireEvent('task-toolbar-created', me, task, task.progressBar);
return task.progressBar;
},
sequentialProcess: function (current, tasks) {
var me = this, record;
if (current == undefined && tasks.length > 0) {
current = tasks.shift();
}
if (current.data && current.data.length <= 0) {
current = tasks.shift();
}
if (!current || me.cancelProcess) {
me.closeButton.enable();
me.cancelButton.disable();
if (me.cancelProcess) {
me.updateProgressBar(current, me.getConfig('processCanceledText'));
}
me.fireEvent('process-done', me, current, me.cancelProcess);
return false;
}
if (!current.hasOwnProperty('totalCount')) current.totalCount = current.data.length;
record = current.data.shift();
me.updateProgressBar(current, current.text);
me.fireEvent(current.event, current, record, function(result, operation) {
if (!me.getConfig('displayResultGrid')) {
me.sequentialProcess(current, tasks);
}
var responseRecord = me.createResponseRecord(result, operation);
me.resultStore.add(responseRecord);
if (!responseRecord.get('success')) {
me.resultFieldSet.expand();
}
me.sequentialProcess(current, tasks);
});
return true;
},
updateProgressBar: function(task, text) {
var index = task.totalCount - task.data.length;
task.progressBar.updateProgress(
index / task.totalCount,
Ext.String.format(text, index, task.totalCount),
true
);
},
createResponseRecord: function(result, operation) {
var success = false, error = '', request, data = { };
if (Ext.isObject(result) && result.hasOwnProperty('responseText')) {
data = Ext.decode(result.responseText);
}
if (data.hasOwnProperty('success')) {
success = data.success;
} else if (Ext.isObject(operation) && operation.hasOwnProperty('wasSuccessful')) {
success = operation.wasSuccessful();
} else if (Ext.isObject(operation) && operation.hasOwnProperty('success')) {
success = operation.success;
} else if (Ext.isObject(result) && result.hasOwnProperty('success')) {
success = result.success;
} else if (Ext.isObject(result) && result.hasOwnProperty('status')) {
success = (result.status === 200);
}
if (data.hasOwnProperty('error')) {
error = data.error;
} else if (Ext.isObject(operation) && operation.hasOwnProperty('getError')) {
error = operation.getError();
} else if (Ext.isObject(operation) && operation.hasOwnProperty('error')) {
error = operation.error;
}
if (Ext.isObject(operation) && operation.hasOwnProperty('request')) {
request = operation.request;
} else if (Ext.isObject(result) && result.hasOwnProperty('request')) {
request = result.request;
}
return Ext.create('Shopware.model.DataOperation', {
success: success,
error: error,
request: request,
operation: operation
});
},
successRenderer: function(value, metaData) {
metaData.tdAttr = 'style="vertical-align: middle;"';
var css = 'sprite-cross-small';
if (value) {
css = 'sprite-tick-small'
}
return '';
},
requestRenderer: function(value, metaData, record) {
var me = this, operation, propertyValue,
params = [], requestRecord,
url,
properties = me.getConfig('outputProperties');
operation = record.get('operation');
if (Ext.isObject(operation) && operation.hasOwnProperty('getRecords')) {
requestRecord = operation.getRecords();
requestRecord = requestRecord[0];
}
if (Ext.isObject(value) && value.hasOwnProperty('url')) {
url = value.url;
} else if (Ext.isObject(value)
&& value.hasOwnProperty('options')
&& value.options.hasOwnProperty('url')) {
url = value.options.url;
}
params.push('url = ' + url);
if (requestRecord) {
Ext.each(properties, function(property) {
propertyValue = requestRecord.get(property);
if (propertyValue) {
params.push('' + property + ' = ' + propertyValue);
}
});
}
return params.join('
');
}
});
Ext.define('Shopware.model.DataOperation', {
extend:'Ext.data.Model',
phantom: true,
fields:[
{ name: 'success', type: 'boolean' },
{ name: 'request' },
{ name: 'error', type: 'string' },
{ name: 'operation' },
]
});
Ext.define('Shopware.grid.Association', {
extend: 'Shopware.grid.Panel',
alias: 'widget.shopware-grid-association',
searchStore: undefined,
searchComboBox: undefined,
statics: {
displayConfig: {
controller: undefined,
associationKey: undefined,
searchUrl: '/backend/base/searchAssociation',
searchCombo: true,
pagingbar: false,
editColumn: false,
searchComboLabel: 'Suche nach'
},
getDisplayConfig: function (userOpts, definition) {
var config = { };
if (userOpts && typeof userOpts.configure == 'function') {
config = Ext.apply({ }, config, userOpts.configure());
}
if (definition && typeof definition.configure === 'function') {
config = Ext.apply({ }, config, definition.configure());
}
config = Ext.apply({ }, config, this.displayConfig);
if (config.controller) {
config.searchUrl = config.searchUrl.replace(
'/backend/base/', '/backend/' + config.controller + '/'
);
}
return config;
},
setDisplayConfig: function (prop, val) {
var me = this;
val = val || '';
if (!me.displayConfig.hasOwnProperty(prop)) {
return false;
}
me.displayConfig[prop] = val;
return true;
}
},
configure: function() {
return { };
},
getConfig: function (prop) {
var me = this;
return me._opts[prop];
},
constructor: function (opts) {
var me = this, args;
me._opts = me.statics().getDisplayConfig(opts, this);
args = arguments;
opts.configure = function() {
return me._opts;
};
me.callParent(args);
},
checkRequirements: function() {
var me = this;
if (!(me.store instanceof Ext.data.Store)) {
me.throwException(me.$className + ": Component requires a configured store, which has to been passed in the class constructor.");
}
if (me.alias.length <= 0) {
me.throwException(me.$className + ": Component requires a configured Ext JS widget alias.");
}
if (me.alias.length === 1 && me.alias[0] === 'widget.shopware-grid-association') {
me.throwException(me.$className + ": Component requires a configured Ext JS widget alias.");
}
},
createToolbar: function() {
var me = this, toolbar;
toolbar = me.callParent(arguments);
toolbar.style = 'background:#fff';
return toolbar;
},
createToolbarItems: function() {
var me = this, items = [];
if (me.getConfig('searchCombo')) {
me.searchStore = me.createAssociationSearchStore(
me.getStore().model,
me.getConfig('associationKey'),
me.getConfig('searchUrl')
);
me.searchComboBox = me.createSearchCombo(me.searchStore);
items.push(me.searchComboBox);
}
return items;
},
createSearchCombo: function (store) {
var me = this;
return Ext.create('Shopware.form.field.Search', {
name: 'associationSearchField',
store: store,
pageSize: 20,
flex: 1,
subApp: me.subApp,
fieldLabel: me.getConfig('searchComboLabel'),
margin: 5,
listeners: {
select: function (combo, records) {
me.onSelectSearchItem(combo, records);
}
}
});
},
onSelectSearchItem: function (combo, records) {
var me = this, inStore;
Ext.each(records, function (record) {
inStore = me.getStore().getById(record.get('id'));
if (inStore === null) {
me.getStore().add(record);
combo.setValue('');
}
});
}
});
Ext.define('Shopware.model.Container', {
extend: 'Ext.container.Container',
autoScroll: true,
associationComponents: [],
eventAlias: undefined,
fieldAssociations: undefined,
record: undefined,
mixins: {
helper: 'Shopware.model.Helper'
},
statics: {
displayConfig: {
controller: undefined,
eventAlias: undefined,
searchUrl: '/backend/base/searchAssociation',
fieldSets: [
{
fields: { },
title: undefined
}
],
associations: [ ],
fieldAlias: undefined
},
getDisplayConfig: function (userOpts, definition) {
var config = { };
if (userOpts && typeof userOpts.configure == 'function') {
config = Ext.apply({ }, config, userOpts.configure());
}
if (definition && typeof definition.configure === 'function') {
config = Ext.apply({ }, config, definition.configure());
}
config = Ext.apply({ }, config, this.displayConfig);
if (config.controller) {
config.searchUrl = config.searchUrl.replace(
'/backend/base/', '/backend/' + config.controller + '/'
);
}
return config;
},
setDisplayConfig: function (prop, val) {
var me = this;
val = val || '';
if (!me.displayConfig.hasOwnProperty(prop)) {
return false;
}
me.displayConfig[prop] = val;
return true;
}
},
configure: function() {
return { };
},
getConfig: function (prop) {
var me = this;
return me._opts[prop];
},
constructor: function (opts) {
var me = this;
me._opts = me.statics().getDisplayConfig(opts, this);
me.callParent(arguments);
},
initComponent: function() {
var me = this;
me.checkRequirements();
me.eventAlias = me.getConfig('eventAlias');
if (!me.eventAlias) me.eventAlias = me.getEventAlias(me.record.$className);
me.registerEvents();
me.fireEvent(me.eventAlias + '-before-init-component', me);
me.fieldAssociations = me.getAssociations(me.record.$className, [
{ relation: 'ManyToOne' }
]);
me.associationComponents = [];
me.items = me.createItems();
me.title = me.getModelName(me.record.$className);
me.fireEvent(me.eventAlias + '-after-init-component', me);
me.callParent(arguments);
},
checkRequirements: function() {
var me = this;
if (!(me.record instanceof Shopware.data.Model)) {
me.throwException(me.$className + ": Component requires a passed Shopware.data.Model in the `record property.");
}
},
registerEvents: function() {
var me = this;
this.addEvents(
me.eventAlias + '-before-init-component',
me.eventAlias + '-after-init-component',
me.eventAlias + '-before-create-items',
me.eventAlias + '-after-create-items',
me.eventAlias + '-before-association-component-created',
me.eventAlias + '-after-association-component-created',
me.eventAlias + '-model-fields-created',
me.eventAlias + '-before-model-field-set-created',
me.eventAlias + '-column-containers-created',
me.eventAlias + '-after-model-field-set-created',
me.eventAlias + '-before-create-model-field',
me.eventAlias + '-association-field-created',
me.eventAlias + '-model-field-created',
me.eventAlias + '-before-reload-data',
me.eventAlias + '-before-reload-association-data',
me.eventAlias + '-after-reload-association-data',
me.eventAlias + '-after-reload-data',
me.eventAlias + '-before-load-lazy-loading-component',
me.eventAlias + '-after-load-lazy-loading-component'
);
},
createItems: function() {
var me = this, items = [], item, config,
associations, fields, field, keys;
if (!me.fireEvent(me.eventAlias + '-before-create-items', me, items)) {
return false;
}
Ext.each(me.getConfig('fieldSets'), function(fieldSet) {
if (Ext.isFunction(fieldSet)) {
item = fieldSet.call(this, items, me.record.$className);
if (item) items.push(item);
return true;
}
fields = [];
keys = [];
if (Object.keys(fieldSet.fields).length > 0) {
keys = Object.keys(fieldSet.fields);
} else if (me.getConfig('fieldSets').length <= 1) {
keys = me.record.fields.keys;
}
Ext.each(keys, function(key) {
config = fieldSet.fields[key] || {};
field = me.createModelField(
me.record,
me.getFieldByName(me.record.fields.items, key),
me.getConfig('fieldAlias'),
config
);
if (field) fields.push(field);
});
item = me.createModelFieldSet(me.record.$className, fields, fieldSet);
items.push(item);
});
associations = me.getAssociations(
me.record.$className,
{ associationKey: me.getConfig('associations') }
);
Ext.each(associations, function(association) {
item = me.createAssociationComponent(
me.getComponentTypeOfAssociation(association),
Ext.create(association.associatedName),
me.getAssociationStore(me.record, association),
association,
me.record
);
if(item) {
items.push(item);
me.associationComponents[association.associationKey] = item;
}
});
me.fireEvent(me.eventAlias + '-after-create-items', me, items);
return items;
},
createAssociationComponent: function(type, model, store, association, baseRecord) {
var me = this, component = { };
if (!(model instanceof Shopware.data.Model)) {
me.throwException(model.$className + ' has to be an instance of Shopware.data.Model');
}
if (baseRecord && !(baseRecord instanceof Shopware.data.Model)) {
me.throwException(baseRecord.$className + ' has to be an instance of Shopware.data.Model');
}
var componentType = model.getConfig(type);
if (!me.fireEvent(me.eventAlias + '-before-association-component-created', me, component, type, model, store)) {
return component;
}
component = Ext.create(componentType, {
record: model,
store: store,
flex: 1,
subApp: me.subApp,
association: association,
configure: function() {
var config = { };
if (association) {
config.associationKey = association.associationKey;
}
if (baseRecord && baseRecord.getConfig('controller')) {
config.controller = baseRecord.getConfig('controller');
}
return config;
}
});
component.on('viewready', function() {
if (me.isLazyLoadingComponent(component)) {
if (!(me.fireEvent(me.eventAlias + '-before-load-lazy-loading-component', me, component))) {
return true;
}
component.getStore().load({
callback: function(records, operation) {
me.fireEvent(me.eventAlias + '-after-load-lazy-loading-component', me, component, records, operation);
}
});
}
});
me.fireEvent(me.eventAlias + '-after-association-component-created', me, component, type, model, store);
return component;
},
createModelFieldSet: function (modelName, fields, customConfig) {
var me = this, fieldSet = null,
title = me.getModelName(modelName),
model = Ext.create(modelName), items = [], container;
customConfig = customConfig || {};
if (customConfig.title) title = customConfig.title;
if (!me.fireEvent(me.eventAlias + '-before-model-field-set-created', me, fieldSet, items, model)) {
return fieldSet;
}
container = Ext.create('Ext.container.Container', {
columnWidth: 0.5,
padding: '0 20 0 0',
layout: 'anchor',
items: fields.slice(0, Math.round(fields.length / 2))
});
items.push(container);
container = Ext.create('Ext.container.Container', {
columnWidth: 0.5,
layout: 'anchor',
items: fields.slice(Math.round(fields.length / 2))
});
items.push(container);
me.fireEvent(me.eventAlias + '-column-containers-created', me, fields, items, model);
fieldSet = Ext.create('Ext.form.FieldSet', {
flex: 1,
padding: '10 20',
layout: 'column',
items: items,
title: title
});
fieldSet = Ext.apply(fieldSet, customConfig);
me.fireEvent(me.eventAlias + '-after-model-field-set-created', me, fieldSet, model);
return fieldSet;
},
createModelField: function (model, field, alias, customConfig) {
var me = this, formField = {}, fieldModel, fieldComponent, xtype;
if (!me.fireEvent(me.eventAlias + '-before-create-model-field', me, formField, model, field, alias)) {
return formField;
}
if (model.idProperty === field.name) {
return null;
}
formField.xtype = 'displayfield';
formField.anchor = '100%';
formField.margin = '0 3 7 0';
formField.labelWidth = 130;
formField.name = field.name;
if (alias !== undefined && Ext.isString(alias) && alias.length > 0) {
formField.name = alias + '[' + field.name + ']';
}
formField.fieldLabel = me.getHumanReadableWord(field.name);
var fieldAssociation = me.getFieldAssociation(field.name);
if (fieldAssociation === undefined) {
switch (field.type.type) {
case 'int':
formField = me.applyIntegerFieldConfig(formField);
break;
case 'string':
formField = me.applyStringFieldConfig(formField);
break;
case 'bool':
formField = me.applyBooleanFieldConfig(formField);
break;
case 'date':
formField = me.applyDateFieldConfig(formField);
break;
case 'float':
formField = me.applyFloatFieldConfig(formField);
break;
}
} else {
fieldModel = Ext.create(fieldAssociation.associatedName);
fieldComponent = fieldModel.getConfig('field');
xtype = Ext.ClassManager.getAliasesByName(fieldComponent);
formField.xtype = xtype[0].replace('widget.', '');
formField.subApp = me.subApp;
if (fieldComponent === 'Shopware.form.field.Search') {
formField.store = me.createAssociationSearchStore(
fieldAssociation.associatedName,
fieldAssociation.associationKey,
me.getConfig('searchUrl')
).load();
}
me.fireEvent(me.eventAlias + '-association-field-created', model, formField, field, fieldAssociation);
}
if (Ext.isString(customConfig)) customConfig = { fieldLabel: customConfig };
customConfig = customConfig || {};
if (Ext.isObject(customConfig)) {
formField = Ext.apply(formField, customConfig);
} else if (Ext.isFunction(customConfig)) {
formField = customConfig.call(this, model, formField, field, fieldAssociation);
}
me.fireEvent(me.eventAlias + '-model-field-created', model, formField, field, fieldAssociation);
return formField;
},
getFieldAssociation: function(fieldName) {
var me = this, fieldAssociation = undefined;
Ext.each(me.fieldAssociations, function(association) {
if (association.field === fieldName) {
fieldAssociation = association;
return false;
}
});
return fieldAssociation;
},
reloadData: function(store, record) {
var me = this, association, component, associationStore;
if (!me.fireEvent(me.eventAlias + '-before-reload-data', me, store, record)) {
return false;
}
Object.keys(me.associationComponents).forEach(function(key) {
component = me.associationComponents[key];
if (component && typeof component.reloadData === 'function') {
association = me.getAssociations(
record.$className,
[ { associationKey: [ key ] } ]
);
associationStore = me.getAssociationStore(
record,
association[0]
);
if (!me.fireEvent(me.eventAlias + '-before-reload-association-data', me, store, record, component, association, associationStore)) {
return true;
}
component.reloadData(
associationStore,
record
);
me.fireEvent(me.eventAlias + '-after-reload-association-data', me, store, record, component, association, associationStore);
}
});
me.fireEvent(me.eventAlias + '-after-reload-data', me, store, record);
}
});
Ext.define('Shopware.form.field.Search', {
extend: 'Ext.form.field.ComboBox',
alias: 'widget.shopware-form-field-search',
queryMode: 'remote',
valueField: 'id',
displayField: 'name',
minChars: 2,
store: undefined,
statics: {
displayConfig: {
listTemplate: false
},
getDisplayConfig: function (userOpts, definition) {
var config = { };
if (userOpts && typeof userOpts.configure == 'function') {
config = Ext.apply({ }, config, userOpts.configure());
}
if (definition && typeof definition.configure === 'function') {
config = Ext.apply({ }, config, definition.configure());
}
config = Ext.apply({ }, config, this.displayConfig);
return config;
},
setDisplayConfig: function (prop, val) {
var me = this;
val = val || '';
if (!me.displayConfig.hasOwnProperty(prop)) {
return false;
}
me.displayConfig[prop] = val;
return true;
}
},
configure: function() {
return { };
},
getConfig: function (prop) {
var me = this;
return me._opts[prop];
},
constructor: function (opts) {
var me = this;
me._opts = me.statics().getDisplayConfig(opts, this);
me.callParent(arguments);
},
initComponent: function() {
var me = this;
if (me.getConfig('listTemplate')) {
me.listConfig = me.createSearchComboListConfig();
}
me.callParent(arguments);
},
createSearchComboListConfig: function () {
return {
getInnerTpl: [
'' +
'' +
'{name}
' +
'' +
'
{[Ext.util.Format.ellipsis(values.description, 150)]}' +
'' +
'' +
''
].join()
}
}
});
Ext.define('Shopware.detail.Controller', {
extend: 'Enlight.app.Controller',
mixins: {
helper: 'Shopware.model.Helper'
},
statics: {
displayConfig: {
detailWindow: undefined,
eventAlias: undefined,
saveSuccessTitle: 'Erfolgreich',
saveSuccessMessage: 'Eintrag wurde erfolgreich gespeichert',
violationErrorTitle: 'Validierung Fehler',
invalidFormTitle: 'Formularvalidierungs Fehler',
invalidFormMessage: 'Das Formular beinhaltet invalidate Daten, bitte prüfen Sie ihre Eingabe.',
},
getDisplayConfig: function (userOpts, definition) {
var config = { };
if (userOpts && typeof userOpts.configure == 'function') {
config = Ext.apply({ }, config, userOpts.configure());
}
if (definition && typeof definition.configure === 'function') {
config = Ext.apply({ }, config, definition.configure());
}
config = Ext.apply({ }, config, this.displayConfig);
return config;
},
setDisplayConfig: function (prop, val) {
var me = this;
if (!me.displayConfig.hasOwnProperty(prop)) {
return false;
}
me.displayConfig[prop] = val;
return true;
}
},
configure: function() {
return { };
},
constructor: function (opts) {
var me = this;
me._opts = me.statics().getDisplayConfig(opts, this);
me.callParent(arguments);
},
getConfig: function (prop) {
var me = this;
return me._opts[prop];
},
init: function () {
var me = this;
if (me.$className !== 'Shopware.detail.Controller') {
me.checkRequirements();
}
if (me.getConfig('eventAlias') && me.getConfig('detailWindow')) {
me.registerEvents();
me.control(me.createControls());
}
me.callParent(arguments);
},
checkRequirements: function() {
var me = this;
if (!me.getConfig('eventAlias')) {
me.throwException(me.$className + ": Component requires the `eventAlias` property in the configure() function");
}
if (!me.getConfig('detailWindow')) {
me.throwException(me.$className + ": Component requires the `detailWindow` property in the configure() function");
}
},
reloadControls: function() {
var me = this;
me.checkRequirements();
me.registerEvents();
me.control(me.createControls());
},
registerEvents: function() {
var me = this;
me.addEvents(
me.getEventName('start-save-record'),
me.getEventName('update-record-on-save'),
me.getEventName('after-update-record-on-save'),
me.getEventName('save-exception'),
me.getEventName('before-send-save-request'),
me.getEventName('save-successfully')
);
},
createControls: function () {
var me = this, alias, controls = {};
alias = Ext.ClassManager.getAliasesByName(me.getConfig('detailWindow'));
if (!alias || alias.length <= 0) {
return false;
}
alias = alias[0];
alias = alias.replace('widget.', '');
controls[alias] = me.createDetailWindowControls();
return controls;
},
createDetailWindowControls: function() {
var me = this, events = {};
events[me.getEventName('save')] = me.onSave;
return events;
},
onSave: function(window, record) {
var me = this, proxy = record.getProxy(), data, form = window.formPanel;
if (!form.getForm().isValid()) {
Shopware.Notification.createGrowlMessage(
me.getConfig('invalidFormTitle'),
me.getConfig('invalidFormMessage')
);
return false;
}
if (!Shopware.app.Application.fireEvent(me.getEventName('start-save-record'), me, window, record, form)) {
return false;
}
if (Shopware.app.Application.fireEvent(me.getEventName('update-record-on-save'), me, window, record, form)) {
form.getForm().updateRecord(record);
}
Shopware.app.Application.fireEvent(me.getEventName('after-update-record-on-save'), me, window, record, form);
proxy.on('exception', function (proxy, response) {
window.setLoading(false);
data = Ext.decode(response.responseText);
Shopware.app.Application.fireEvent(me.getEventName('save-exception'), me, data, window, record, form);
if (data.violations && data.violations.length > 0) {
me.createViolationMessage(data.violations);
me.markFieldsAsInvalid(window, data.violations);
}
}, me, { single: true });
window.setLoading(true);
if (!Shopware.app.Application.fireEvent(me.getEventName('before-send-save-request'), me, window, record, form)) {
return false;
}
record.save({
success: function(result) {
window.setLoading(false);
Shopware.app.Application.fireEvent(me.getEventName('save-successfully'), me, result, window, record, form);
Shopware.Notification.createGrowlMessage(
me.getConfig('saveSuccessTitle'),
me.getConfig('saveSuccessMessage')
);
window.loadRecord(result);
}
});
},
createViolationMessage: function(violations) {
var me = this,
template = '';
Ext.each(violations, function(violation) {
template += '' + violation.property + ': ' + violation.message + '';
});
template = '';
Shopware.Notification.createStickyGrowlMessage({
title: me.getConfig('violationErrorTitle'),
text: template,
width: 400
});
},
markFieldsAsInvalid: function(window, violations) {
var me = this;
Ext.each(violations, function(violation) {
var field = me.getFieldByName(window.formPanel.getForm().getFields().items, violation.property);
if (field) {
field.focus();
field.markInvalid(violation.message);
}
});
},
getEventName: function (name) {
return this.getConfig('eventAlias') + '-' + name;
}
});
Ext.define('Shopware.listing.InfoPanel', {
extend: 'Ext.panel.Panel',
alias: 'widget.shopware-listing-info-panel',
mixins: {
helper: 'Shopware.model.Helper'
},
region: 'east',
width: 200,
cls: 'detail-view',
collapsible: true,
layout: 'fit',
infoView: undefined,
listingWindow: undefined,
gridPanel: undefined,
title: 'Detail Informationen',
statics: {
displayConfig: {
model: undefined,
fields: { },
emptyText: 'Kein Eintrag selektiert.'
},
getDisplayConfig: function (userOpts, definition) {
var config = { };
if (userOpts && typeof userOpts.configure == 'function') {
config = Ext.apply({ }, config, userOpts.configure());
}
if (definition && typeof definition.configure === 'function') {
config = Ext.apply({ }, config, definition.configure());
}
config = Ext.apply({ }, config, this.displayConfig);
return config;
},
setDisplayConfig: function (prop, val) {
var me = this;
if (!me.displayConfig.hasOwnProperty(prop)) {
return false;
}
me.displayConfig[prop] = val;
return true;
}
},
configure: function() {
return { };
},
constructor: function (opts) {
var me = this;
me._opts = me.statics().getDisplayConfig(opts, this);
me.callParent(arguments);
},
getConfig: function (prop) {
var me = this;
return me._opts[prop];
},
initComponent: function() {
var me = this;
me.checkRequirements();
me.gridPanel = me.listingWindow.gridPanel;
me.items = me.createItems();
me.addEventListeners();
me.callParent(arguments);
},
checkRequirements: function() {
var me = this;
if (!(me.listingWindow instanceof Ext.window.Window)) {
me.throwException(me.$className + ": Component requires a passed listingWindow property which contains the instance of the assigned Shopware.window.Listing");
}
if (!(me.listingWindow.gridPanel instanceof Shopware.grid.Panel)) {
me.throwException(me.$className + ": The listingWindow.gridPanel property contains no Shopware.grid.Panel instance.");
}
if (me.alias.length <= 0) {
me.throwException(me.$className + ": Component requires a configured Ext JS widget alias.");
}
if (me.alias.length === 1 && me.alias[0] === 'widget.shopware-listing-info-panel') {
me.throwException(me.$className + ": Component requires a configured Ext JS widget alias.");
}
},
addEventListeners: function() {
var me = this;
me.gridPanel.on(me.gridPanel.eventAlias + '-selection-changed', function(grid, selModel, records) {
var record = { };
if (records.length > 0) {
record = records.shift();
}
me.updateInfoView(record);
});
},
createItems: function() {
var me = this, items = [];
items.push(me.createInfoView());
return items;
},
createInfoView: function(){
var me = this;
me.infoView = Ext.create('Ext.view.View', {
tpl: me.createTemplate(),
flex: 1,
autoScroll: true,
padding: 5,
style: 'color: #6c818f;font-size:11px',
emptyText: '' + me.getConfig('emptyText') + '
',
deferEmptyText: false,
itemSelector: 'div.item',
renderData: []
});
return me.infoView;
},
createTemplate: function() {
var me = this, fields = [], model, keys, field, config,
configFields = me.getConfig('fields');
if (me.getConfig('model')) {
model = Ext.create(me.getConfig('model'));
keys = model.fields.keys;
if (Object.keys(configFields).length > 0) keys = Object.keys(configFields);
Ext.each(keys, function(key) {
field = me.getFieldByName(model.fields.items, key);
config = configFields[key];
if (Ext.isFunction(config)) {
field = config.call(me, me, field);
if (field) fields.push(field);
} else if (Ext.isObject(config) || (Ext.isString(config) && config.length > 0)) {
fields.push(config);
} else {
fields.push(me.createTemplateForField(model, field));
}
});
}
return new Ext.XTemplate(
'',
'',
fields.join(''),
'
',
''
);
},
createTemplateForField: function(model, field) {
var me = this;
return '' + me.getHumanReadableWord(field.name) +': {' + field.name + '}
'
},
updateInfoView: function(record) {
var me = this;
if (record.data) {
me.infoView.update(record.data);
} else {
me.infoView.update(me.infoView.emptyText);
}
return true;
}
});
Ext.define('Shopware.listing.FilterPanel', {
extend: 'Ext.form.Panel',
alias: 'widget.shopware-listing-filter-panel',
mixins: {
helper: 'Shopware.model.Helper',
container: 'Shopware.model.Container'
},
region: 'west',
width: 300,
cls: 'detail-view',
collapsible: true,
layout: 'anchor',
title: 'Filter',
listingWindow: undefined,
gridPanel: undefined,
infoText: undefined,
toolbar: undefined,
filterButton: undefined,
resetButton: undefined,
fieldAssociations: [ ],
statics: {
displayConfig: {
eventAlias: undefined,
controller: undefined,
searchUrl: '/backend/base/searchAssociation',
model: undefined,
fields: { },
infoText: 'Aktivieren Sie der verschiedenen Felder über die davor angezeigte Checkbox. Aktivierte Felder werden mit einer UND Bedingung verknüpft.',
filterButtonText: 'Filter anwenden',
resetButtonText: 'Filter zurücksetzen'
},
getDisplayConfig: function (userOpts, definition) {
var config = { };
if (userOpts && typeof userOpts.configure == 'function') {
config = Ext.apply({ }, config, userOpts.configure());
}
if (definition && typeof definition.configure === 'function') {
config = Ext.apply({ }, config, definition.configure());
}
config = Ext.apply({ }, config, this.displayConfig);
if (config.controller) {
config.searchUrl = config.searchUrl.replace(
'/backend/base/', '/backend/' + config.controller + '/'
);
}
return config;
},
setDisplayConfig: function (prop, val) {
var me = this;
if (!me.displayConfig.hasOwnProperty(prop)) {
return false;
}
me.displayConfig[prop] = val;
return true;
}
},
configure: function() {
return { };
},
constructor: function (opts) {
var me = this;
me._opts = me.statics().getDisplayConfig(opts, this);
me.callParent(arguments);
},
getConfig: function (prop) {
var me = this;
return me._opts[prop];
},
initComponent: function() {
var me = this;
me.checkRequirements();
me.eventAlias = me.getConfig('eventAlias');
if (!me.eventAlias) me.eventAlias = me.getEventAlias(me.getConfig('model'));
me.registerEvents();
me.gridPanel = me.listingWindow.gridPanel;
me.items = me.createItems();
me.dockedItems = me.createDockedItems();
me.callParent(arguments);
},
checkRequirements: function() {
var me = this;
if (!me.getConfig('controller')) {
me.throwException(me.$className + ": Component requires the `controller` property in the configure() function");
}
if (!me.getConfig('model')) {
me.throwException(me.$className + ": Component requires the `model` property in the configure() function");
}
if (me.alias.length <= 0) {
me.throwException(me.$className + ": Component requires a configured Ext JS widget alias.");
}
if (me.alias.length === 1 && me.alias[0] === 'widget.shopware-listing-filter-panel') {
me.throwException(me.$className + ": Component requires a configured Ext JS widget alias.");
}
},
registerEvents: function() {
this.addEvents(
this.eventAlias + '-before-apply-field-filter',
this.eventAlias + '-before-grid-load-filter',
this.eventAlias + '-before-filter-grid',
this.eventAlias + '-after-filter-grid'
);
},
createItems: function() {
var me = this, items = [];
items.push(me.createInfoText());
items.push(me.createFilterFields());
return items;
},
createInfoText: function() {
var me = this;
me.infoText = Ext.create('Ext.container.Container', {
html: me.getConfig('infoText'),
style: 'color: #6c818f; font-size: 11px; line-height: 14px;',
margin: '0 0 10'
});
return me.infoText;
},
createFilterFields: function() {
var me = this, items = [], field, config,
record = Ext.create(me.getConfig('model'));
me.fieldAssociations = me.getAssociations(me.getConfig('model'), [
{ relation: 'ManyToOne' }
]);
var configFields = me.getConfig('fields');
Ext.each(record.fields.items, function(modelField) {
if (Object.keys(configFields).length > 0 && !(configFields.hasOwnProperty(modelField.name))) {
return true;
}
config = configFields[modelField.name];
if (Ext.isString(config)) config = { fieldLabel: config };
field = me.createModelField(record, modelField, undefined, config);
if (!field) return true;
var container = Ext.create('Shopware.filter.Field', {
field: field,
subApp: me.subApp
});
field.container = container;
items.push(container);
});
return Ext.create('Ext.container.Container', {
items: items,
layout: 'anchor',
anchor: '100%',
defaults: {
anchor: '100%'
}
});
},
createDockedItems: function() {
var me = this;
return [
me.createToolbar()
];
},
createToolbar: function() {
var me = this;
me.toolbar = Ext.create('Ext.toolbar.Toolbar', {
items: [ me.createFilterButton(), me.createResetButton() ],
dock: 'bottom'
});
return me.toolbar;
},
createFilterButton: function() {
var me = this;
me.filterButton = Ext.create('Ext.button.Button', {
cls: 'secondary small',
iconCls: 'sprite-funnel',
text: me.getConfig('filterButtonText'),
handler: function() {
me.filterGridStore();
}
});
return me.filterButton;
},
createResetButton: function() {
var me = this;
me.resetButton = Ext.create('Ext.button.Button', {
cls: 'secondary small',
iconCls: 'sprite-funnel--minus',
text: me.getConfig('resetButtonText'),
handler: function() {
me.getForm().reset();
me.gridPanel.getStore().clearFilter(true);
me.gridPanel.getStore().load();
}
});
return me.resetButton;
},
filterGridStore: function() {
var me = this;
if (!me.fireEvent(me.eventAlias + '-before-filter-grid', me, me.gridPanel)) {
return false;
}
me.gridPanel.getStore().clearFilter(true);
me.createFilters();
me.fireEvent(me.eventAlias + '-before-grid-load-filter', me, me.gridPanel);
me.gridPanel.getStore().load({
callback: function(records, operation) {
me.fireEvent(me.eventAlias + '-after-filter-grid', me, me.gridPanel, records, operation);
}
});
},
createFilters: function() {
var me = this,
model = Ext.create(me.getConfig('model')),
values = me.getForm().getValues();
Object.keys(values).forEach(function (key) {
if (me.getFieldByName(model.fields.items, key) === undefined) {
return true;
}
if (!me.fireEvent(me.eventAlias + '-before-apply-field-filter', me, me.gridPanel, key, values[key])) {
return true;
}
me.gridPanel.getStore().filters.add(key,
Ext.create('Ext.util.Filter', {
property: key,
value: values[key]
})
);
});
}
});
Ext.define('Shopware.filter.Field', {
extend: 'Ext.form.FieldContainer',
padding: 10,
layout: {
type: 'hbox',
align: 'stretch'
},
style: 'background: #fff',
mixins: {
helper: 'Shopware.model.Helper'
},
checkbox: undefined,
field: undefined,
statics: {
displayConfig: {
},
getDisplayConfig: function (userOpts, definition) {
var config = { };
if (userOpts && typeof userOpts.configure == 'function') {
config = Ext.apply({ }, config, userOpts.configure());
}
if (definition && typeof definition.configure === 'function') {
config = Ext.apply({ }, config, definition.configure());
}
config = Ext.apply({ }, config, this.displayConfig);
return config;
},
setDisplayConfig: function (prop, val) {
var me = this;
if (!me.displayConfig.hasOwnProperty(prop)) {
return false;
}
me.displayConfig[prop] = val;
return true;
}
},
configure: function() {
return { };
},
constructor: function (opts) {
var me = this;
me._opts = me.statics().getDisplayConfig(opts, this);
me.callParent(arguments);
},
getConfig: function (prop) {
var me = this;
return me._opts[prop];
},
initComponent: function() {
var me = this;
me.checkbox = Ext.create('Ext.form.field.Checkbox', {
width: 28,
margin: '2 0 0 0'
});
me.checkbox.on('change', function(checkbox, value) {
var field = me.items.items[1];
if (!field) return false;
if (value) {
field.enable();
} else {
field.disable()
}
});
me.field.flex = 1;
me.field.labelWidth = 100;
me.field.disabled = true;
me.field.margin = 0;
me.items = [
me.checkbox,
me.field
];
me.callParent(arguments);
}
});
Ext.define('Shopware.store.Association', {
extend: 'Ext.data.Store',
mixins: {
helper: 'Shopware.model.Helper'
},
autoLoad: false,
batch: true,
remoteSort: true,
remoteFilter: true,
pageSize: 20,
statics: {
displayConfig: {
controller: undefined,
searchUrl: '/backend/base/reloadAssociation'
},
getDisplayConfig: function (userOpts, definition) {
var config = { };
if (userOpts && typeof userOpts.configure == 'function') {
config = Ext.apply({ }, config, userOpts.configure());
}
if (definition && typeof definition.configure === 'function') {
config = Ext.apply({ }, config, definition.configure());
}
config = Ext.apply({ }, config, this.displayConfig);
if (config.controller) {
config.searchUrl = config.searchUrl.replace(
'/backend/base/', '/backend/' + config.controller + '/'
);
}
return config;
},
setDisplayConfig: function (prop, val) {
var me = this;
if (!me.displayConfig.hasOwnProperty(prop)) {
return false;
}
me.displayConfig[prop] = val;
return true;
}
},
configure: function() {
return { };
},
getConfig: function (prop) {
var me = this;
return me._opts[prop];
},
constructor: function (config) {
var me = this;
me.association = config.association;
me.extraParams = config.extraParams;
me._opts = me.statics().getDisplayConfig(config, this);
return me.callParent(config);
},
load: function(options) {
var me = this,
operation,
proxy;
me.checkRequirements();
proxy = Ext.create('Ext.data.proxy.Ajax', {
url: me.getConfig('searchUrl'),
extraParams: me.extraParams,
reader: Ext.create('Ext.data.reader.Json', {
root: 'data',
totalProperty: 'total',
model: me.model
})
});
options = Ext.apply({
action: 'read',
filters: me.filters.items,
sorters: me.getSorters()
}, options);
options.page = options.page || me.currentPage;
options.start = (options.start !== undefined) ? options.start : (options.page - 1) * me.pageSize;
options.limit = options.limit || me.pageSize;
me.lastOptions = options;
operation = new Ext.data.Operation(options);
if (me.fireEvent('beforeload', me, operation) !== false) {
me.loading = true;
proxy.read(operation, me.onProxyLoad, me);
}
return me;
},
checkRequirements: function() {
var me = this;
if (!me.getConfig('controller')) {
me.throwException(me.$className + ": Reload not available. Please configure the store `controller` property.");
}
}
});
Ext.define('Shopware.form.field.Media', {
extend: 'Ext.form.FieldContainer',
alias: 'widget.shopware-media-field',
layout: {
type: 'hbox',
align: 'stretch'
},
mixins: [
'Shopware.model.Helper',
'Ext.form.field.Base'
],
height: 115,
mediaPath: '/',
noMedia: '/templates/_default/frontend/_resources/images/no_picture.jpg',
value: undefined,
path: undefined,
mediaId: undefined,
valueField: 'id',
selectButton: undefined,
resetButton: undefined,
preview: undefined,
albumId: undefined,
validTypes: [ ],
record: undefined,
buttonContainer: undefined,
previewContainer: undefined,
statics: {
displayConfig: {
selectButtonText: 'Medium selektieren',
resetButtonText: 'Medium zurücksetzen'
},
getDisplayConfig: function (userOpts, definition) {
var config = { };
if (userOpts && typeof userOpts.configure == 'function') {
config = Ext.apply({ }, config, userOpts.configure());
}
if (definition && typeof definition.configure === 'function') {
config = Ext.apply({ }, config, definition.configure());
}
config = Ext.apply({ }, config, this.displayConfig);
return config;
},
setDisplayConfig: function (prop, val) {
var me = this;
if (!me.displayConfig.hasOwnProperty(prop)) {
return false;
}
me.displayConfig[prop] = val;
return true;
}
},
configure: function() {
return { };
},
constructor: function (opts) {
var me = this;
me._opts = me.statics().getDisplayConfig(opts, this);
me.callParent(arguments);
},
getConfig: function (prop) {
var me = this;
return me._opts[prop];
},
initComponent: function() {
var me = this;
me.items = me.createItems();
me.callParent(arguments);
},
createItems: function() {
var me = this;
return [
me.createButtonContainer(),
me.createPreviewContainer()
];
},
createButtonContainer: function() {
var me = this;
me.buttonContainer = Ext.create('Ext.container.Container', {
width: 180,
padding: '0 10',
style: "background: #fff",
layout: {
type: 'vbox',
align: 'stretch'
},
items: [
me.createSelectButton(),
me.createResetButton()
]
});
return me.buttonContainer;
},
createPreviewContainer: function() {
var me = this;
me.previewContainer = Ext.create('Ext.container.Container', {
flex: 1,
style: "background: #fff",
items: [ me.createPreview() ]
});
return me.previewContainer;
},
createSelectButton: function() {
var me = this;
me.selectButton = Ext.create('Ext.button.Button', {
text: me.getConfig('selectButtonText'),
iconCls: 'sprite-inbox-image',
cls: 'secondary small',
margin: '10 0',
handler: function() {
me.openMediaManager()
}
});
return me.selectButton;
},
createResetButton: function() {
var me = this;
me.resetButton = Ext.create('Ext.button.Button', {
text: me.getConfig('resetButtonText'),
iconCls: 'sprite-inbox--minus',
cls: 'secondary small',
handler: function() {
me.removeMedia();
}
});
return me.resetButton;
},
removeMedia: function() {
var me = this;
me.value = null;
me.path = null;
me.mediaId = null;
me.preview.setSrc(me.noMedia);
},
createPreview: function() {
var me = this;
me.preview = Ext.create('Ext.Img', {
src: me.mediaPath + me.value,
height: 100,
maxHeight: 100,
padding: 5,
margin: 5,
style: "border-radius: 6px; border: 1px solid #c4c4c4;"
});
return me.preview;
},
openMediaManager: function() {
var me = this;
if (!(me.fireEvent('before-open-media-manager', me))) {
return false;
}
Shopware.app.Application.addSubApplication({
name: 'Shopware.apps.MediaManager',
layout: 'small',
eventScope: me,
params: {
albumId: me.albumId
},
mediaSelectionCallback: me.onSelectMedia,
selectionMode: false,
validTypes: me.validTypes || []
});
me.fireEvent('after-open-media-manager', me);
},
onSelectMedia: function(button, window, selection) {
var me = this,
record = selection[0];
if (!(record instanceof Ext.data.Model)) {
return true;
}
me.record = record;
me.path = record.get('path');
me.mediaId = record.get('id');
me.value = record.get(me.valueField);
me.updatePreview(me.path);
window.close();
},
updatePreview: function(image) {
this.preview.setSrc(
this.mediaPath + image
);
},
getValue: function() {
return this.value;
},
setValue: function(value) {
var me = this;
if (value !== me.value) {
me.requestMediaData(value);
}
this.value = value;
this.updatePreview(value);
},
getSubmitData: function() {
var value = {};
value[this.name] = this.value;
return value;
},
requestMediaData: function(value) {
var me = this, params = {};
params[me.valueField] = value;
Ext.Ajax.request({
url: '/backend/mediaManager/getMedia',
method: 'POST',
params: params,
success: function(response) {
var operation = Ext.decode(response.responseText);
if (operation.success == true) {
me.record = Ext.create('Shopware.apps.Base.model.Media', operation.data);
me.mediaId = me.record.get('id');
me.path = me.record.get('path');
me.updatePreview(me.path);
}
}
});
}
});
Ext.define('Shopware.apps.Base.model.User', {
alternateClassName:'Shopware.model.User',
extend:'Shopware.data.Model',
idProperty:'id',
fields:[
{ name:'id', type:'int' },
{ name:'roleId', type:'int' },
{ name:'username', type:'string' },
{ name:'password', type:'string' },
{ name:'localeId', type:'int' },
{ name:'sessionId', type:'string' },
{ name:'lastLogin', type:'date' },
{ name:'name', type:'string' },
{ name:'email', type:'string' },
{ name:'active', type:'int' },
{ name:'admin', type:'int' },
{ name:'salted', type:'int' },
{ name:'failedLogins', type:'int' },
{ name:'lockedUntil', type:'date' }
]
});
Ext.define('Shopware.apps.Base.model.Category', {
alternateClassName: 'Shopware.model.Category',
extend:'Shopware.data.Model',
idProperty:'id',
fields:[
{ name : 'id', type:'int' },
{ name : 'parent', type:'int' },
{ name : 'name', type:'string' },
{ name : 'position', type:'int' },
{ name : 'active', type:'boolean', defaultValue: true },
{ name : 'childrenCount', type: 'int' },
{ name : 'text', type: 'string' },
{ name : 'cls', type: 'string' },
{ name : 'leaf', type: 'boolean' },
{ name : 'allowDrag', type: 'boolean' }
]
});
Ext.define('Shopware.apps.Base.model.CustomerGroup', {
alternateClassName: 'Shopware.model.CustomerGroup',
extend:'Shopware.data.Model',
idProperty:'id',
fields:[
{ name: 'id', type: 'int' },
{ name: 'key', type: 'string' },
{ name: 'name', type: 'string' },
{ name: 'tax', type: 'boolean', defaultValue: true },
{ name: 'taxInput', type: 'boolean', defaultValue: true },
{ name: 'mode', type: 'boolean' },
{ name: 'discount', type: 'float', useNull:true }
]
});
Ext.define('Shopware.apps.Base.model.Dispatch', {
alternateClassName: 'Shopware.model.Dispatch',
extend: 'Shopware.data.Model',
idProperty : 'id',
fields: [
{ name : 'id', type : 'int' },
{ name : 'name', type : 'string' },
{ name : 'type', type : 'int' },
{ name : 'comment', type : 'string' },
{ name : 'active', type : 'int' },
{ name : 'position', type : 'int' }
]
});
Ext.define('Shopware.apps.Base.model.Payment', {
snippets: {
debit: 'Lastschrift',
cash: 'Nachnahme',
invoice: 'Rechnung',
prepayment: 'Vorkasse',
paypalexpress: 'PayPal'
},
alternateClassName: 'Shopware.model.Payment',
extend:'Shopware.data.Model',
idProperty:'id',
fields:[
{ name:'id', type: 'int' },
{ name:'name', type: 'string' },
{
name:'description',
type: 'string',
convert: function(value, record) {
var snippet = value;
if (record && record.snippets) {
snippet = record.snippets[record.get('name')];
}
if (Ext.isString(snippet) && snippet.length > 0) {
return snippet;
} else {
return value;
}
}
},
{ name:'position', type: 'int' },
{ name:'active', type: 'int' }
]
});
Ext.define('Shopware.apps.Base.model.Shop', {
alternateClassName:'Shopware.model.Shop',
extend:'Shopware.data.Model',
fields:[
{ name:'id', type:'int' },
{ name:'default', type:'boolean' },
{ name:'localeId', type:'int' },
{ name:'categoryId', type:'int' },
{ name:'name', type:'string' }
]
});
Ext.define('Shopware.apps.Base.model.Supplier', {
alternateClassName: 'Shopware.model.Supplier',
extend: 'Shopware.data.Model',
idProperty : 'id',
fields: [
{ name : 'id', type : 'int' },
{ name : 'name', type : 'string' },
{ name : 'image', type : 'string' },
{ name : 'link', type : 'string' },
{ name : 'description', type : 'string' }
]
});
Ext.define('Shopware.apps.Base.model.Country', {
alternateClassName: 'Shopware.model.Country',
extend:'Shopware.data.Model',
idProperty:'id',
fields:[
{ name: 'id', type: 'int' },
{ name: 'name', type: 'string' },
{ name: 'iso', type: 'string' },
{ name: 'isoName', type: 'string' },
{ name: 'position', type: 'int' },
{ name: 'active', type: 'boolean' }
]
});
Ext.define('Shopware.apps.Base.model.Article', {
alternateClassName:'Shopware.model.Article',
extend:'Shopware.data.Model',
idProperty:'id',
fields:[
{ name:'id', type:'int' },
{ name:'number', type:'string' },
{ name:'name', type:'string' },
{ name:'description', type:'string' },
{ name:'supplierName', type:'string' },
{ name:'supplierId', type:'int' },
{ name:'active', type:'int' },
{ name:'detailId', type:'int' },
{ name:'changeTime', type:'date' },
{ name:'inStock', type:'int' }
]
});
Ext.define('Shopware.apps.Base.model.Locale', {
alternateClassName: ['Shopware.model.Locales', 'Shopware.model.Locale'],
extend: 'Shopware.data.Model',
idProperty : 'id',
fields: [
{ name : 'id', type : 'int' },
{ name: 'name', type: 'string', convert: function(v, record) {
return record.data.language + ' (' + record.data.territory + ')';
} },
{ name: 'language', type : 'string' },
{ name: 'territory', type : 'string' },
{ name: 'locale', type : 'string' }
]
});
Ext.define('Shopware.apps.Base.model.Currency', {
alternateClassName: 'Shopware.model.Currency',
extend: 'Shopware.data.Model',
idProperty : 'id',
fields: [
{ name : 'id', type : 'int' },
{ name : 'name', type : 'string' },
{ name : 'currency', type : 'string' }
]
});
Ext.define('Shopware.apps.Base.model.PaymentStatus', {
snippets: {
state9: 'Teilweise in Rechnung gestellt',
state10: 'Komplett in Rechnung gestellt',
state11: 'Teilweise bezahlt',
state12: 'Komplett bezahlt',
state13: '1. Mahnung',
state14: '2. Mahnung',
state15: '3. Mahnung',
state16: 'Inkasso',
state17: 'Offen',
state18: 'Reserviert',
state19: 'Verzoegert',
state20: 'Wiedergutschrift',
state21: 'Überprüfung notwendig',
state30: 'Es wurde kein Kredit genehmigt',
state31: 'Der Kredit wurde vorlaeufig akzeptiert',
state32: 'Der Kredit wurde genehmigt',
state33: 'Die Zahlung wurde von der Hanseatic Bank angewiesen',
state34: 'Es wurde eine Zeitverlaengerung eingetragen',
state35: 'Vorgang wurde abgebrochen'
},
alternateClassName: 'Shopware.model.PaymentStatus',
extend:'Shopware.data.Model',
idProperty:'id',
fields:[
{ name:'id', type: 'int' },
{
name:'description',
type: 'string',
convert: function(value, record) {
var snippet = value;
if (record && record.snippets) {
snippet = record.snippets['state' + record.get('id')];
}
if (Ext.isString(snippet) && snippet.length > 0) {
return snippet;
} else {
return value;
}
}
}
]
});
Ext.define('Shopware.apps.Base.model.OrderStatus', {
snippets: {
state0: 'Abgebrochen',
state1: 'Offen',
state2: 'In Bearbeitung (Wartet)',
state3: 'Komplett abgeschlossen',
state4: 'Teilweise abgeschlossen',
state5: 'Storniert / Abgelehnt',
state6: 'Zur Lieferung bereit',
state7: 'Teilweise ausgeliefert',
state8: 'Komplett ausgeliefert',
state9: 'Klärung notwendig'
},
alternateClassName: 'Shopware.model.OrderStatus',
extend:'Shopware.data.Model',
idProperty:'id',
fields:[
{ name:'id', type: 'int' },
{
name:'description',
type: 'string',
convert: function(value, record) {
var snippet = value;
var internalId = record.get('id') + 1;
if (record && record.snippets) {
snippet = record.snippets['state' + internalId];
}
if (Ext.isString(snippet) && snippet.length > 0) {
return snippet;
} else {
return value;
}
}
}
]
});
Ext.define('Shopware.apps.Base.model.Address', {
alternateClassName: 'Shopware.model.Address',
extend:'Shopware.data.Model',
fields:[
{ name:'salutation', type:'string' },
{ name:'company', type:'string' },
{ name:'department', type:'string' },
{ name:'firstName', type:'string' },
{ name:'lastName', type:'string' },
{ name:'street', type:'string' },
{ name:'streetNumber', type:'string' },
{ name:'zipCode', type:'string' },
{ name:'city', type:'string' },
{ name:'countryId', type:'int', useNull: true }
]
});
Ext.define('Shopware.apps.Base.model.BillingAddress', {
alternateClassName: 'Shopware.model.BillingAddress',
extend:'Shopware.apps.Base.model.Address',
fields:[
{ name:'number', type:'string' },
{ name:'phone', type:'string' },
{ name:'fax', type:'string' },
{ name:'vatId', type:'string' }
]
});
Ext.define('Shopware.apps.Base.model.Customer', {
alternateClassName: 'Shopware.model.Customer',
extend:'Shopware.data.Model',
fields:[
{ name:'id', type:'int' },
{ name:'groupKey', type:'string' },
{ name:'email', type:'string' },
{ name:'active', type:'boolean' },
{ name:'accountMode', type:'int' },
{ name:'confirmationKey', type:'string' },
{ name:'paymentId', type:'int', useNull: true },
{ name:'firstLogin', type:'date' },
{ name:'lastLogin', type:'date' },
{ name:'newsletter', type:'int' },
{ name:'validation', type:'int' },
{ name:'languageId', type:'int' },
{ name:'shopId', type:'int', useNull: true },
{ name:'priceGroupId', type:'int' },
{ name:'internalComment', type:'string' },
{ name:'failedLogins', type:'int' },
{ name:'referer', type:'string' }
]
});
Ext.define('Shopware.apps.Base.model.Tax', {
alternateClassName:'Shopware.model.Tax',
extend : 'Shopware.data.Model',
idProperty:'id',
fields : [
{ name : 'id', type: 'integer' },
{ name : 'tax',type: 'float' },
{ name : 'name',type: 'string' }
]
});
Ext.define('Shopware.apps.Base.model.Media', {
extend: 'Shopware.data.Model',
configure: function() {
return {
field: 'Shopware.form.field.Media'
};
},
fields: [
'created',
'description',
'extension',
'id',
'name',
'type',
'path',
'userId',
'width',
'height',
'albumId'
]
});
Ext.define('Shopware.apps.Base.model.Template', {
alternateClassName: 'Shopware.model.Template',
extend: 'Ext.data.Model',
idProperty : 'id',
fields: [
{ name: 'id', type : 'int' },
{ name: 'name', type: 'string' },
{ name: 'template', type : 'string' }
]
});
Ext.define('Shopware.apps.Base.model.CountryArea', {
extend: 'Shopware.data.Model',
fields: [
{ name: 'id', type:'int' },
{ name: 'name', type: 'string', convert: function(v) {
return v.charAt(0).toUpperCase() + v.substr(1);
} },
{ name: 'active', type: 'boolean' }
]
});
Ext.define('Shopware.apps.Base.model.CountryState', {
extend: 'Shopware.data.Model',
fields: [
{ name: 'id', type: 'int' },
{ name: 'countryId', type: 'int' },
{ name: 'name', type: 'string' },
{ name: 'shortCode', type: 'string' },
{ name: 'position', type: 'int' },
{ name: 'active', type: 'boolean' }
]
});
Ext.define('Shopware.apps.Base.model.Form', {
extend: 'Ext.data.Model',
alternateClassName: 'Shopware.model.Form',
fields: [
{ name: 'id', type: 'int', useNull: true },
{ name: 'label', type: 'string' },
{ name: 'name', type: 'string' },
{ name: 'description', type: 'string' }
],
associations: [{
type: 'hasMany', model: 'Shopware.apps.Base.model.Element',
name: 'getElements', associationKey: 'elements'
}]
});
Ext.define('Shopware.apps.Base.model.Element', {
extend: 'Ext.data.Model',
alternateClassName: 'Shopware.model.Element',
fields: [
{ name: 'id', type: 'int', useNull: true },
{ name: 'name', type: 'string' },
{ name: 'value' },
{ name: 'label', type: 'string' },
{ name: 'description', type: 'string', useNull: true },
{ name: 'type', type: 'string', useNull: true },
{ name: 'required', type: 'boolean' },
{ name: 'scope', type: 'int' },
'options'
],
associations: [{
type: 'hasMany',
model: 'Shopware.apps.Base.model.Value',
name: 'getValues',
associationKey: 'values'
}]
});
Ext.define('Shopware.apps.Base.model.Value', {
extend: 'Ext.data.Model',
alternateClassName: 'Shopware.model.Value',
fields: [
{ name: 'id', type: 'int', useNull: true },
{ name: 'shopId', type: 'int' },
{ name: 'value', defaultValue: null, useNull: true }
]
});
Ext.define('Shopware.apps.Base.model.PositionStatus', {
snippets: {
state0: 'Offen',
state1: 'In Bearbeitung (Wartet)',
state2: 'Abgebrochen',
state3: 'Komplett abgeschlossen'
},
alternateClassName: 'Shopware.model.PositionStatus',
extend:'Shopware.data.Model',
fields:[
{ name:'id', type: 'int' },
{
name:'description',
type: 'string',
convert: function(value, record) {
var snippet = value;
if (record && record.snippets) {
snippet = record.snippets['state' + record.get('id')];
}
if (Ext.isString(snippet) && snippet.length > 0) {
return snippet;
} else {
return value;
}
}
}
]
});
Ext.define('Shopware.apps.Base.model.DocType', {
snippets: {
type1: 'Rechnung',
type2: 'Lieferschein',
type3: 'Gutschrift',
type4: 'Stornorechnung'
},
extend:'Ext.data.Model',
fields:[
{ name: 'id', type: 'int' },
{
name:'name',
type: 'string',
convert: function(value, record) {
var snippet = value;
var internalId = 'type' + record.get('id');
if (record && record.snippets) {
snippet = record.snippets[internalId];
}
if (Ext.isString(snippet) && snippet.length > 0) {
return snippet;
} else {
return value;
}
}
},
{ name: 'template', type: 'string' },
{ name: 'numbers', type: 'string' },
{ name: 'left', type: 'int' },
{ name: 'right', type: 'int' },
{ name: 'top', type: 'int' },
{ name: 'bottom', type: 'int' },
{ name: 'pageBreak', type: 'int' }
]
});
Ext.define('Shopware.apps.Base.model.PasswordEncoder', {
alternateClassName: 'Shopware.model.PasswordEncoder',
extend:'Ext.data.Model',
fields:[
{ name:'id', type:'string' }
]
});
Ext.define('Shopware.apps.Base.store.User', {
alternateClassName: 'Shopware.store.User',
extend: 'Ext.data.Store',
storeId: 'base.User',
pageSize: 10,
autoLoad: false,
remoteSort: true,
remoteFilter: true,
model : 'Shopware.apps.Base.model.User',
proxy:{
type:'ajax',
url:'/backend/base/getUsers',
reader:{
type:'json',
root:'data',
totalProperty:'total'
}
}
});
Ext.define('Shopware.apps.Base.store.Category', {
alternateClassName: 'Shopware.store.Category',
extend: 'Ext.data.Store',
storeId: 'base.Category',
remoteSort: true,
remoteFilter: true,
model : 'Shopware.apps.Base.model.Category',
proxy:{
type:'ajax',
url:'/backend/base/getCategories',
reader:{
type:'json',
root:'data',
totalProperty:'total'
}
},
filters: [{
property: 'c.parentId',
value: 1
}]
}).create();
Ext.define('Shopware.apps.Base.store.CategoryTree', {
alternateClassName: 'Shopware.store.CategoryTree',
extend : 'Ext.data.TreeStore',
storeId: 'base.CategoryTree',
autoLoad: false,
model : 'Shopware.apps.Base.model.Category',
proxy : {
type : 'ajax',
api : {
read : '/backend/category/getList'
},
reader : {
type : 'json',
root: 'data'
}
}
}).create();
Ext.define('Shopware.apps.Base.store.CustomerGroup', {
extend: 'Ext.data.Store',
alternateClassName: 'Shopware.store.CustomerGroup',
storeId: 'base.CustomerGroup',
model : 'Shopware.apps.Base.model.CustomerGroup',
pageSize: 1000,
proxy:{
type:'ajax',
url:'/backend/base/getCustomerGroups',
reader:{
type:'json',
root:'data',
totalProperty:'total'
}
}
}).create();
Ext.define('Shopware.apps.Base.store.Dispatch', {
extend: 'Ext.data.Store',
alternateClassName: 'Shopware.store.Dispatch',
storeId: 'base.Dispatch',
model : 'Shopware.apps.Base.model.Dispatch',
pageSize: 1000,
proxy: {
type: 'ajax',
url: '/backend/base/getDispatches',
reader: {
type: 'json',
root: 'data',
totalProperty: 'total'
}
}
}).create();
Ext.define('Shopware.apps.Base.store.Payment', {
extend: 'Ext.data.Store',
alternateClassName: 'Shopware.store.Payment',
storeId: 'base.Payment',
model : 'Shopware.apps.Base.model.Payment',
pageSize: 1000,
proxy:{
type:'ajax',
url:'/backend/base/getPayments',
reader:{
type: 'json',
root: 'data',
totalProperty: 'total'
}
}
}).create();
Ext.define('Shopware.apps.Base.store.Shop', {
extend: 'Ext.data.Store',
alternateClassName: 'Shopware.store.Shop',
storeId: 'base.Shop',
model : 'Shopware.apps.Base.model.Shop',
pageSize: 1000,
remoteSort: true,
remoteFilter: true,
proxy:{
type:'ajax',
url: '/backend/base/getShops',
reader:{
type:'json',
root:'data',
totalProperty:'total'
}
},
filters: [{
property: 'main',
value: null
}]
}).create();
Ext.define('Shopware.apps.Base.store.ShopLanguage', {
extend: 'Shopware.apps.Base.store.Shop',
alternateClassName: 'Shopware.store.ShopLanguage',
storeId: 'base.ShopLanguage',
filters: [ ]
}).create();
Ext.define('Shopware.apps.Base.store.Translation', {
extend: 'Ext.data.Store',
alternateClassName: 'Shopware.store.Translation',
storeId: 'base.Translation',
model : 'Shopware.apps.Base.model.Shop',
pageSize: 1000,
remoteSort: true,
remoteFilter: true,
proxy:{
type:'ajax',
url: '/backend/base/getShops',
reader:{
type:'json',
root:'data',
totalProperty:'total'
}
},
filters: [{
property: 'default',
value: false
}]
}).create();
Ext.define('Shopware.apps.Base.store.Supplier', {
alternateClassName: 'Shopware.store.Supplier',
extend: 'Ext.data.Store',
storeId: 'base.Supplier',
autoLoad: false,
remoteSort: true,
remoteFilter: true,
model : 'Shopware.apps.Base.model.Supplier',
proxy: {
type: 'ajax',
url: '/backend/base/getSuppliers',
reader: {
type: 'json',
root: 'data',
totalProperty: 'total'
}
}
}).create();
Ext.define('Shopware.apps.Base.store.Country', {
extend: 'Ext.data.Store',
alternateClassName: 'Shopware.store.Country',
storeId: 'base.Country',
model : 'Shopware.apps.Base.model.Country',
pageSize: 1000,
proxy:{
type:'ajax',
url:'/backend/base/getCountries',
reader:{
type:'json',
root:'data',
totalProperty:'total'
}
}
}).create();
Ext.define('Shopware.apps.Base.store.Article', {
alternateClassName: 'Shopware.store.Article',
extend: 'Ext.data.Store',
storeId: 'base.Article',
pageSize: 10,
autoLoad: false,
remoteSort: true,
remoteFilter: true,
model : 'Shopware.apps.Base.model.Article',
proxy:{
type:'ajax',
url:'/backend/base/getArticles',
reader:{
type:'json',
root:'data',
totalProperty:'total'
}
}
});
Ext.define('Shopware.apps.Base.store.Locale', {
extend: 'Ext.data.Store',
alternateClassName: [
'Shopware.store.Locale',
'Shopware.store.Locales',
'Shopware.apps.Base.store.Locales'
],
storeId: 'base.Locale',
model : 'Shopware.apps.Base.model.Locale',
pageSize: 1000,
proxy: {
type: 'ajax',
url: '/backend/base/getLocales',
reader: {
type: 'json',
root: 'data',
totalProperty: 'total'
}
}
}).create();
Ext.define('Shopware.apps.Base.store.Currency', {
extend: 'Ext.data.Store',
alternateClassName: [
'Shopware.store.Currency'
],
storeId: 'base.Currency',
model : 'Shopware.apps.Base.model.Currency',
pageSize: 1000,
proxy: {
type: 'ajax',
url: '/backend/base/getCurrencies',
reader: {
type: 'json',
root: 'data',
totalProperty: 'total'
}
}
}).create();
Ext.define('Shopware.apps.Base.store.PaymentStatus', {
extend: 'Ext.data.Store',
alternateClassName: 'Shopware.store.PaymentStatus',
storeId: 'base.PaymentStatus',
model : 'Shopware.apps.Base.model.PaymentStatus',
pageSize: 1000,
autoLoad: false,
proxy:{
type:'ajax',
url:'/backend/base/getPaymentStatus',
reader:{
type: 'json',
root: 'data',
totalProperty: 'total'
}
}
}).create();
Ext.define('Shopware.apps.Base.store.OrderStatus', {
extend: 'Ext.data.Store',
alternateClassName: 'Shopware.store.OrderStatus',
storeId: 'base.OrderStatus',
model : 'Shopware.apps.Base.model.OrderStatus',
pageSize: 1000,
autoLoad: false,
proxy:{
type:'ajax',
url:'/backend/base/getOrderStatus',
reader:{
type: 'json',
root: 'data',
totalProperty: 'total'
}
}
}).create();
Ext.define('Shopware.apps.Base.store.Tax', {
extend : 'Ext.data.Store',
alternateClassName: 'Shopware.store.Tax',
storeId: 'base.Tax',
model : 'Shopware.apps.Base.model.Tax',
pageSize: 1000,
proxy:{
type:'ajax',
url:'/backend/base/getTaxes',
reader:{
type:'json',
root:'data',
totalProperty:'total'
}
}
});
Ext.define('Shopware.apps.Base.store.Template', {
extend: 'Ext.data.Store',
alternateClassName: 'Shopware.store.Template',
storeId: 'base.Template',
model : 'Shopware.apps.Base.model.Template',
pageSize: 1000,
proxy: {
type: 'ajax',
url: '/backend/base/getTemplates',
reader: {
type: 'json',
root: 'data',
totalProperty: 'total'
}
}
}).create();
Ext.define('Shopware.apps.Base.store.CountryArea', {
extend: 'Ext.data.Store',
alternateClassName: 'Shopware.store.CountryArea',
storeId: 'base.CountryArea',
model : 'Shopware.apps.Base.model.CountryArea',
pageSize: 1000,
proxy:{
type:'ajax',
url:'/backend/base/getCountryAreas',
reader:{
type:'json',
root:'data',
totalProperty:'total'
}
}
}).create();
Ext.define('Shopware.apps.Base.store.CountryState', {
extend: 'Ext.data.Store',
alternateClassName: 'Shopware.store.CountryState',
storeId: 'base.CountryState',
model : 'Shopware.apps.Base.model.CountryState',
pageSize: 1000,
proxy:{
type:'ajax',
url:'/backend/base/getCountryStates',
reader:{
type:'json',
root:'data',
totalProperty:'total'
}
}
}).create();
Ext.define('Shopware.apps.Base.store.Form', {
extend: 'Ext.data.Store',
alternateClassName: 'Shopware.store.Form',
storeId: 'base.Form',
model:'Shopware.apps.Base.model.Form',
proxy: {
type: 'ajax',
url: '/backend/config/getForm',
api: {
create: '/backend/config/saveForm',
update: '/backend/config/saveForm',
destroy: '/backend/config/deleteForm'
},
reader: {
type: 'json',
root: 'data'
}
}
});
Ext.define('Shopware.apps.Base.store.PositionStatus', {
extend: 'Ext.data.Store',
autoLoad: false,
model : 'Shopware.apps.Base.model.PositionStatus',
alternateClassName: 'Shopware.store.PositionStatus',
storeId: 'base.PositionStatus',
pageSize: 1000,
proxy:{
type:'ajax',
url:'/backend/base/getDetailStatus',
reader:{
type: 'json',
root: 'data',
totalProperty: 'total'
}
}
});
Ext.define('Shopware.apps.Base.store.PasswordEncoder', {
extend: 'Ext.data.Store',
alternateClassName: 'Shopware.store.PasswordEncoder',
storeId: 'base.PasswordEncoder',
model : 'Shopware.apps.Base.model.PasswordEncoder',
proxy:{
type:'ajax',
url:'/backend/base/getAvailableHashes',
reader:{
type:'json',
root:'data',
totalProperty:'total'
}
}
}).create();
Ext.define('Shopware.button.HoverButton', {
extend: 'Ext.button.Button',
alias: 'widget.hoverbutton',
afterRender: function() {
var me = this;
me.callParent(arguments);
me.getEl().on('mouseover', me.onClick, me);
},
onClick: function(event) {
var me = this;
if (me.preventDefault || (me.disabled && me.getHref()) && event) {
event.preventDefault();
}
if(!me.disabled) {
me.doToggle();
me.maybeShowMenu();
me.fireHandler(event);
}
}
});
Ext.define('Shopware.MediaManager.MediaSelection',
{
extend: 'Ext.form.field.Trigger',
alternateClassName: [ 'Shopware.form.field.MediaSelection', 'Shopware.MediaSelection' ],
alias: [ 'widget.mediafield', 'widget.mediaselectionfield' ],
uses: [ 'Ext.button.Button', 'Ext.Component', 'Ext.layout.component.field.Field' ],
componentLayout: 'triggerfield',
buttonConfig: null,
buttonText: 'Datei(en) auswählen...',
buttonIconCls: 'sprite-inbox-image',
buttonOnly: false,
buttonMargin: 3,
readOnly: true,
multiSelect: true,
albumId: null,
onRender: function() {
var me = this,
inputEl, buttonWrap, mediaButton;
me.callParent(arguments);
me.registerEvents();
if (me.disabled) {
me.disableItems();
}
inputEl = me.inputEl;
if(me.buttonOnly) {
inputEl.setDisplayed(false);
}
buttonWrap = Ext.get(me.id + '-browseButtonWrap');
mediaButton = buttonWrap.down('.' + Ext.baseCSSPrefix + 'form-mediamanager-btn');
buttonWrap.setStyle('width', mediaButton.getWidth() + ((!me.buttonOnly) ? 3 : 0) + 'px');
buttonWrap.on('click', me.onOpenMediaManager, me);
},
registerEvents: function() {
var me = this;
me.addEvents(
'renderMediaManagerButton',
'beforeOpenMediaManager',
'afterOpenMediaManager',
'selectMedia'
);
return true;
},
getRecords: function() {
if(!this.selectedRecords) {
return false;
}
return this.selectedRecords;
},
getRecordsCount: function() {
if(!this.selectedRecords) {
return 0;
}
return this.selectedRecords.length;
},
onOpenMediaManager: function() {
var me = this;
me.fireEvent('beforeOpenMediaManager', me);
Shopware.app.Application.addSubApplication({
name: 'Shopware.apps.MediaManager',
layout: 'small',
eventScope: me,
params: {
albumId: me.albumId
},
mediaSelectionCallback: me.onGetSelection,
selectionMode: me.multiSelect,
validTypes: me.validTypes || []
});
me.fireEvent('afterOpenMediaManager', me);
},
onGetSelection: function(btn) {
var me = this,
win = btn.up('window'),
dataPnl = win.down('.mediamanager-media-view'),
selModel, selected;
if(dataPnl.selectedLayout === 'grid') {
dataPnl = dataPnl.dataView;
} else {
dataPnl = dataPnl.cardContainer.getLayout().getActiveItem();
}
selModel = dataPnl.getSelectionModel();
selected = selModel.getSelection();
me.selectedRecords = selected;
me.fireEvent('selectMedia', me, me.selectedRecords, selModel);
if(me.selectedRecords.length > 1) {
var paths = [];
Ext.each(me.selectedRecords, function(record) {
paths.push(record.get('path'));
});
paths = paths.toString();
me.inputEl.dom.value = paths;
} else {
selected = me.selectedRecords[0];
me.inputEl.dom.value = selected.get('path');
}
win.close();
},
onDestroy: function(){
Ext.destroyMembers(this, 'button');
this.callParent();
},
onEnable: function(){
var me = this;
me.callParent();
},
onDisable: function(){
this.callParent();
this.disableItems();
},
reset : function(){
var me = this;
if (me.rendered) {
me.inputEl.dom.value = '';
}
me.callParent();
},
disableItems: function(){
var button = this.button;
if (button) {
button.disable();
}
},
getTriggerMarkup: function() {
var me = this,
result,
btn = Ext.widget('button', Ext.apply({
preventDefault: false,
cls: Ext.baseCSSPrefix + 'form-mediamanager-btn small secondary',
style: (me.buttonOnly) ? '' : 'margin-left:' + me.buttonMargin + 'px',
text: me.buttonText,
iconCls: me.buttonIconCls
}, me.buttonConfig)),
btnCfg = btn.getRenderTree();
me.fireEvent('renderMediaManagerButton', me, btn);
result = '' + Ext.DomHelper.markup(btnCfg) + ' | ';
btn.destroy();
return result;
}
});
Ext.apply(Ext.form.VTypes, {
password : function(val, field) {
if (field.initialPassField) {
var pwd = Ext.getCmp(field.initialPassField);
return (val == pwd.getValue());
}
return true;
},
passwordText : 'Die eingegebenen Passwörter sind nicht gleich'
});
Ext.apply(Ext.form.field.VTypes, {
missingValidationErrorText: 'The remote vType validation needs a validationErrorMsg property',
remote:function (val, field) {
if (!field.validationUrl) {
return true;
}
if (!field.validationErrorMsg) {
Ext.Error.raise(this.missingValidationErrorText);
return false;
}
if(!field.rendered) {
return true;
}
if(!field.hasOwnProperty('hasBlurListener')) {
field.on('blur', this.onFireRemoteValidation, this);
field.hasBlurListener = true;
}
return (field.hasOwnProperty('oldValid')) ? field.oldValid : true;
},
daterange:function(val, field)
{
var date = field.parseDate(val);
if (!date) {
return false;
}
if (field.startDateField && (!this.dateRangeMax || (date.getTime() != this.dateRangeMax.getTime()))) {
var start = field.up('form').down('#' + field.startDateField);
start.setMaxValue(date);
start.validate();
this.dateRangeMax = date;
}
else if (field.endDateField && (!this.dateRangeMin || (date.getTime() != this.dateRangeMin.getTime()))) {
var end = field.up('form').down('#' + field.endDateField);
end.setMinValue(date);
end.validate();
this.dateRangeMin = date;
}
return true;
},
onFireRemoteValidation: function(field) {
var parameters, val = field.getValue();
if(Ext.isDefined(field.oldValid)) {
if(val == field.oldValue) {
return field.oldValid;
}
}
field.oldValue = val;
if (!field.validationRequestParams){
parameters = {
value:val,
param:field.validationRequestParam
};
} else {
parameters = field.validationRequestParams;
parameters.value = val;
}
Ext.Ajax.request({
async: false,
url:field.validationUrl,
params: parameters,
success:function (response) {
if (!response.responseText) {
field.markInvalid(field.validationErrorMsg);
field.vtypeText = field.validationErrorMsg;
field.oldValid = false;
}
else {
field.clearInvalid();
field.oldValid = true;
}
},
failure:function (response) {
Shopware.Msg.createGrowlMessage('', field.validationErrorMsg, '', 'growl', false);
return false;
}
});
}
});
Ext.define('Shopware.form.field.TinyMCE',
{
extend: 'Ext.form.field.TextArea',
alternateClassName: [ 'Shopware.form.TinyMCE', 'Ext.form.field.TinyMCE' ],
alias: [ 'widget.tinymcefield', 'widget.tinymce' ],
requires: [ 'Ext.form.field.TextArea', 'Ext.XTemplate' ],
uses: [ 'Shopware.MediaManager.MediaSelection' ],
statics: {
initialized: false,
settings: {
cleanup : false,
convert_urls : false,
media_strict : false,
relative_urls : true,
language: Ext.editorLang.substring(0,2),
mode: "textareas",
theme: "advanced",
skin: "o2k7",
invalid_elements:'script,applet',
plugins: "media_selection,fullscreen",
theme_advanced_toolbar_location: "top",
theme_advanced_resizing: true,
theme_advanced_toolbar_align: "left",
theme_advanced_statusbar_location: "bottom",
extended_valid_elements : "font[size],iframe[frameborder|src|width|height|name|align|frameborder|allowfullscreen|id|class|style],script[src|type],object[width|height|classid|codebase|ID|value],param[name|value],embed[name|src|type|wmode|width|height|style|allowScriptAccess|menu|quality|pluginspage],video[autoplay|class|controls|id|lang|loop|onclick|ondblclick|onkeydown|onkeypress|onkeyup|onmousedown|onmousemove|onmouseout|onmouseover|onmouseup|preload|poster|src|style|title|width|height],audio[autoplay|class|controls|id|lang|loop|onclick|ondblclick|onkeydown|onkeypress|onkeyup|onmousedown|onmousemove|onmouseout|onmouseover|onmouseup|preload|src|style|title]",
document_base_url: 'http://www.bautz-shop.de/',
contentCSS: 'http://www.bautz-shop.de/templates/_default/backend/_resources/styles/tiny_mce.css?_dc=' + new Date().getTime(),
skin_variant: 'shopware',
theme_advanced_buttons1: 'undo,redo,|,bold,italic,underline,|,fontsizeselect,forecolor,|,bullist,numlist,|,justifyleft,justifycenter,justifyright,|,link,unlink,media_selection,|,code,fullscreen,',
theme_advanced_buttons2: '',
theme_advanced_buttons3: '',
theme_advanced_buttons4: ''
},
setGlobalSettings: function(userSettings) {
Ext.apply(this.settings, userSettings);
}
},
hasPlaceholder: false,
config: {
editor: { }
},
autoSize: Ext.emptyFn,
noSourceErrorText: "The TinyMCE editor source files aren't included in the project",
initComponent: function() {
var me = this;
me.callParent(arguments);
if(window.tinymce) {
me.statics.initialized = true;
}
me.registerEvents();
},
registerEvents: function() {
var me = this;
me.addEvents(
'beforerendereditor',
'rendereditor',
'afterrendereditor'
);
return true;
},
onRender: function(ct, position) {
var me = this, el;
Ext.applyIf(me.subTplData, {
cols: me.cols,
rows: me.rows
});
me.callParent(arguments);
el = me.inputEl;
el.dom.setAttribute('tabIndex', -1);
el.addCls('x-hidden');
me.initEditor();
me.registerEditorEvents();
},
initEditor: function() {
var me = this, input = me.inputEl, height, placeholder = false;
if(!window.tinyMCE) {
Ext.Error.raise(me.noSourceErrorText);
}
me.config.editor = Ext.Object.merge(this.statics().settings, me.editor);
if(me.height) {
height = me.height - 12;
me.config.editor.height = height;
}
if(me.readOnly) {
me.config.editor.readOnly = true;
}
me.fireEvent('beforerendereditor', me, input.id, me.config.editor);
me.tinymce = new tinymce.Editor(input.id, me.config.editor);
me.fireEvent('rendereditor', me, me.tinymce, input.id, me.config.editor);
me.tinymce.onChange.add(function(ed, values) {
me.setRawValue(values.content);
});
me.tinymce.onInit.add(function(ed, evt) {
var dom = ed.dom,
doc = ed.getDoc(),
el = doc.content_editable ? ed.getBody() : (tinymce.isGecko ? doc : ed.getWin());
if((!me.value || !me.value.length) && me.emptyText && me.emptyText.length) {
me.tinymce.setContent(me.emptyText);
me.hasPlaceholder = true;
tinymce.dom.Event.add(el, 'focus', function() {
var value = me.tinymce.getContent();
value = Ext.util.Format.stripTags(value);
if(value === me.emptyText) {
me.tinymce.setContent('');
}
});
}
tinymce.dom.Event.add(el, 'blur', function() {
var value = me.tinymce.getContent();
me.setRawValue(value);
value = Ext.util.Format.stripTags(value);
if(me.hasPlaceholder && !value.length || (value == me.emptyText)) {
me.tinymce.setContent(me.emptyText);
}
});
});
me.tinymce.render();
me.fireEvent('afterrendereditor', me, me.tinymce, input.id, me.config.editor);
window.setTimeout(function() {
me.changeSniffer = window.setInterval(function() {
var value = me.tinymce.getContent();
me.setRawValue(value);
}, 300);
}, 500);
},
registerEditorEvents: function() {
var me = this;
me.on({
'resize': {
scope: me,
fn: me.onEditorResize
}
})
},
onEditorResize: function(view, width, height) {
var me = this, editor = me.tinymce,
edTable = Ext.get(editor.id + "_tbl"),
edIframe = Ext.get(editor.id + "_ifr"),
edToolbar = Ext.get(editor.id + "_xtbar");
if(!edTable) {
return false;
}
width = (width < 100) ? 100 : (width - 205);
height = (height < 129) ? 129 : (height - 100);
var toolbarWidth = width;
if(edTable) {
toolbarWidth = width - edTable.getFrameWidth( "lr" );
}
var toolbarHeight = 0;
if(edToolbar) {
toolbarHeight = edToolbar.getHeight();
var toolbarTd = edToolbar.findParent( "td", 5, true );
toolbarHeight += toolbarTd.getFrameWidth( "tb" );
edToolbar.setWidth( toolbarWidth );
}
var edStatusbarTd = edTable.child( ".mceStatusbar" );
var statusbarHeight = 0;
if(edStatusbarTd) {
statusbarHeight += edStatusbarTd.getHeight();
}
var iframeHeight = height - toolbarHeight - statusbarHeight;
var iframeTd = edIframe.findParent( "td", 5, true );
if(iframeTd)
iframeHeight -= iframeTd.getFrameWidth( "tb" );
edTable.setSize( width, height );
edIframe.setSize( toolbarWidth, iframeHeight );
},
getEditor: function() {
return this.tinymce;
},
setValue: function(value, editorChange) {
var me = this;
me.callParent(arguments);
if(!me.rendered || !me.statics.initialized) {
return false;
}
if(!editorChange) {
me.setEditorValue(value, me);
if((!value || !value.length) && me.hasPlaceholder) {
me.setEditorValue(me.emptyText, me);
}
}
return me;
},
setRawValue: function(value) {
var me = this;
me.callParent(arguments);
if(!me.rendered || !me.statics.initialized) {
return false;
}
return me;
},
setEditorValue: function(value, scope) {
var me = scope;
if(!me.tinymce) {
return false;
}
if(me.tinymce.undoManager) {
me.tinymce.undoManager.clear();
}
me.tinymce.setContent(value === null || value === undefined ? '' : value);
me.tinymce.startContent = me.tinymce.getContent({ format: 'raw' });
return true;
},
focus: function(selectText, delay) {
var me = this;
if(delay) {
if (!me.focusTask) {
me.focusTask = Ext.create('Ext.util.DelayedTask', me.focus);
}
me.focusTask.delay(Ext.isNumber(delay) ? delay : 10, null, me, [selectText, false]);
return me;
}
me.tinymce.focus();
if(selectText) {
var edIframe = Ext.get(me.tinymce.id + "_ifr"),
dom = edIframe.dom,
doc = dom.contentDocument,
win = dom.contentWindow,
selection = win.getSelection(),
range = doc.createRange();
range.selectNodeContents(doc.body);
selection.removeAllRanges();
selection.addRange(range);
}
return me;
},
destroy: function() {
var me = this;
me.callParent(arguments);
clearInterval(me.changeSniffer);
Ext.destroyMembers(me, 'tinymce');
},
enable: function(slient) {
var me = this;
me.callParent(arguments);
if(!me.tinymce) {
return me;
}
var bodyEl = me.tinymce.getBody();
bodyEl = Ext.get(bodyEl);
if(bodyEl.hasCls('mceNonEditable')) {
bodyEl.removeCls('mceNonEditable');
bodyEl.addCls('mceContentBody');
}
me.tinymce.getBody().setAttribute('contenteditable', true);
return me;
},
disable: function(silent) {
var me = this;
me.callParent(arguments);
if(!me.tinymce) {
return me;
}
var bodyEl = me.tinymce.getBody();
bodyEl = Ext.get(bodyEl);
if(bodyEl.hasCls('mceContentBody')) {
bodyEl.removeCls('mceContentBody');
bodyEl.addCls('mceNonEditable');
}
me.tinymce.getBody().setAttribute('contenteditable', false);
return me;
}
});
Ext.define('Shopware.form.plugin.Translation',
{
extend: 'Ext.AbstractPlugin',
alternateClassName: [ 'Shopware.form.Translation', 'Shopware.plugin.Translation' ],
alias: 'plugin.translation',
translatableFields: [],
translatableFieldsConfig: [],
translationType: 'article',
translationCallback: Ext.emptyFn,
translationKey: null,
icons: [],
uses: [ 'Ext.DomHelper', 'Ext.Element' ],
client: null,
init: function(client) {
var me = this;
me.callParent(arguments);
me.client = client;
me.client.on('afterrender', me.onGetTranslatableFields, me);
me.client.getForm().on('recordchange', me.onGetTranslatableFields, me);
},
clear: function() {
var me = this;
me.translatableFields.length = 0;
Ext.each(this.icons, function(icon) {
icon.removeListener('click');
icon.remove();
});
},
onGetTranslatableFields: function() {
var me = this;
me.clear();
if (!me.translationKey && typeof me.client.getForm().getRecord() === 'undefined') {
return;
}
if (!me.translationKey && me.client.getForm().getRecord().phantom) {
return;
}
Ext.each(me.client.getForm().getFields().items, function(field) {
var config = field.initialConfig;
if(config.translatable) {
if(!config.allowBlank) {
config.allowBlank = true;
}
if(config.translationLabel) {
config.fieldLabel = config.translationLabel;
}
if(config.translationName) {
config.name = config.translationName;
}
if(!config.fieldLabel) {
config.fieldLabel = ' ';
config.labelSeparator = '';
}
if(!field.isDisabled()) {
me.translatableFields.push(field);
}
if(field.getEl()) {
me.createGlobeElement(field);
}
}
});
},
createGlobeElement: function(field) {
var me = this, type, style, globeIcon;
type = me.getFieldType(field);
switch(type) {
case 'tinymce':
style = 'top: 3px; right: 3px';
break;
case 'codemirror':
style = 'top: 6px; right: 26px;z-index:999999';
break;
case 'textarea':
style = 'top: 6px; right: 6px';
break;
case 'trigger':
style = 'top: 6px; right: 26px';
break;
case 'textfield':
default:
style = 'top: 6px; right: 6px; z-index:1;';
break;
}
globeIcon = new Ext.Element(document.createElement('span'));
globeIcon.set({
cls: Ext.baseCSSPrefix + 'translation-globe sprite-globe',
style: 'position: absolute;width: 16px; height: 16px;display:block;cursor:pointer;'+style
});
globeIcon.addListener('click', me.onOpenTranslationWindow, me);
field.getEl().setStyle('position', 'relative');
globeIcon.insertAfter(field.inputEl);
me.icons.push(globeIcon);
},
onOpenTranslationWindow: function() {
var me = this;
if(typeof(Shopware.app.Application.addSubApplication) !== 'function') {
Ext.Error.raise('Your ExtJS application does not support sub applications');
}
var key = me.translationKey || me.client.getForm().getRecord().getId();
me.translatableFieldsConfig = me.getFieldValues(me.translatableFields);
Shopware.app.Application.addSubApplication({
name: 'Shopware.apps.Translation',
eventScope: me,
translationCallback: me.translationCallback,
translatableFields: me.translatableFieldsConfig,
translationType: me.translationType,
translationMerge: me.translationMerge,
translationKey: key
});
},
getFieldValues: function(fields) {
var result = [];
Ext.each(fields, function(field) {
var value = field.getValue(),
config = field.initialConfig;
if(!config.xtype) {
config.xtype = field.xtype;
}
if(value) {
config.emptyText = value;
}
result.push(config)
});
return result;
},
getFieldType: function(field) {
var type;
Ext.each(field.alternateClassName, function(className) {
if(className === 'Ext.form.TextField') {
type = 'textfield';
}
if(className === 'Shopware.form.TinyMCE') {
type = 'tinymce';
}
if(className === 'Shopware.form.CodeMirror') {
type = 'codemirror';
}
if(className === 'Ext.form.TextArea') {
type = 'textarea';
}
if(className === 'Ext.form.TriggerField'
|| className === 'Ext.form.ComboBox'
|| className === 'Ext.form.DateField'
|| className === 'Ext.form.Picker'
|| className === 'Ext.form.Spinner'
|| className === 'Ext.form.TimeField') {
type = 'trigger';
}
});
return type;
},
destroy: function() {
this.callParent(arguments);
}
});
Ext.define('Shopware.grid.HeaderToolTip', {
extend: 'Ext.AbstractPlugin',
alias: 'plugin.headertooltip',
uses: [ 'Ext.tip.ToolTip' ],
client: null,
showIcons: true,
init: function(client) {
var me = this;
me.callParent(arguments);
me.client = client;
me.client.headerCt.on("afterrender", me.onAfterRender, me);
},
onAfterRender: function() {
var me = this;
headerCt = me.client.headerCt;
grid = me.client;
if (me.showIcons) {
me.wrapColumnsWithSpan(headerCt.getGridColumns());
}
grid.tip = me.getToolTip();
grid.tip.on("beforeshow", me.onBeforeShow, me);
},
wrapColumnsWithSpan: function(columns) {
Ext.each(columns, function(column) {
if (column.tooltip) {
var el = column.el;
var tooltipclass = Ext.baseCSSPrefix + "tooltip"
el.update('' + el.dom.innerHTML + '');
}
});
},
getToolTip: function() {
var me = this;
headerCt = me.client.headerCt;
return Ext.create('Ext.tip.ToolTip', {
target: headerCt.el,
delegate: "." + Ext.baseCSSPrefix + "column-header",
trackMouse: true,
renderTo: Ext.getBody()
});
},
onBeforeShow: function(tip) {
var me = this;
headerCt = me.client.headerCt;
var column = headerCt.down('gridcolumn[id=' + tip.triggerElement.id +']');
if (column && column.tooltip) {
tip.update(column.tooltip);
} else {
tip.clearTimers();
return false;
}
},
destroy: function() {
this.client.headerCt.un("afterrender");
this.callParent(arguments);
}
});
Ext.define('Shopware.Notification', {
extend: 'Ext.app.Controller',
singleton: true,
alternateClassName: [ 'Shopware.Messages', 'Shopware.Msg' ],
requires: [ 'Ext.container.Container', 'Ext.panel.Panel', 'Ext.XTemplate' ],
baseMsgType: 'notice',
hideDelay: 1800,
easingType: 'easeIn',
animationDuration: 200,
alertWidth: 350,
alertMsgCls: 'alert-message',
blockMsgCls: 'block-message',
growlMsgCls: 'growl-msg',
growlMsgCollection: Ext.create('Ext.util.MixedCollection'),
offsetTop: 50,
alertMsgTpl: [
'',
'',
'
',
'x',
'',
'
',
'',
'{title} ',
'',
'{text}',
'
',
'
',
'{text}',
'
',
''
],
growlMsgTpl: [
'',
'',
'',
'
',
'{title}
',
'',
'
{text}
',
'
name="{name}" ',
'size="{size}" ',
'tabIndex="{tabIdx}" ',
'class="{fieldCls} {typeCls}" autocomplete="off" />
',
'',
{
compiled: true,
disableFormats: true
}
],
onChange: function(newValue, oldValue) {
this.updateMeter(newValue);
},
updateMeter : function(val) {
var me = this, maxWidth, score, scoreWidth,
objMeter = me.el.down('.' + Ext.baseCSSPrefix + 'form-strengthmeter'),
scoreBar = me.el.down('.' + Ext.baseCSSPrefix + 'form-strengthmeter-scorebar');
if (val){
maxWidth = objMeter.getWidth();
score = me.calcStrength(val);
scoreWidth = maxWidth - (maxWidth / 100) * score;
scoreBar.setWidth(scoreWidth, true);
} else {
scoreBar.setWidth('100%');
}
},
calcStrength: function(p) {
var len = p.length,
score = len;
if (len > 0 && len <= 4) { // length 4 or
score += len
} else if (len >= 5 && len <= 7) {
score += 6;
} else if (len >= 8 && len <= 15) {
score += 12;
} else if (len >= 16) { // length 16 or more
score += 18;
}
if (p.match(/[a-z]/)) {
score += 1;
}
if (p.match(/[A-Z]/)) { // [verified] at least one upper
score += 5;
}
if (p.match(/\d/)) { // [verified] at least one
score += 5;
}
if (p.match(/(?:.*?\d)3/)) {
score += 5;
}
if (p.match(/[\!,@,#,$,%,\^,&,\*,\?,_,~]/)) {
score += 5;
}
if (p.match(/(?:.*?[\!,@,#,$,%,\^,&,\*,\?,_,~])2/)) {
score += 5;
}
if (p.match(/(?=.*[a-z])(?=.*[A-Z])/)) {
score += 2;
}
if (p.match(/(?=.*\d)(?=.*[a-z])(?=.*[A-Z])/)) {
score += 2;
}
if (p.match(/(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[\!,@,#,$,%,\^,&,\*,\?,_,~])/)) {
score += 2;
}
return Math.min(Math.round(score * 2), 100);
}
});
Ext.define('Shopware.form.field.CodeMirror',
{
extend: 'Ext.form.field.TextArea',
alternateClassName: [ 'Shopware.form.CodeMirror', 'Ext.form.field.CodeMirror' ],
alias: [ 'widget.codemirrorfield', 'widget.codemirror' ],
editor: null,
editorHeight: 0,
editorWidth: 0,
isEditorRendered: false,
modePath: 'http://www.bautz-shop.de/engine/Library/CodeMirror/mode',
loadedModes: Ext.create('Ext.util.MixedCollection'),
initComponent : function() {
var me = this;
me.on({ resize: me.onResize });
me.addEvents('editorready');
me.callParent(arguments);
},
constructor: function(config) {
var me = this;
Ext.applyIf(config, {
indentUnit: 4,
theme: 'default'
});
me.config = config;
me.callParent(arguments);
Ext.apply(config, {
onChange: function() {
me.checkChange();
},
onFocus: function() {
me.fireEvent('focus', me);
}
});
},
onResize: function(component, width, height) {
var me = this;
me.editorHeight = height;
me.editorWidth = width - 10;
me.resizeEditor();
},
onRender: function() {
var me = this;
me.callParent(arguments);
if(!window.CodeMirror) {
Ext.Error.raise("The CodeMirror editor source files aren't included in the project");
}
if(!me.config.mode) {
Ext.Error.raise("The CodeMirror mode is not configured");
}
var availableModes = CodeMirror.modes,
modeActive = false;
Ext.Array.each(availableModes, function(value) {
if(value === me.config.mode) {
modeActive = true;
}
});
if(!modeActive) {
me.loadJSFile(me.modePath + '/' + me.config.mode + '/' + me.config.mode + '.js');
} else {
if(!me.isEditorRendered) {
me.initEditor();
}
}
},
initEditor: function() {
var me = this,
el = me.inputEl;
me.editor = CodeMirror.fromTextArea(document.getElementById(el.id), me.config);
me.isEditorRendered = true;
me.editor.on('change', function() {
me.editor.save();
});
me.resizeEditor();
me.editor.setValue(me.rawValue);
me.fireEvent('editorready', me, me.editor);
return me.editor;
},
resizeEditor: function() {
var me = this,
scroller,
height, width;
if (me.editor && me.el) {
if (me.height) {
height = me.height;
} else {
height = me.el.getHeight();
}
if (me.width) {
width = me.width - 10;
} else {
width = '100%';
}
scroller = Ext.get(me.editor.getScrollerElement());
scroller.setHeight(height);
scroller.setWidth(width);
me.editor.refresh();
}
},
reset: function() {
if (this.editor) {
this.editor.setValue('');
}
return this.callParent(arguments);
},
getValue: function() {
if (this.editor) {
this.editor.save();
}
return this.callParent(arguments);
},
setValue: function(value) {
if (this.editor && (typeof value !== "undefined")) {
this.editor.setValue(value);
}
if(this.editor) {
this.editor.refresh();
}
this.config.value = value;
return this.callParent(arguments);
},
focus: function() {
this.editor.focus();
},
loadJSFile: function(file) {
var me = this,
head = document.head,
script = document.createElement('script');
Ext.apply(script, {
src : file,
type : 'text/javascript',
onload : Ext.Function.createDelayed(me.handleFileLoad, 100, me, [script]),
onreadystatechange : function() {
if (this.readyState === 'loaded' || this.readyState === 'complete') {
me.handleFileLoad(script);
}
}
});
head.appendChild(script);
},
handleFileLoad: function(script) {
script.onload = null;
script.onreadystatechange = null;
script.onerror = null;
var me = this,
loadedModes = me.loadedModes;
loadedModes.add(Ext.get(script));
if(!me.isEditorRendered) {
me.initEditor();
}
},
destroy: function() {
if (this.editor) {
this.editor.toTextArea();
}
this.callParent(arguments);
}
});
Ext.define('Shopware.form.field.ArticleSearch',
{
extend: 'Ext.container.Container',
layout: 'anchor',
alternateClassName: [ 'Shopware.form.ArticleSearch', 'Shopware.ArticleSearch' ],
alias: [ 'widget.articlesearch', 'widget.articlesearchfield' ],
cls: Ext.baseCSSPrefix + 'search-article-live',
requires: [
'Ext.form.field.Trigger',
'Ext.view.View',
'Ext.form.field.Hidden',
'Ext.XTemplate',
'Shopware.apps.Base.store.Article',
'Shopware.apps.Base.model.Article',
'Ext.grid.Panel'
],
returnValue: 'name',
hiddenReturnValue: 'number',
returnRecord: null,
searchFieldName: 'live-article-search',
hiddenFieldName: 'hidden-article-search',
dropDownStore: null,
dropDownOffset: [ 105, 8 ],
searchBuffer: 500,
multiSelect: false,
multiSelectStore: Ext.create('Ext.data.Store', {
model: 'Shopware.apps.Base.model.Article'
}),
mulitSelectGrid: null,
gridHeight: 200,
gridToolbarDock: 'bottom',
confirmButtonText: 'Zugewiesene Artikel speichern',
cancelButtonText: 'Artikel zurücksetzen',
separator: ';',
searchScope: ['articles','variants','configurator'],
formFieldConfig: {},
snippets: {
emptyText: 'Suche...',
assignedArticles: 'Zugewiesene Artikel',
articleName: 'Artikelname',
orderNumber: 'Bestellnummer',
dropDownTitle: 'Artikel'
},
initComponent: function() {
var me = this;
me.registerEvents();
if (!(me.articleStore instanceof Ext.data.Store)) {
me.articleStore = Ext.create('Shopware.apps.Base.store.Article');
}
me.dropDownStore = Ext.create('Shopware.apps.Base.store.Article', {
listeners: {
single: true,
load: function() {
me.loadArticleStore(me.articleStore);
}
}
});
if (Ext.isObject(me.articleStore) && me.articleStore.data.items.length > 0 ) {
me.loadArticleStore(me.articleStore);
}
if (Ext.isArray(me.searchScope) && me.searchScope.length > 0) {
me.dropDownStore.getProxy().extraParams = {
articles: Ext.Array.contains(me.searchScope, 'articles'),
variants: Ext.Array.contains(me.searchScope, 'variants'),
configurator: Ext.Array.contains(me.searchScope, 'configurator')
};
}
me.hiddenField = me.createHiddenField();
me.searchField = me.createSearchField();
me.dropDownMenu = me.createDropDownMenu();
me.items = [ me.hiddenField, me.searchField, me.dropDownMenu ];
if(!me.multiSelect) {
delete me.multiSelectStore;
} else {
me.multiSelectGrid = me.createMultiSelectGrid();
me.items.push(me.multiSelectGrid);
}
if(me.articleStore && me.multiSelect) {
me.multiSelectGrid.show();
}
me.dropDownStore.on('datachanged', me.onSearchFinish, me);
me.callParent(arguments);
},
registerEvents: function() {
this.addEvents(
'reset',
'search',
'valueselect',
'deleteArticle',
'applyAssignment'
);
},
createHiddenField: function() {
var me = this,
input = Ext.create('Ext.form.field.Hidden', {
name: me.hiddenFieldName
});
return input;
},
getHiddenField: function() {
return this.hiddenField || (this.hiddenField = this.createHiddenField());
},
createSearchField: function() {
var me = this;
var fieldConfig = Ext.apply({
componentLayout: 'textfield',
triggerCls: 'reset',
emptyText: me.snippets.emptyText,
fieldLabel: (me.fieldLabel || undefined),
cls: Ext.baseCSSPrefix + 'search-article-live-field',
name: me.searchFieldName,
enableKeyEvents: true,
anchor: (me.anchor || undefined),
onTriggerClick: function() {
this.reset();
this.focus();
this.setHideTrigger(true);
me.dropDownMenu.hide();
me.fireEvent('reset', me, this);
},
hideTrigger: true,
listeners: {
scope: me,
keyup: me.onSearchKeyUp,
blur: me.onSearchBlur
}
}, me.formFieldConfig);
var input = Ext.create('Ext.form.field.Trigger', fieldConfig);
return input;
},
onSearchBlur: function() {
var me = this;
Ext.defer(function() {
if (me.dropDownMenu) {
me.dropDownMenu.hide();
}
}, 1000);
},
getSearchField: function() {
return this.searchField || (this.searchField = this.createSearchField())
},
createDropDownMenu: function() {
var me = this,
view = Ext.create('Ext.view.View', {
floating: true,
autoShow: false,
autoRender: true,
hidden: true,
shadow: false,
width: 222,
toFrontOnShow: true,
focusOnToFront: false,
store: me.dropDownStore,
cls: Ext.baseCSSPrefix + 'search-article-live-drop-down',
overItemCls: Ext.baseCSSPrefix + 'drop-down-over',
selectedItemCls: Ext.baseCSSPrefix + 'drop-down-over',
trackOver: true,
itemSelector: 'div.item',
singleSelect: true,
listeners: {
scope: me,
itemclick: function(view, record) {
me.onSelectArticle(view, record);
}
},
tpl: me.createDropDownMenuTpl()
});
return view;
},
getDropDownMenu: function() {
return this.dropDownMenu || (this.dropDownMenu = this.createDropDownMenu());
},
createDropDownMenuTpl: function() {
var me = this;
return new Ext.XTemplate(
'',
'',
'
',
'',
'{name}',
'{number}',
'
',
'',
'
',
'
{title}',
'
{url}',
'
',
'{date}',
'{metaDescription}',
'
',
'