Your IP : 3.142.212.150
// @flow
import {Type, Text, Loc} from 'main.core';
import { BaseEvent, EventEmitter } from 'main.core.events';
import type { ProcessOptions, OptionsField, QueueAction, ProcessResult, ControllerResponse } from './process-types';
import { ProcessResultStatus, ProcessState } from './process-types';
import { Dialog } from './dialog';
/**
* @namespace {BX.UI.StepProcessing}
*/
export const ProcessEvent = {
StateChanged: 'BX.UI.StepProcessing.StateChanged',
BeforeRequest: 'BX.UI.StepProcessing.BeforeRequest'
}
/**
* @namespace {BX.UI.StepProcessing}
*/
export const ProcessCallback = {
StateChanged: 'StateChanged',
RequestStart: 'RequestStart',
RequestStop: 'RequestStop',
RequestFinalize: 'RequestFinalize',
StepCompleted: 'StepCompleted'
}
export const ProcessDefaultLabels = {
AuthError: Loc.getMessage('UI_STEP_PROCESSING_AUTH_ERROR'),
RequestError: Loc.getMessage('UI_STEP_PROCESSING_REQUEST_ERR'),
DialogStartButton: Loc.getMessage('UI_STEP_PROCESSING_BTN_START'),
DialogStopButton: Loc.getMessage('UI_STEP_PROCESSING_BTN_STOP'),
DialogCloseButton: Loc.getMessage('UI_STEP_PROCESSING_BTN_CLOSE'),
RequestCanceling: Loc.getMessage('UI_STEP_PROCESSING_CANCELING'),
RequestCanceled: Loc.getMessage('UI_STEP_PROCESSING_CANCELED'),
RequestCompleted: Loc.getMessage('UI_STEP_PROCESSING_COMPLETED'),
DialogExportDownloadButton: Loc.getMessage('UI_STEP_PROCESSING_FILE_DOWNLOAD'),
DialogExportClearButton: Loc.getMessage('UI_STEP_PROCESSING_FILE_DELETE'),
WaitingResponse: Loc.getMessage('UI_STEP_PROCESSING_WAITING'),
};
const EndpointType = {
Controller: 'controller',
Component: 'component'
};
/**
* Long running process.
*
* @namespace {BX.UI.StepProcessing}
* @event BX.UI.StepProcessing.StateChanged
* @event BX.UI.StepProcessing.BeforeRequest
*/
export class Process
{
options: ProcessOptions;
id: string;
// Ajax endpoint
endpointType: EndpointType.Controller|EndpointType.Component;
controller: string;
controllerDefault: string;
component: string;
componentMode: 'class'|'ajax';
hash: string;
action: string = '';
method: 'POST'|'GET' = 'POST';
params: {[name: string]: any} = {};
/**
* @private
*/
xhr: ?XMLHttpRequest;
ajaxPromise: ?Promise;
isRequestRunning: boolean = false;
networkErrorCount: 0;
// Queue
queue: Array<QueueAction> = [];
currentStep: number = -1;
state: $Values<ProcessState> = ProcessState.intermediate;
// Dialog
dialog: Dialog;
initialOptionValues: {[id: string]: any} = {};
optionsFields: {[id: string]: OptionsField} = {};
// Events
handlers: {[event: string]: any => {}} = {};
// Messages
messages: Map<string, string> = new Map;
constructor(options: ProcessOptions)
{
this.options = Type.isPlainObject(options) ? options : {};
this.id = this.getOption('id', '');
if (!Type.isStringFilled(this.id))
{
this.id = 'Process_' + Text.getRandom().toLowerCase();
}
const controller = this.getOption('controller', '');
const component = this.getOption('component', '');
if (Type.isStringFilled(controller))
{
this.controller = controller;
this.controllerDefault = controller;
this.endpointType = EndpointType.Controller;
}
else if (Type.isStringFilled(component))
{
this.component = component;
this.endpointType = EndpointType.Component;
this.componentMode = this.getOption('componentMode', 'class');
}
if (!Type.isStringFilled(this.controller))
{
if (!Type.isStringFilled(this.component))
{
throw new TypeError("BX.UI.StepProcessing: There no any ajax endpoint was defined.");
}
}
this
.setQueue(this.getOption('queue', []))
.setParams(this.getOption('params', {}))
.setOptionsFields(this.getOption('optionsFields', {}))
.setHandlers(this.getOption('handlers', {}))
.setMessages(ProcessDefaultLabels)
.setMessages(this.getOption('messages', {}))
;
}
destroy()
{
if (this.dialog instanceof Dialog)
{
this.dialog.close().destroy();
this.dialog = null;
}
this._closeConnection();
}
//region Run
start(startStep?: number = 1)
{
this._refreshHash();
startStep = startStep || 1;
if (
this.state === ProcessState.intermediate ||
this.state === ProcessState.stopped ||
this.state === ProcessState.completed
)
{
if (!this.getDialog().checkOptionFields())
{
return;
}
this.getDialog().clearErrors().clearWarnings();
this.networkErrorCount = 0;
if (this.getQueueLength() > 0)
{
this.currentStep = 0;
if (startStep > 1)
{
this.currentStep = startStep - 1;
}
if (this.endpointType === EndpointType.Controller)
{
if (Type.isStringFilled(this.queue[this.currentStep].controller))
{
this.setController(this.queue[this.currentStep].controller);
}
}
if (!Type.isStringFilled(this.queue[this.currentStep].action))
{
throw new Error("BX.UI.StepProcessing: Could not find controller action at the queue position.");
}
this.setAction(this.queue[this.currentStep].action);
this.startRequest();
if (this.queue[this.currentStep].title)
{
this.getDialog().setSummary(this.queue[this.currentStep].title);
}
else
{
this.getDialog().setSummary(this.getMessage('WaitingResponse'));
}
}
else
{
this.startRequest();
}
}
return this;
}
stop()
{
if (this.state === ProcessState.running)
{
this.stopRequest();
this.currentStep = -1;
}
return this;
}
//endregion
//region Request
startRequest(): ?Promise
{
if (this.isRequestRunning || this.state === ProcessState.canceling)
{
return this.ajaxPromise;
}
this.isRequestRunning = true;
this.ajaxPromise = null;
let actionData = new FormData();
let appendData = (data, prefix) => {
if (Type.isPlainObject(data))
{
Object.keys(data).forEach(name => {
let id = name;
if (prefix)
{
id = prefix+'['+name+']';
}
if (Type.isArray(data[name]) || Type.isPlainObject(data[name]))
{
appendData(data[name], id);
}
else
{
actionData.append(id, data[name]);
}
});
}
else if (Type.isArray(data))
{
data.forEach(element => actionData.append(prefix+'[]', element));
}
};
appendData(this.params);
if (this.queue[this.currentStep].params)
{
appendData(this.queue[this.currentStep].params);
}
let initialOptions = this.getDialog().getOptionFieldValues();
if (BX.type.isNotEmptyObject(initialOptions))
{
appendData(initialOptions);
this.initialOptionValues = initialOptions;
this.storeOptionFieldValues(initialOptions);
}
else
{
Object.keys(this.initialOptionValues).forEach(name => {
// don't repeat file uploading
if (this.initialOptionValues[name] instanceof File)
{
delete (this.initialOptionValues[name]);
}
});
appendData(this.initialOptionValues);
}
this.setState(ProcessState.running);
if (this.hasActionHandler(ProcessCallback.RequestStart))
{
this.callActionHandler(ProcessCallback.RequestStart, [actionData]);
}
else if (this.hasHandler(ProcessCallback.RequestStart))
{
this.callHandler(ProcessCallback.RequestStart, [actionData]);
}
EventEmitter.emit(ProcessEvent.BeforeRequest, new BaseEvent({data: {process: this, actionData: actionData}}));
let params = {
data: actionData,
method: this.method,
onrequeststart: this._onRequestStart.bind(this)
};
if (this.endpointType === EndpointType.Controller)
{
this.ajaxPromise =
BX.ajax.runAction(this.controller + '.' + this.getAction(), params)
.then(
this._onRequestSuccess.bind(this),
this._onRequestFailure.bind(this)
);
}
else if (this.endpointType === EndpointType.Component)
{
params.data.mode = this.componentMode;
if ('signedParameters' in params.data)
{
params.signedParameters = params.data.signedParameters;
delete params.data.signedParameters;
}
this.ajaxPromise =
BX.ajax.runComponentAction(this.component, this.getAction(), params)
.then(
this._onRequestSuccess.bind(this),
this._onRequestFailure.bind(this)
);
}
return this.ajaxPromise;
}
stopRequest(): ?Promise
{
if (this.state === ProcessState.canceling)
{
return this.ajaxPromise;
}
this.setState(ProcessState.canceling);
this._closeConnection();
let actionData = BX.clone(this.params);
actionData.cancelingAction = this.getAction();
this.getDialog().setSummary(this.getMessage("RequestCanceling"));
let proceedAction = true;
if (this.hasActionHandler(ProcessCallback.RequestStop))
{
proceedAction = false;
this.callActionHandler(ProcessCallback.RequestStop, [actionData]);
}
else if (this.hasHandler(ProcessCallback.RequestStop))
{
proceedAction = false;
this.callHandler(ProcessCallback.RequestStop, [actionData]);
}
EventEmitter.emit(ProcessEvent.BeforeRequest, new BaseEvent({data: {process: this, actionData: actionData}}));
this.ajaxPromise = null;
if (proceedAction)
{
let params = {
data: actionData,
method: this.method,
onrequeststart: this._onRequestStart.bind(this)
};
if (this.endpointType === EndpointType.Controller)
{
this.setController(this.controllerDefault);
this.ajaxPromise =
BX.ajax.runAction(this.controller + '.cancel', params)
.then(
this._onRequestSuccess.bind(this),
this._onRequestFailure.bind(this)
);
}
else if (this.endpointType === EndpointType.Component)
{
params.data.mode = this.componentMode;
if ('signedParameters' in params.data)
{
params.signedParameters = params.data.signedParameters;
delete params.data.signedParameters;
}
this.ajaxPromise =
BX.ajax.runComponentAction(this.component, 'cancel', params)
.then(
this._onRequestSuccess.bind(this),
this._onRequestFailure.bind(this)
);
}
}
return this.ajaxPromise;
}
finalizeRequest(): ?Promise
{
if (this.state === ProcessState.canceling)
{
return this.ajaxPromise;
}
let actionData = BX.clone(this.params);
let proceedAction = true;
if (this.hasActionHandler(ProcessCallback.RequestFinalize))
{
proceedAction = false;
this.callActionHandler(ProcessCallback.RequestFinalize, [actionData]);
}
else if (this.hasHandler(ProcessCallback.RequestFinalize))
{
proceedAction = false;
this.callHandler(ProcessCallback.RequestFinalize, [actionData]);
}
EventEmitter.emit(ProcessEvent.BeforeRequest, new BaseEvent({data: {process: this, actionData: actionData}}));
this.ajaxPromise = null;
if (proceedAction)
{
let params = {
data: actionData,
method: this.method,
onrequeststart: this._onRequestStart.bind(this)
};
if (this.endpointType === EndpointType.Controller)
{
this.setController(this.controllerDefault);
this.ajaxPromise = BX.ajax.runAction(this.controller + '.finalize', params);
}
else if (this.endpointType === EndpointType.Component)
{
params.data.mode = this.componentMode;
if ('signedParameters' in params.data)
{
params.signedParameters = params.data.signedParameters;
delete params.data.signedParameters;
}
this.ajaxPromise = BX.ajax.runComponentAction(this.component, 'finalize', params);
}
}
return this.ajaxPromise;
}
/**
* @private
*/
_refreshHash()
{
this.hash = this.id + Date.now();
this.setParam("PROCESS_TOKEN", this.hash);
return this;
}
/**
* @private
*/
_onRequestSuccess(response: ControllerResponse)
{
this.isRequestRunning = false;
this.xhr = null;
this.ajaxPromise = null;
if (!response)
{
this.getDialog().setError(this.getMessage('RequestError'));
this.setState(ProcessState.error);
return;
}
if (Type.isArrayFilled(response.errors))
{
const errors = response.errors.slice(-10);
let errMessages = [];
errors.forEach(err => errMessages.push(err.message));
this.getDialog().setErrors(errMessages, true);
this.setState(ProcessState.error);
return;
}
this.networkErrorCount = 0;
const result = response.data;
const status = Type.isStringFilled(result.STATUS) ? result.STATUS : "";
let summary = "";
if (Type.isStringFilled(result.SUMMARY))
{
summary = result.SUMMARY;
}
else if (Type.isStringFilled(result.SUMMARY_HTML))
{
summary = result.SUMMARY_HTML;
}
const processedItems = Type.isNumber(result.PROCESSED_ITEMS) ? result.PROCESSED_ITEMS : 0;
const totalItems = Type.isNumber(result.TOTAL_ITEMS) ? result.TOTAL_ITEMS : 0;
let finalize = !!result.FINALIZE;
if (this.hasActionHandler(ProcessCallback.StepCompleted))
{
this.callActionHandler(ProcessCallback.StepCompleted, [status, result]);
}
if (Type.isStringFilled(result.WARNING))
{
this.getDialog().setWarning(result.WARNING);
}
if (status === ProcessResultStatus.progress || status === ProcessResultStatus.completed)
{
if (totalItems > 0)
{
if (this.queue[this.currentStep].progressBarTitle)
{
this.getDialog()
.setProgressBar(totalItems, processedItems, this.queue[this.currentStep].progressBarTitle);
}
else
{
this.getDialog()
.setProgressBar(totalItems, processedItems);
}
}
else
{
this.getDialog().hideProgressBar();
}
}
if (status === ProcessResultStatus.progress)
{
if (summary !== "")
{
this.getDialog().setSummary(summary, true);
}
if (this.state === ProcessState.canceling)
{
this.setState(ProcessState.stopped);
}
else
{
if (this.endpointType === EndpointType.Controller)
{
const nextController = Type.isStringFilled(result.NEXT_CONTROLLER) ? result.NEXT_CONTROLLER : "";
if (nextController !== "")
{
this.setController(nextController);
}
else if (Type.isStringFilled(this.queue[this.currentStep].controller))
{
this.setController(this.queue[this.currentStep].controller);
}
else
{
this.setController(this.controllerDefault);
}
}
const nextAction = Type.isStringFilled(result.NEXT_ACTION) ? result.NEXT_ACTION : "";
if (nextAction !== "")
{
this.setAction(nextAction);
}
setTimeout(
BX.delegate(this.startRequest, this),
100
);
}
return;
}
if (this.state === ProcessState.canceling)
{
this.getDialog().setSummary(this.getMessage("RequestCanceled"));
this.setState(ProcessState.completed);
}
else if (status === ProcessResultStatus.completed)
{
if (this.getQueueLength() > 0 && this.currentStep + 1 < this.getQueueLength())
{
// next
this.currentStep ++;
if (this.endpointType === EndpointType.Controller)
{
if (Type.isStringFilled(this.queue[this.currentStep].controller))
{
this.setController(this.queue[this.currentStep].controller);
}
else
{
this.setController(this.controllerDefault);
}
}
if (!Type.isStringFilled(this.queue[this.currentStep].action))
{
throw new Error("BX.UI.StepProcessing: Could not find controller action at the queue position.");
}
if ('finalize' in this.queue[this.currentStep])
{
finalize = true;
this.setAction(this.queue[this.currentStep].action);
}
else
{
this.setAction(this.queue[this.currentStep].action);
this.getDialog().setSummary(this.queue[this.currentStep].title);
setTimeout(
BX.delegate(this.startRequest, this),
100
);
return;
}
}
if (summary !== "")
{
this.getDialog().setSummary(summary, true);
}
else
{
this.getDialog().setSummary(this.getMessage("RequestCompleted"));
}
if (Type.isStringFilled(result.DOWNLOAD_LINK))
{
if (Type.isStringFilled(result.DOWNLOAD_LINK_NAME))
{
this.getDialog().setMessage('downloadButton', result.DOWNLOAD_LINK_NAME);
}
if (Type.isStringFilled(result.CLEAR_LINK_NAME))
{
this.getDialog().setMessage('clearButton', result.CLEAR_LINK_NAME);
}
this.getDialog().setDownloadButtons(
result.DOWNLOAD_LINK,
result.FILE_NAME,
BX.delegate(function(){
this.getDialog().resetButtons({stop: true, close: true});
this.callAction('clear'); //.then
setTimeout(BX.delegate(function(){
this.getDialog().resetButtons({close: true});
}, this), 1000);
}, this)
);
}
this.setState(ProcessState.completed, result);
if (finalize)
{
setTimeout(
BX.delegate(this.finalizeRequest, this),
100
);
}
}
else
{
this.getDialog().setSummary("").setError(this.getMessage("RequestError"));
this.setState(ProcessState.error);
}
}
/**
* @private
*/
_onRequestFailure (response: ControllerResponse)
{
/*
// check if it's manual aborting
if (this.state === ProcessState.canceling)
{
return;
}
*/
this.isRequestRunning = false;
this.ajaxPromise = null;
// check non auth
if (
Type.isPlainObject(response) &&
('data' in response) && Type.isPlainObject(response.data) &&
('ajaxRejectData' in response.data) && Type.isPlainObject(response.data.ajaxRejectData) &&
('reason' in response.data.ajaxRejectData) && (response.data.ajaxRejectData.reason === 'status') &&
('data' in response.data.ajaxRejectData) && (response.data.ajaxRejectData.data === 401)
)
{
this.getDialog().setError(this.getMessage('AuthError'));
}
// check errors
else if (
Type.isPlainObject(response) &&
('errors' in response) &&
Type.isArrayFilled(response.errors)
)
{
let abortingState = false;
let networkError = false;
response.errors.forEach(err => {
if (err.code === 'NETWORK_ERROR')
{
if (this.state === ProcessState.canceling)
{
abortingState = true;
}
else
{
networkError = true;
}
}
});
// ignoring error of manual aborting
if (abortingState)
{
return;
}
if (networkError)
{
this.networkErrorCount ++;
// Let's give it more chance to complete
if (this.networkErrorCount <= 2)
{
setTimeout(
BX.delegate(this.startRequest, this),
15000
);
return;
}
}
const errors = response.errors.slice(-10);
let errMessages = [];
errors.forEach(err => {
if (err.code === 'NETWORK_ERROR')
{
errMessages.push(this.getMessage('RequestError'))
}
else
{
errMessages.push(err.message)
}
});
this.getDialog().setErrors(errMessages, true);
}
else
{
this.getDialog().setError(this.getMessage('RequestError'));
}
this.xhr = null;
this.currentStep = -1;
this.setState(ProcessState.error);
}
//endregion
//region Connection
/**
* @private
*/
_closeConnection()
{
if (this.xhr instanceof XMLHttpRequest)
{
try
{
this.xhr.abort();
this.xhr = null;
}
catch (e){}
}
}
/**
* @private
*/
_onRequestStart(xhr: XMLHttpRequest)
{
this.xhr = xhr;
}
//endregion
//region Set & Get
setId(id: string)
{
this.id = id;
return this;
}
getId(): string
{
return this.id;
}
//region Queue actions
setQueue(queue: Array<QueueAction>)
{
queue.forEach((action: QueueAction) => this.addQueueAction(action));
return this;
}
addQueueAction(action: QueueAction)
{
this.queue.push(action);
return this;
}
getQueueLength(): number
{
return this.queue.length;
}
//endregion
//region Process options
setOption(name: $Keys<ProcessOptions>, value: any)
{
this.options[name] = value;
return this;
}
getOption(name: $Keys<ProcessOptions>, defaultValue?: any = null): any
{
return this.options.hasOwnProperty(name) ? this.options[name] : defaultValue;
}
//endregion
//region Initial fields
setOptionsFields(optionsFields: {[id: string]: OptionsField})
{
Object.keys(optionsFields).forEach(id => this.addOptionsField(id, optionsFields[id]));
return this;
}
addOptionsField(id: string, field: OptionsField)
{
this.optionsFields[id] = field;
return this;
}
storeOptionFieldValues(values: {[name: string]: any})
{
if ('sessionStorage' in window)
{
let valuesToStore = {};
Object.keys(this.optionsFields).forEach((name: string) => {
let field: OptionsField = this.optionsFields[name];
switch (field.type)
{
case 'checkbox':
case 'select':
case 'radio':
if (field.name in values)
{
valuesToStore[field.name] = values[field.name];
}
break;
}
});
window.sessionStorage.setItem('bx.' + this.getId(), JSON.stringify(valuesToStore));
}
return this;
}
restoreOptionFieldValues()
{
let values = {};
if ('sessionStorage' in window)
{
values = JSON.parse(window.sessionStorage.getItem('bx.' + this.getId()));
if (!Type.isPlainObject(values))
{
values = {};
}
}
return values;
}
//endregion
//region Request parameters
setParams(params: {[name: string]: any})
{
this.params = {};
Object.keys(params).forEach(name => this.setParam(name, params[name]));
return this;
}
getParams(): {[string]:any}
{
return this.params;
}
setParam(key: string, value: any)
{
this.params[key] = value;
return this;
}
getParam(key: string): any | null
{
return this.params[key] ? this.params[key] : null;
}
//endregion
//region Process state
setState(state: $Values<ProcessState>, result?: ProcessResult = {})
{
if (this.state === state)
{
return this;
}
this.state = state;
if (state === ProcessState.intermediate || state === ProcessState.stopped)
{
this.getDialog()
.lockButton('start', false)
.lockButton('stop', true)
.showButton('close', true);
}
else if (state === ProcessState.running)
{
this.getDialog()
.lockButton('start', true, true)
.lockButton('stop', false)
.showButton('close', false);
}
else if (state === ProcessState.canceling)
{
this.getDialog()
.lockButton('start', true)
.lockButton('stop', true, true)
.showButton('close', false)
.hideProgressBar();
}
else if (state === ProcessState.error)
{
this.getDialog()
.lockButton('start', true)
.lockButton('stop', true)
.showButton('close', true);
}
else if (state === ProcessState.completed)
{
this.getDialog()
.lockButton('start', true)
.lockButton('stop', true)
.showButton('close', true)
.hideProgressBar();
}
if (this.hasActionHandler(ProcessCallback.StateChanged))
{
this.callActionHandler(ProcessCallback.StateChanged, [state, result]);
}
else if (this.hasHandler(ProcessCallback.StateChanged))
{
this.callHandler(ProcessCallback.StateChanged, [state, result]);
}
EventEmitter.emit(ProcessEvent.StateChanged, new BaseEvent({data: {state: state, result: result}}));
return this;
}
getState(): $Values<ProcessState>
{
return this.state;
}
//endregion
//region Controller
setController(controller: string)
{
this.controller = controller;
return this;
}
getController(): string
{
return this.controller;
}
setComponent(component: string, componentMode: 'class'|'ajax' = 'class')
{
this.component = component;
this.componentMode = componentMode;
return this;
}
getComponent(): string
{
return this.component;
}
setAction(action: string)
{
this.action = action;
return this;
}
getAction(): string
{
return this.action;
}
callAction(action: string): ?Promise
{
this.setAction(action)._refreshHash();
return this.startRequest();
}
//endregion
//region Event handlers
setHandlers(handlers: {[$Keys<ProcessCallback>]: any => {}})
{
Object.keys(handlers).forEach(type => this.setHandler(type, handlers[type]));
return this;
}
setHandler(type: $Keys<ProcessCallback>, handler: any => {})
{
if (Type.isFunction(handler))
{
this.handlers[type] = handler;
}
return this;
}
hasHandler(type: $Keys<ProcessCallback>)
{
return Type.isFunction(this.handlers[type]);
}
callHandler(type: $Keys<ProcessCallback>, args: any)
{
if (this.hasHandler(type))
{
this.handlers[type].apply(this, args);
}
}
hasActionHandler(type: $Keys<ProcessCallback>)
{
if (this.queue[this.currentStep])
{
if ('handlers' in this.queue[this.currentStep])
{
return Type.isFunction(this.queue[this.currentStep].handlers[type]);
}
}
return false;
}
callActionHandler(type: $Keys<ProcessCallback>, args: any)
{
if (this.hasActionHandler(type))
{
this.queue[this.currentStep].handlers[type].apply(this, args);
}
}
//endregion
//region lang messages
setMessages(messages: {[string]: string})
{
Object.keys(messages).forEach((id) => this.setMessage(id, messages[id]));
return this;
}
setMessage(id: string, text: string)
{
this.messages.set(id, text);
return this;
}
getMessage(id: string, placeholders?: {[string]: string} = null): string
{
let phrase = this.messages.has(id) ? this.messages.get(id) : '';
if (Type.isStringFilled(phrase) && Type.isPlainObject(placeholders))
{
Object.keys(placeholders).forEach((placeholder: string) => {
phrase = phrase.replace('#'+placeholder+'#', placeholders[placeholder]);
});
}
return phrase;
}
//endregion
//endregion
//region Dialog
getDialog(): Dialog
{
if (!this.dialog)
{
this.dialog = new Dialog({
id: this.id,
optionsFields: this.getOption('optionsFields', {}),
minWidth: Number.parseInt(this.getOption('dialogMinWidth', 500)),
maxWidth: Number.parseInt(this.getOption('dialogMaxWidth', 1000)),
optionsFieldsValue: this.restoreOptionFieldValues(),
messages: {
title: this.getMessage('DialogTitle'),
summary: this.getMessage('DialogSummary'),
startButton: this.getMessage('DialogStartButton'),
stopButton: this.getMessage('DialogStopButton'),
closeButton: this.getMessage('DialogCloseButton'),
downloadButton: this.getMessage('DialogExportDownloadButton'),
clearButton: this.getMessage('DialogExportClearButton')
},
showButtons: this.getOption('showButtons'),
handlers: {
start: BX.delegate(this.start, this),
stop: BX.delegate(this.stop, this),
dialogShown: (typeof(this.handlers.dialogShown) == 'function' ? this.handlers.dialogShown : null),
dialogClosed: (typeof(this.handlers.dialogClosed) == 'function' ? this.handlers.dialogClosed : null)
}
});
}
return this.dialog;
}
showDialog ()
{
this.getDialog()
.setSetting('optionsFieldsValue', this.restoreOptionFieldValues())
.resetButtons(this.getOption('optionsFields'))
.show();
if (!this.isRequestRunning)
{
this.setState(ProcessState.intermediate);
}
return this;
}
closeDialog ()
{
if (this.isRequestRunning)
{
this.stop();
}
this.getDialog().close();
return this;
}
//endregion
}