Elep

(function(app) {
 SUGAR.jssource = {
	"modules":{
		"Home":{"fieldTemplates": {
"base": {
"layoutbutton": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Home.LayoutbuttonField
 * @alias SUGAR.App.view.fields.BaseHomeLayoutbuttonField
 * @extends View.Fields.Base.BaseField
 */
({
	// Layoutbutton FieldTemplate (base)

events: {
        'click .btn.layout' : 'layoutClicked'
    },

extendsFrom: 'ButtonField',
    getFieldElement: function() {
        return this.$el;
    },
    _render: function() {
        var buttonField = app.view._getController({type: 'field', name: 'button', platform: app.config.platform});
        buttonField.prototype._render.call(this);
    },
    _loadTemplate: function() {
        app.view.Field.prototype._loadTemplate.call(this);
        if(this.action !== 'edit' || (this.model.maxColumns <= 1)) {
            this.template = app.template.empty;
        }
    },
    format: function(value) {
        var metadata = this.model.get("metadata");
        if(metadata) {
            var components = this.getComponentsFromMetadata(metadata);
            return components ? components.length : 1;
        }
        return value;
    },
    layoutClicked: function(evt) {
        var value = $(evt.currentTarget).data('value');
        this.setLayout(value);
    },
    /**
     * Gets component from metadata.
     *
     * @param {Object} metadata for all dashboard components
     * @return {Object} dashboard component
     */
    getComponentsFromMetadata: function(metadata) {
        var component;
        // this is a tabbed dashboard
        if (metadata.tabs) {
            var tabIndex = this.context.get('activeTab') || 0;
            component = metadata.tabs[tabIndex].components;
        } else {
            component = metadata.components;
        }
        return component;
    },
    setLayout: function(value) {
        var span = 12 / value;
        if(this.value) {

if (value === this.value) {
                return;
            }
            var setComponent = function() {
                var metadata = this.model.get("metadata");
                var components = this.getComponentsFromMetadata(metadata);

_.each(components, function(component) {
                    component.width = span;
                }, this);

if (components.length > value) {
                    _.times(components.length - value, function(index) {
                        components[value - 1].rows = components[value - 1].rows.concat(components[value + index].rows);
                    }, this);
                    components.splice(value);
                } else {
                    _.times(value - components.length, function(index) {
                        components.push({
                            rows: [],
                            width: span
                        });
                    }, this);
                }
                this.model.set("metadata", app.utils.deepCopy(metadata), {silent: true});
                this.model.trigger("change:metadata");
            };
            if(value !== this.value) {
                app.alert.show('resize_confirmation', {
                    level: 'confirmation',
                    messages: app.lang.get('LBL_DASHBOARD_LAYOUT_CONFIRM', this.module),
                    onConfirm: _.bind(setComponent, this),
                    onCancel: _.bind(this.render,this) // reverse the toggle done
                });
            } else {
                setComponent.call(this);
            }
        } else {
            //new data
            var metadata = {
                components: []
            };
            _.times(value, function(index) {
                metadata.components.push({
                    rows: [],
                    width: span
                });
            }, this);

this.model.set("metadata", app.utils.deepCopy(metadata), {silent: true});
            this.model.trigger("change:metadata");
        }
    },
    bindDomChange: function() {

},
    bindDataChange: function() {
        if (this.model) {
            this.model.on("change:metadata", this.render, this);
            if(this.model.isNew()) {
                //Assign default layout set
                this.setLayout(1);
                //clean out model changed attributes not to warn unsaved changes
                this.model.changed = {};
            }
        }
    }
}) },
"layoutsizer": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Home.LayoutsizerField
 * @alias SUGAR.App.view.fields.BaseHomeLayoutsizerField
 * @extends View.Fields.Base.BaseField
 */
({
	// Layoutsizer FieldTemplate (base)

spanMin: 2,
    spanTotal: 12,
    spanStep: 1,
    format: function(value) {
        var metadata = this.model.get("metadata");
        return (metadata && metadata.components) ? metadata.components.length - 1 : 0;
    },
    _loadTemplate: function() {
        app.view.Field.prototype._loadTemplate.call(this);
        if(this.action !== 'edit') {
            this.template = app.template.empty;
        }
    },
    _render: function() {
        app.view.Field.prototype._render.call(this);
        if(this.action === 'edit' && this.value > 0) {
            var self = this,
                metadata = this.model.get("metadata");
            this.$('#layoutwidth').empty().noUiSlider('init', {
                    knobs: this.value,
                    scale: [0,this.spanTotal],
                    step: this.spanStep,
                    connect: false,
                    end: function(type) {
                        if(type !== 'move') {
                            var values = $(this).noUiSlider('value');
                            self.setValue(values);
                        }
                    }
                })
                .append(function(){
                    var html = "",
                        segments = (self.spanTotal / self.spanStep) + 1,
                        segmentWidth = $(this).width() / (segments - 1),
                        acum = 0;
                    _.times(segments, function(i){
                        acum = (segmentWidth * i) - 2;
                        html += "<div class='ticks' style='left:"+acum+"px'></div>";
                    }, this);
                    return html;
                });
            this.setSliderPosition(metadata);
        } else {
            this.$('.noUiSliderEnds').hide();
        }
    },
    setSliderPosition: function(metadata) {
        var divider = 0;
        _.each(_.pluck(metadata.components, 'width'), function(span, index) {
            if(index >= this.value) return;
            divider = divider + parseInt(span, 10);
            this.$('#layoutwidth').noUiSlider('move', {
                handle: index,
                to: divider
            });
        }, this);
    },
    setValue: function(value) {
        var metadata = this.model.get("metadata"),
            divider = 0;
        _.each(metadata.components, function(component, index){
            if(index == metadata.components.length - 1) {
                component.width = this.spanTotal - divider;
                if(component.width < this.spanMin) {
                    var adjustment = this.spanMin - component.width;
                    for(var i = index - 1; i >= 0; i--) {
                        metadata.components[i].width -= adjustment;
                        if(metadata.components[i].width < this.spanMin) {
                            adjustment = this.spanMin - metadata.components[i].width;
                            metadata.components[i].width = this.spanMin;
                        } else {
                            adjustment = 0;
                        }
                    }
                    component.width = this.spanMin;
                }
            } else {
                component.width = value[index] - divider;
                if(component.width < this.spanMin) {
                    component.width = this.spanMin;
                }
                divider += component.width;
            }
        }, this);
        this.setSliderPosition(metadata);
        this.model.set("metadata", metadata, {silent: true});
        this.model.trigger("change:layout");
    },
    bindDataChange: function() {
        if (this.model) {
            this.model.on("change:metadata", this.render, this);
        }
    },
    bindDomChange: function() {

}
}) },
"sugar-dashlet-label": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Home.SugarDashletLabelField
 * @alias SUGAR.App.view.fields.BaseHomeSugarDashletLabelField
 * @extends View.Fields.Base.LabelField
 *
 * Label for trademarked `Sugar Dashlet&reg;` term.
 */
({
	// Sugar-dashlet-label FieldTemplate (base)

extendsFrom: 'LabelField'
}) },
"dashboardtitle": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Home.DashboardtitleField
 * @alias SUGAR.App.view.fields.BaseHomeDashboardtitleField
 * @extends View.Fields.Base.BaseField
 */
({
	// Dashboardtitle FieldTemplate (base)

events: {
        'click .dropdown-toggle': 'toggleClicked',
        'click a[data-id]': 'navigateClicked',
        'click a[data-action=manager]': 'managerClicked',
        'click a[data-type=dashboardtitle]': 'editClicked',
    },
    dashboards: null,

hasEditAccess: true,

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

if (!app.acl.hasAccessToModel('edit', this.model, this.name)) {
            this.hasEditAccess = false;
        }
    },

/**
     * @inheritdoc
     */
    _render: function() {
        this._super('_render');

this.$('input[name=name]').on('keydown', _.bind(function(evt) {
            this.fieldInput(evt);
        }, this));

this.$('input[name=name]').on('blur', _.bind(function() {
            this.fieldBlur();
        }, this));
    },

/**
     * Handle the click by dashboard title
     * @param {Object} evt The jQuery Event Object
     */
    editClicked: function(evt) {
        if (this.model.get('is_template')) {
            return;
        }

// Reinitialize hasChanges function to provide opportunity
        // to collapse the field with changes
        this.hasChanged = function() {
            return false;
        };

this.view.editClicked(evt);
        this.view.toggleField(this, true);
    },

/**
     * Handle input in title field
     * @param {Object} evt The jQuery Event Object
     */
    fieldInput: function(evt) {
        this.model.set('name', evt.currentTarget.value, {
            silent: true
        });

if (!this.model.dataFetched) {
            return;
        }

if ($.inArray(evt.keyCode, [13, 27]) != -1) {
            this.fieldBlur();
        }
    },

/**
     * Handle blur of title field
     */
    fieldBlur: function() {
        if (!this.model.dataFetched) {
            return;
        }

const reloadCollection = () => {
            this.context.off('record:set:state', reloadCollection);
            if (this.context.parent) {
                const collection = this.getCollection();
                collection.fetch();
            }
        };

this.context.on('record:set:state', reloadCollection);

this.view.saveHandle();
        this.view.toggleField(this);
    },

/**
     * Return collection
     * @return {Object} Sugar collection
     */
    getCollection: function() {
        const contextBro = this.context.parent &&
        _.contains(['multi-line', 'focus'], this.context.parent.get('layout')) ?
            this.context.parent : this.context.parent.getChildContext({module: 'Home'});
        return contextBro.get('collection');
    },

toggleClicked: function(evt) {
        var self = this;
        if (!_.isEmpty(this.dashboards)) {
            if (_.isFunction(self.view.adjustDropdownMenu)) {
                self.view.adjustDropdownMenu();
            }
            return;
        }

/**
     * Handle the click from the UI
     * @param {Object} evt The jQuery Event Object
     */
    navigateClicked: function(evt) {
        var id = $(evt.currentTarget).data('id');
        this.navigate(id);
    },
    /**
     * Navigate the user to the manage dashboards view
     */
    managerClicked: function() {
        var ctx = this.context && this.context.parent &&
        (_.contains(['multi-line', 'focus'], this.context.parent.get('layout'))) ?
            this.context.parent : app.controller.context;
        var dashboardModule = ctx.get('module');
        var dashboardLayout = ctx.get('layout');
        app.router.navigate('#Dashboards?moduleName=' + dashboardModule +
            '&viewName=' + dashboardLayout, {trigger: true});
    },
    /**
     * Change the Dashboard
     * @param {string} id The ID of the Dashboard to load
     * @param {string} [type] (Deprecated) The type of dashboard being loaded, default is undefined
     */
    navigate: function(id, type) {
        if (!_.isUndefined(type)) {
            // TODO: Remove the `type` parameter. This is to be done in TY-654
            app.logger.warn('The `type` parameter to `View.Fields.Base.Home.DashboardtitleField`' +
            'has been deprecated since 7.9.0.0. Please update your code to stop using it.');
        }
        this.view.layout.navigateLayout(id);
    },
    /**
     * Inspect the dashlet's label and convert i18n string only if it's concerned
     *
     * @param {String} i18n string or user typed string
     * @return {String} Translated string
     */
    format: function(value) {
        var module = this.context.parent && this.context.parent.get('module') || this.context.get('module');
        return app.lang.get(value, module) || value;
    },

/**
     * @inheritdoc
     *
     * Override template for dashboard title on home page.
     * Need display it as label so use `f.base.detail` template.
     */
    _loadTemplate: function() {
        app.view.Field.prototype._loadTemplate.call(this);

if (this.context && this.context.get('model') &&
            this.context.get('model').dashboardModule === 'Home'
        ) {
            var tpl = (this.tplName === 'detail') ? 'dashboardtitle' : this.tplName;
            this.template = app.template.getField('dashboardtitle', tpl, this.module) || this.template;
        }
    },

/**
     * Called by record view to set max width of inner record-cell div
     * to prevent long names from overflowing the outer record-cell container
     */
    setMaxWidth: function(width) {
        this.$el.css({'max-width': width});
    },

/**
     * Return the width of padding on inner record-cell
     */
    getCellPadding: function() {
        var padding = 0,
            $cell = this.$('.dropdown-toggle');

if ($cell.length > 0) {
            padding = parseInt($cell.css('padding-left'), 10) + parseInt($cell.css('padding-right'), 10);
        }

return padding;
    }
}) },
"favorite": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Dashboards.FavoriteField
 * @alias SUGAR.App.view.fields.DashboardsBaseFavoriteField
 * @extends View.Fields.Base.FavoriteField
 */
({
	// Favorite FieldTemplate (base)

// FIXME TY-1463 Remove this file.
    /**
     * Check first if the model exists before rendering.
     *
     * The dashboards currently reside in the Home module. The Home module does
     * not have favorites enabled. The dashboards do have favorites enabled.
     * In order to show the favorite icon on dashboards, we need to bypass
     * the favoritesEnabled check.
     *
     * @override
     * @private
     */
    _render: function() {
        // can't favorite something without an id
        if (!this.model.get('id')) {
            return null;
        }
        return app.view.Field.prototype._render.call(this);
    }
}) },
"hint-dashboardtitle": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Hint-dashboardtitle FieldTemplate (base)

extendsFrom: 'HomeDashboardtitleField',

hintStateKey: 'hintEnabled',

events: {
        'click .dropdown-toggle': 'toggleClicked',
        'click a[data-id]': 'navigateClicked',
        'click a[data-action=manager]': 'managerClicked',
        'click a[data-type=hint-dashboardtitle]': 'editClicked',
    },

/**
     * @inheritdoc
     */
    initialize: function(options) {
        options.context.set('forceNew', true);
        this._super('initialize', [options]);

if (this.isRecordView()) {
            if (this.getHintState()) {
                var model = this.context.parent.get('model');
                setTimeout(function() {
                    app.events.trigger('preview:render', model);
                }, 0);
            }

app.events.on('preview:close', function() {
                this.setHintState(false);
            }, this);
        }
    },

/**
     * Get hint state
     *
     * @return {string}
     */
    getHintState: function() {
        return app.user.lastState.get(this.hintStateKey);
    },

/**
     * Set hint state
     *
     * @param {string} value
     */
    setHintState: function(value) {
        app.user.lastState.set(this.hintStateKey, value);
    },

/**
     * Check if is record view
     *
     * @return {bool}
     */
    isRecordView: function() {
        var ctxParent = this.context.parent;
        return ctxParent && ctxParent.get('dataView') === 'record';
    },

/**
     * @inheritdoc
     */
    toggleClicked: function(event) {
        this._super('toggleClicked', [event]);
        var isNotAdded = this.$('.dropdown-menu [data-id=\'stage2\']').length < 1;
        if (this.isRecordView() && isNotAdded) {
            var template = `<li><a href=\'javascript:void(0);\' data-id=\'stage2\'>${Handlebars.Utils.escapeExpression(
                app.lang.get('LBL_HINT_PANEL')
            )}</a></li>`;
            this.$('.dropdown-menu').prepend(template);
        }
    },

/**
     * @inheritdoc
     */
    navigateClicked: function(evt) {
        this._super('navigateClicked', [evt]);
    },

/**
     * @inheritdoc
     */
    managerClicked: function() {
        this._super('managerClicked', []);
    },

/**
     * @inheritdoc
     */
    editClicked: function(evt) {
        this._super('editClicked', [evt]);
    },

/**
     * @inheritdoc
     */
    navigate: function(id, type) {
        var isHintState = id === 'stage2';

this.setHintState(isHintState);
        if (isHintState) {
            app.events.trigger('preview:render', this.context.parent.get('model'));
        } else {
            this._super('navigate', [id, type]);
        }
    }
}) }
}}
,
"views": {
"base": {
"about-headerpane": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Home.AboutHeaderpaneView
 * @alias SUGAR.App.view.views.BaseHomeAboutHeaderpaneView
 * @extends View.Views.Base.HeaderpaneView
 */
({
	// About-headerpane View (base)

extendsFrom: 'HeaderpaneView',

/**
     * @override
     *
     * Formats the title with the current server info.
     */
    _formatTitle: function(title) {
        var serverInfo = app.metadata.getServerInfo();
        var aboutVars = {
            product_name: serverInfo.product_name,
            version: serverInfo.version,
            custom_version: serverInfo.custom_version,
            build: serverInfo.build,
        };
        return app.lang.get(title, this.module, aboutVars);
    }
}) },
"webpage": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Home.WebpageView
 * @alias SUGAR.App.view.views.BaseHomeWebpageView
 * @extends View.View
 */
({
	// Webpage View (base)

plugins: ['Dashlet'],

/**
     * @property {Object} _defaultOptions
     * @property {number} _defaultOptions.limit Default number of rows displayed
     *   in a dashlet.
     *
     * @protected
     */
    _defaultOptions: {
        limit: 10,
    },

bindDataChange: function(){
        if(!this.meta.config) {
            this.model.on("change", this.render, this);
        }
    },

_render: function() {
        if (!this.meta.config) {
            this.dashletConfig.view_panel[0].height = this.settings.get('limit') * this.rowHeight;
        }
        app.view.View.prototype._render.call(this);
    },

initDashlet: function(view) {
        this.viewName = view;
        var settings = _.extend({}, this._defaultOptions, this.settings.attributes);
        this.settings.set(settings);
    },

loadData: function(options) {
        if (options && options.complete) {
            options.complete();
        }
    }
}) },
"dashboard-headerpane": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.HomeDashboardHeaderpaneView
 * @alias SUGAR.App.view.views.BaseHomeDashboardHeaderpaneView
 * @extends View.Views.Base.HeaderpaneMainView
 */
({
	// Dashboard-headerpane View (base)

extendsFrom: 'DashboardHeaderpaneMainView',

className: 'preview-headerbar home-headerpane',
    /**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['DashboardFiltersVisibility']);

this._super('initialize', [options]);

this._initProperties();

this._registerEvents();
    },

/**
     * Register events
     */
    _registerEvents: function() {
        this.listenTo(this.context, 'button:dashboard_filters:click', this.toggleDashboardFilter);
        this.listenTo(this.context, 'button:cancel_dashboard_filters:click', this.cancelDashboardFilters);
        this.listenTo(this.context, 'button:save_dashboard_filters:click', this.saveDashboardFilters);
        this.listenTo(this.context, 'dashboard-saved-success', this.saveDashboardSuccess);
        this.listenTo(this.context, 'dashboard-filter-mode-updated', this.filterModeState);
        this.listenTo(this.context, 'filter-groups-updated', this.enableSaveButton);
        this.listenTo(this.context, 'filter-field-updated', this.enableSaveButton);
        this.listenTo(this.context, 'toggle:change-visibility:button', this._toggleDashboardFiltersButton);
        this.listenTo(this.context, 'dashboard-filters-metadata-loaded', this._handleFiltersButtonVisibility);
        this.listenTo(this.context, 'dashboard:filter:broken', this.disableSaveButton);
        this.listenTo(this.model, 'sync', this.modelSync);

// we only extend events so that save works
        _.extend(this.events, this._getHeaderpaneEvents());
    },

/**
     * Initialize properties
     */
    _initProperties: function() {
        this.hasAccessToReports = app.acl.hasAccess('view', 'Reports');

this.initFiltersVisibilityProperties();
    },

/**
     * @inheritdoc
     */
    _renderHeader: function() {
        this._super('_renderHeader');

const showFiltersButton = this.$('[data-action="change-visibility"]');

showFiltersButton.off('click', _.bind(this.toggleDashboardFilter, this));
        showFiltersButton.on('click', _.bind(this.toggleDashboardFilter, this));
    },

/**
     * Model synced
     */
    modelSync: function() {
        if (!this.model || this.disposed) {
            return;
        }

const metadata = this.model ? this.model.get('metadata') : {};

if (!metadata || metadata.tabs) {
            return;
        }

const showFiltersButton = this.$('[data-action="change-visibility"]');
        const originalTitle = app.lang.get('LBL_DASHBOARD_FILTERS', 'Home');

showFiltersButton.removeClass('disabled');
        showFiltersButton.attr('data-original-title', originalTitle);
        showFiltersButton.attr('title', originalTitle);

const compatibleDashlets = _.filter(metadata.dashlets, (dashlet) => {
            return dashlet.view && dashlet.view.filtersDef;
        });

if (_.isEmpty(compatibleDashlets)) {
            this._filtersOnScreen = true;

this.toggleDashboardFilter();

const incompatibleTitle = app.lang.get('LBL_DASHBOARD_DASHLETS_INCOMPATIBLE', 'Home');

showFiltersButton.addClass('disabled');
            showFiltersButton.attr('title', incompatibleTitle);
            showFiltersButton.attr('data-original-title', incompatibleTitle);
        }
    },

/**
     * Show/hide the button given a set of rules
     *
     * @param {Object} filterGroups
     */
    _handleFiltersButtonVisibility: function(filterGroups) {
        // we execute this code on the next frame given the fact that _renderHeader has to be executed first
        // _renderHeader is being called when the model has been synced(same as this method) so we
        // have to make sure this one always executes after _renderHeader
        // this limitation came from the implementation of the headerpane controller
        _.debounce(() => {
            const metadata = this.model ? this.model.get('metadata') : {};

if (metadata.tabs) {
                return;
            }

this.modelSync();

const showFiltersButton = this.$('[data-action="change-visibility"]');
            const dashbordMain = this.layout.getComponent('dashboard-main');

showFiltersButton.toggleClass('!hidden', false);

if (!dashbordMain) {
                showFiltersButton.toggleClass('!hidden', true);
                return;
            }

const dashletMain = dashbordMain.getComponent('dashlet-main');

if (!dashletMain) {
                showFiltersButton.toggleClass('!hidden', true);
                return;
            }

if (this._filtersOnScreen) {
                const showFiltersButton = this.$('.report-visibility-button');

showFiltersButton.toggleClass('active', true);
            }

this._updateNumberOfFilters(filterGroups);
        })();
    },

/**
     * Get headerpane events
     *
     * @return {Object}
     */
    _getHeaderpaneEvents: function() {
        const parentDashboardHeaderpaneController = app.view._getController({
            type: 'view',
            name: 'dashboard-headerpane',
            module: 'Dashboards'
        });

if (typeof parentDashboardHeaderpaneController !== 'function' ||
            typeof parentDashboardHeaderpaneController.prototype !== 'object') {
            return {};
        }

return parentDashboardHeaderpaneController.prototype.events;
    },

/**
     * Cancel action
     */
    cancelDashboardFilters: function() {
        this.context.trigger('dashboard-filters-canceled');
        this.context.trigger('dashboard-filter-mode-changed', 'detail');
        this.context.trigger('dashboard-filter-mode-updated', 'detail');

this.manageCancelSaveButtons(false);
    },

/**
     * Save action
     */
    saveDashboardFilters: function() {
        this.disableSaveButton();
        this.context.trigger('dashboard-filters-save');
    },

/**
     * Save dashboard success
     */
    saveDashboardSuccess: function() {
        this.manageCancelSaveButtons(false);
    },

/**
     * Filter mode ON
     *
     * The Cancel/Save button should be visible in the headerpane
     */
    filterModeState: function(state) {
        const buttonsVisibility = state === 'edit';

this.manageCancelSaveButtons(buttonsVisibility);
    },

/**
     * Show/Hide Cancel/Save buttons
     *
     * @param {boolean} visibility
     */
    manageCancelSaveButtons: function(visibility) {
        this.$('[name="cancel_dashboard_filters"]').toggleClass('!hidden', !visibility);
        this.$('[name="save_dashboard_filters"]').toggleClass('!hidden', !visibility);
        this.$('.report-visibility-button').toggleClass('!hidden', visibility);
    },

/**
     * Filter group save button disabling
     */
    disableSaveButton: function() {
        this.$('[name="save_dashboard_filters"]').toggleClass('disabled', true);
    },

/**
     * Filter group save button enabling
     *
     * When a change is made, the save button should be enabled
     */
    enableSaveButton: function() {
        this.$('[name="save_dashboard_filters"]').toggleClass('disabled', false);
    },

/**
     * Show/Hide the filter container
     */
    toggleDashboardFilter: function() {
        const buttonDisabled = this.$('[data-action="change-visibility"]').hasClass('disabled');

if (buttonDisabled) {
            return;
        }

this._filtersOnScreen = !this._filtersOnScreen;

const showFiltersButton = this.$('.report-visibility-button');
        showFiltersButton.toggleClass('active', this._filtersOnScreen);

this.storeFilterPanelState(this._filtersOnScreen);

this.context.trigger('dashboard-filter-toggled', this._filtersOnScreen);
    },

/**
     * Update the displayed number of filters
     *
     * @param {Object} filterGroups
     */
    _updateNumberOfFilters: function(filterGroups) {
        const formattedFiltersNumber = this._getNumberOfFiltersToDisplay(filterGroups);
        const filtersBadgeEl = this.$('.report-filters-badge');

filtersBadgeEl.toggleClass('!hidden', true);

if (formattedFiltersNumber > 0 || _.isString(formattedFiltersNumber)) {
            filtersBadgeEl.toggleClass('!hidden', false);
            filtersBadgeEl.text(formattedFiltersNumber);
        }
    },

/**
     * Get a formatted display number
     *
     * @param {Object} filterGroups
     *
     * @return {string}
     */
    _getNumberOfFiltersToDisplay: function(filterGroups) {
        const maxNumberOfFiltersDisplayed = 9;
        const maxNumberOfFiltersLabel = '9+';

let formattedFiltersNumber = _.size(filterGroups);

if (formattedFiltersNumber > maxNumberOfFiltersDisplayed) {
            formattedFiltersNumber = maxNumberOfFiltersLabel;
        }

return formattedFiltersNumber;
    },

/**
     * @inheritdoc
     */
    _dispose: function() {
        const showFiltersButton = this.$('[data-action="change-visibility"]');
        showFiltersButton.off('click', _.bind(this.toggleDashboardFilter, this));

this._super('_dispose');
    },
}) },
"about-version": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Home.AboutVersionView
 * @alias SUGAR.App.view.views.BaseHomeAboutVersionView
 * @extends View.View
 */
({
	// About-version View (base)

/**
     * Version info string
     */
    versionInfo: '',

/**
     * Array of the user's products
     */
    products: [],

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

let version = app.metadata.getServerInfo().version;
        let template = Handlebars.compile(app.lang.get('LBL_ABOUT_VERSION', 'Home'));
        this.versionInfo = template({
            version: version,
        });

this.products = app.user.getProductNames();
    }
}) },
"search-dashboard-headerpane": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.SearchDashboardHeaderpaneView
 * @alias SUGAR.App.view.views.BaseSearchDashboardHeaderpaneView
 * @extends View.View
 */
({
	// Search-dashboard-headerpane View (base)

className: 'search-dashboard-headerpane',
    events: {
        'click a[name=collapse_button]' : 'collapseClicked',
        'click a[name=expand_button]' : 'expandClicked',
        'click a[name=reset_button]' : 'resetClicked'
    },

/**
     * Collapses all the dashlets in the dashboard.
     */
    collapseClicked: function() {
        this.context.trigger('dashboard:collapse:fire', true);
    },

/**
     * Expands all the dashlets in the dashboard.
     */
    expandClicked: function() {
        this.context.trigger('dashboard:collapse:fire', false);
    },

/**
     * Triggers 'facets:reset' event to reset the facets applied on the search.
     */
    resetClicked: function() {
        this.context.parent.trigger('facets:reset', true);
    }
}) },
"helplet": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Home.HelpletView
 * @alias SUGAR.App.view.views.BaseHomeHelpletView
 * @extends View.Views.Base.HelpletView
 */
({
	// Helplet View (base)

extendsFrom: 'HelpletView',

/**
     * Console IDs mapped to the console label and support site module name
     */
    _consoleMap: {
        'c108bb4a-775a-11e9-b570-f218983a1c3e': {
            lang: 'LBL_AGENT_WORKBENCH',
            supportModule: 'ServiceConsole'
        },
    },

/**
     * Method to fetch the help object from the app.help utility.
     */
    createHelpObject: function() {
        var helpUrl = {};
        // Console check
        var modelId = app.controller.context.get('modelId');
        if (this._consoleMap[modelId]) {
            helpUrl.plural_module_name = app.lang.get(this._consoleMap[modelId].lang);
        }
        this._super('createHelpObject', [helpUrl]);
    },

/**
     * Consoles need to link to documentation differently
     *
     * @param {Object} params
     * @return {Object} params
     * @override
     */
    sanitizeUrlParams: function(params) {
        var modelId = app.controller.context.get('modelId');
        if (this._consoleMap[modelId]) {
            params.module = this._consoleMap[modelId].supportModule;
            delete params.route;
        }
        return params;
    }
}) },
"dashboard-filters-edit": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.HomeDashboardFiltersEdit
 * @alias SUGAR.App.view.views.BaseHomeDashboardFiltersEdit
 * @extends View.View
 */
({
	// Dashboard-filters-edit View (base)

className: 'dashboard-filter-container bg-[--foreground-base] h-full overflow-hidden w-[230px]',
    plugins: ['DashboardFilters'],
    events: {
        'click [data-panelaction="createNewGroup"]': 'addNewFilterGroup',
    },

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

this._initProperties();
        this._registerEvents();
    },

/**
     * Init properties
     */
    _initProperties: function() {
        this._editMode = true;

this.initFiltersProperties();
    },

/**
     * Register events
     */
    _registerEvents: function() {
        this.listenTo(this.context, 'dashboard-filter-widget-clicked', this.manageFieldInFilterGroup);
        this.listenTo(this.context, 'dashboard-filter-group-selected', this.filtersGroupSelected);
        this.listenTo(this.context, 'dashboard-filter-group-name-changed', this.filterGroupNameChanged);
        this.listenTo(this.context, 'dashboard-filter-group-removed', this.removeFilterGroup);
        this.listenTo(this.context, 'dashboard-filter-group-invalid-save', this.invalidGroupSave);
    },

/**
     * Dashboard meta data has been loaded, we need to create the views
     */
    manageDashboardFilters: function(filterGroups) {
        this.handleDashboardFilters(filterGroups);

this._toggleAddFilterButton();
    },

/**
     * Toggle loading screen
     *
     * @param {boolean} toggle
     */
    toggleLoading: function(toggle) {
        this.$('.filters-skeleton-loader').toggleClass('hidden', !toggle);
        this.$('.dashboard-filters-edit-container').toggleClass('hidden', toggle);
    },

/**
     * Either add or remove a filter in the group
     *
     * @param {Object} data
     */
    manageFieldInFilterGroup: function(data) {
        if (!this._filterGroups || _.isEmpty(_.keys(this._filterGroups))) {
            return;
        }

this.context.trigger('dashboard-filters-interaction');

if (data.highlighted) {
            this._addFieldToFilterGroup(data);
        } else {
            this._removeFieldFromFilterGroup(data);
        }
    },

/**
     * Remove a group
     *
     * @param {string} groupId
     */
    removeFilterGroup: function(groupId) {
        if (!_.has(this._filterGroups, groupId) || !_.has(this._filterGroupsView, groupId)) {
            return;
        }

this.context.trigger('dashboard-filters-interaction');

this._filterGroupsView[groupId].dispose();

delete this._filterGroups[groupId];
        delete this._filterGroupsView[groupId];

const newSelectedGroup = _.chain(this._filterGroups).keys().first().value() || false;

this._activeFilterGroupId = newSelectedGroup;

this.notifyGroupsUpdated();
        this._toggleAddFilterButton();
    },

/**
     * Create new empty group from UI
     */
    addNewFilterGroup: function() {
        this.context.trigger('dashboard-filters-interaction');

this._createNewGroup();
        this.notifyGroupsUpdated();
        this._toggleAddFilterButton();
    },

/**
     * Triggered when a group name is updated
     *
     * @param {string} groupLabel
     * @param {string} groupId
     */
    filterGroupNameChanged: function(groupLabel, groupId) {
        if (!_.has(this._filterGroups, groupId)) {
            return;
        }

this._filterGroups[groupId].label = groupLabel;

this.notifyGroupsUpdated();
    },

/**
     * Change active filters group
     *
     * @param {string} filtersGroupId
     */
    filtersGroupSelected: function(filtersGroupId) {
        if (!_.has(this._filterGroups, filtersGroupId) || this._activeFilterGroupId === filtersGroupId) {
            return;
        }

this._activeFilterGroupId = filtersGroupId;

this.notifyGroupsSelected();
    },

/**
     * Show/Hide Add Filter Button
     */
    _toggleAddFilterButton: function() {
        const showNoFilterContainer = _.isEmpty(this._filterGroups);

this.$('[data-container="no-filter-container"]').toggleClass('hidden', !showNoFilterContainer);
        this.$('[data-container="add-container"]').toggleClass('hidden', !showNoFilterContainer);
        this.$('.edit-add-group').toggleClass('hidden', showNoFilterContainer);
    },

/**
     * Create a new filter group
     */
    _createNewGroup: function() {
        const groupId = app.utils.generateUUID();
        const groupMeta = {
            label: app.lang.get('LBL_DASHBOARD_FILTER_GROUP'),
            fieldType: false,
            fields: [],
            filterDef: {
                qualifier_name: 'not_empty',
            },
            fieldsDashlet: [],
        };

const isSelected = true;

this.createGroup(groupId, groupMeta, isSelected);
    },

/**
     * Add a filter to the selected group
     *
     * @param {Object} data
     */
    _addFieldToFilterGroup: function(data) {
        let filterGroup = this._filterGroups[this._activeFilterGroupId];

filterGroup.fields = _.without(filterGroup.fields, _.findWhere(filterGroup.fields, {
            dashletId: data.dashletId,
        }));

filterGroup.fieldType = data.field.type;

filterGroup.fields.push({
            dashletId: data.dashletId,
            fieldName: data.field.name,
            fieldDef: data.field,
            targetModule: data.targetModule,
            tableKey: data.filter.table_key,
            dashletLabel: data.dashletLabel,
            isRelated: data.isRelated,
            targetFieldModule: this.targetFieldModule,
            dashletSpecificData: data.dashletSpecificData,
        });

this._filterGroups[this._activeFilterGroupId] = filterGroup;
        const groupView = this._filterGroupsView[this._activeFilterGroupId];

groupView.toggleGroupInvalid(false);

this.notifyGroupsUpdated();
    },

/**
     * Remove a filter from the selected group
     *
     * @param {Object} data
     */
    _removeFieldFromFilterGroup: function(data) {
        let filterGroup = this._filterGroups[this._activeFilterGroupId];

filterGroup.fields = _.without(filterGroup.fields, _.findWhere(filterGroup.fields, {
            fieldName: data.field.name,
            dashletId: data.dashletId,
        }));

if (_.isEmpty(filterGroup.fields)) {
            filterGroup.fieldType = false;
            filterGroup.filterDef = {
                qualifier_name: 'not_empty',
            };
        }

this._filterGroups[this._activeFilterGroupId] = filterGroup;

this.notifyGroupsUpdated();
    },
}) },
"about-source-code": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Home.AboutSourceCodeView
 * @alias SUGAR.App.view.views.BaseHomeAboutSourceCodeView
 * @extends View.View
 */
({
	// About-source-code View (base)

/**
     * The server info object. See {@link Core.MetadataManager#getServerInfo}.
     *
     * @property {String}
     */
    serverInfo: null,

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

this.serverInfo = app.metadata.getServerInfo();
    }
}) },
"dashboard-filters-detail": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.HomeDashboardFiltersDetail
 * @alias SUGAR.App.view.views.BaseHomeDashboardFiltersDetail
 * @extends View.View
 */
({
	// Dashboard-filters-detail View (base)

className: 'dashboard-filter-container bg-[--foreground-base] h-full overflow-hidden w-[230px]',
    plugins: ['DashboardFilters'],
    events: {
        'click [data-action="switch-to-edit"]': 'switchToEditMode',
        'click [data-action="add-first-filter"]': 'addFirstFilter',
        'click [data-action="apply-runtime-filters"]': 'applyRuntimeFilters',
    },

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

this._initProperties();
        this._registerEvents();
    },

/**
     * @inheritdoc
     */
    _initProperties: function() {
        this._editMode = false;

this.initFiltersProperties();
    },

/**
     * @inheritdoc
     */
    _registerEvents: function() {
        this.listenTo(this.context, 'dashboard-filter-group-invalid-save', this.invalidGroupSave, this);
        this.listenTo(this.context, 'filter-operator-data-changed', this.enableApplyButton, this);
    },

/**
     * Dashboard meta data has been loaded, we need to create the views
     */
    manageDashboardFilters: function(filterGroups) {
        let showEditButton = false;
        let showApplyFiltersContainer = false;
        let showNoFilterContainer = false;
        let showAddContainer = false;

this.handleDashboardFilters(filterGroups);

this._hasGroupFilters = !_.isEmpty(this._filterGroups);
        this._hasEditAccess = app.acl.hasAccessToModel('edit', this.model);

let isTemplateDashboard = false;
        if (!_.isUndefined(this.model) && !_.isUndefined(this.model.get('is_template'))) {
            isTemplateDashboard = this.model.get('is_template');
        }
        showNoFilterContainer = !this._hasGroupFilters;
        showApplyFiltersContainer = this._hasGroupFilters;

if (this._hasEditAccess && !isTemplateDashboard) {
            showEditButton = this._hasGroupFilters;
            showAddContainer = !this._hasGroupFilters;
        }

this.$('[data-action="show-edit-button"]').toggleClass('hidden', !showEditButton);
        this.$('[data-container="apply-filters-container"]').toggleClass('hidden', !showApplyFiltersContainer);
        this.$('[data-container="no-filter-container"]').toggleClass('hidden', !showNoFilterContainer);
        this.$('[data-container="add-container"]').toggleClass('hidden', !showAddContainer);

this.toggleLoading(false);
    },

/**
     * Enable the apply filters button
     */
    enableApplyButton: function() {
        this.$('.apply-filters-btn').removeClass('disabled').removeAttr('disabled');
    },

/**
     * Disable the apply filters button
     */
    disableApplyButton: function() {
        this.$('.apply-filters-btn').addClass('disabled').attr('disabled', true);
    },

/**
     * Toggle loading screen
     *
     * @param {boolean} toggle
     */
    toggleLoading: function(toggle) {
        this.$('.filters-skeleton-loader').toggleClass('hidden', !toggle);
        this.$('.dashboard-filters-detail-container').toggleClass('hidden', toggle);
    },

/**
     * Add first filter and go to edit mode
     */
    addFirstFilter: function() {
        this.context.trigger('dashboard-filters-interaction');
        this.switchToEditMode();
    },

/**
     * Go to edit mode
     */
    switchToEditMode: function() {
        let canEdit = this._canAlterFilters();

if (canEdit) {
            this.context.trigger('dashboard-filter-mode-changed', 'edit');
            this.context.trigger('dashboard-filter-mode-updated', 'edit');
        } else {
            this._showCantAlterWarning();
        }
    },

/**
     * Apply runtime filters
     */
    applyRuntimeFilters: function() {
        let canEdit = this._canAlterFilters();

if (canEdit) {
            this.context.trigger('dashboard-filters-apply');
            this.context.trigger('refresh-dashlet-results');
            this.disableApplyButton();
        } else {
            this._showCantAlterWarning();
        }
    },

/**
     * Show cannot alter filters warning
     */
    _showCantAlterWarning: function() {
        app.alert.show('show_alter_alert', {
            level: 'warning',
            messages: app.lang.get('LBL_NO_ALTER_FILTERS', this.module),
            autoClose: true,
        });
    },

/**
     * Can or cannot edit filters
     *
     * @return {boolean}
     */
    _canAlterFilters: function() {
        const dashboardMain = this.closestComponent('dashboard-main');
        const dashletMain = dashboardMain ? dashboardMain.getComponent('dashlet-main') : false;
        const dashboardGrid = dashletMain ? dashletMain.getComponent('dashboard-grid') : false;

let canAlter = true;

if (dashboardGrid) {
            _.each(dashboardGrid._components, (dashletWrapper) => {
                _.each(dashletWrapper._components, (dashlet) => {
                    if (dashlet.isDashletLoading) {
                        canAlter = false;
                    }
                });
            });
        }

return canAlter;
    },

/**
     * Build the unique key for the dashboard
     *
     * @param {string} dashboardId
     *
     * @return {string}
     */
    _buildDashboardStateKey: function(dashboardId) {
        const module = this.module;

return lastStateKey;
    },

/**
     * Get last state for dashboard
     *
     * @param {string} lastStateKey
     *
     * @return {string}
     */
    _getDashboardLastState: function(lastStateKey) {
        const lastState = app.user.lastState.get(lastStateKey);

if (lastState) {
            return JSON.parse(lastState);
        }

return this._getDashboardDefaultState();
    },

/**
     * Get the default state for user
     *
     * @return {Object}
     */
    _getDashboardDefaultState: function() {
        const defaultState = {};

return defaultState;
    },
}) },
"hint-news-dashlet": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Hint-news-dashlet View (base)

plugins: ['Stage2CssLoader', 'Dashlet'],

/**
     * Classes that are responsible of COG icon on the dashlet.
     */
    cogIconDefaultClass: 'sicon-settings',
    cogIconLoadingClass: 'sicon-refresh sicon-is-spinning',

events: {
        'click [name=edit_button]': 'editClicked',
        'click [name=refresh_button]': 'refreshClicked',
        'click [data-action=newsClick]': 'trackNewsSelect'
    },

/**
     * Load threshold indicates how many news should be fake-loaded initially and on scroll.
     */
    loadThreshold: 5,

/**
     * Indicates if more news should be loaded. On initial load and on scroll
     * this variable should be true, but if we simply apply a search term, it should be false.
     */
    loadMore: true,

/**
     * Shows that how much did we scroll down. When a search is done, the scroll is reset.
     * We reapply the amount of scroll we did with the help of the scrollPosition.
     */
    scrollPosition: 0,

/**
     * Shows the order number of the last displayed news article.
     * searching will be done on all news.
     */
    lastDisplayedNewsIndex: 0,

/**
     * Initially and on loading we would like to show a placeholder for the user.
     * Since we start with loading the dependencies, we show the placeholder by default.
     */
    isHintRequestLoading: true,

/**
     * The list of news articles loaded.
     */
    news: [],

/**
     * Cache. We save any new articles loaded by the auto-updater.
     * We will show these news if the user click on the notification.
     */
    newArticles: [],

/**
     * Cache. We save the titles of the new artciles loaded by the auto-updater.
     * This will make it easier to identify if an article was already loeaded.
     */
    newArticleTitles: [],

/**
     * The list of news articles based on the search term.
     * searchResults will contain all news when the search is reset or there is no search term.
     */
    searchResults: [],

/**
     * The frequency of the auto-updater in seconds.
     */
    autoUpdaterIntervals: 60,

isNotHintUser: false,

/**
     * Holds the time duration of a valid data enrichment access token (1 hour).
     */
    tokenExpirationTimeOut: 60 * 60 * 1000,

initDashlet: function() {
        this.moduleName = this.context.get('module');
        this.getDependencies();
        this.isDarkMode = app.hint.isDarkMode();
        app.events.on('hint-news-dashlet:search', this.applySearchTerm, this);
        this.runAutoUpdater();
    },

/**
     * It changes the cog icon into a spinning set of arrows (default dashlet way)
     * if the news are being loaded, reverts on load.
     *
     * @param {boolean} loading Flag indicating if the news are being loaded.
     */
    toggleCogIcon: function(loading) {
        this.cogIconDefaultClass = 'sicon-settings';
        this.cogIconLoadingClass = 'sicon-refresh sicon-is-spinning';
        var iconToAdd = loading ? this.cogIconLoadingClass : this.cogIconDefaultClass;
        var iconToRemove = loading ? this.cogIconDefaultClass : this.cogIconLoadingClass;
        this.cogIcon.removeClass(iconToRemove).addClass(iconToAdd);
    },

/**
     * On selecting the edit from the dashlet menu, display the notification preferences.
     */
    editClicked: function() {
        app.drawer.open({
            layout: 'stage2-news-preferences-drawer'
        });
    },

/**
     * Dashlet Refresh event handler.
     */
    refreshClicked: function() {
        this.initNewsRequest();
    },

/**
     * An error handler used by the stage2 dependency calls.
     *
     * @param {string} message Error message to log.
     * @param {Object} error Error object holding information about the failed request.
     */
    setStage2errorCode: function(message, error) {
        app.logger.error(message.concat(JSON.stringify(error)));
        if (_.isUndefined(this.stage2errorCode)) {
            this.stage2errorCode = error.status;
            this.render();
        }
    },

/**
     * First dependency of the news request. The news will be get using the url retrieved here.
     */
    getStage2Url: function() {
        var self = this;
        app.api.call('GET', app.api.buildURL('stage2/params'), null, {
            success: function(data) {
                self.stage2url = data.enrichmentServiceUrl;
                self.notificationsServiceUrl = data.notificationsServiceUrl;
                self.initNewsRequest();
            },
            error: _.bind(this.setStage2errorCode, this, 'Failed to get Hint param: ')
        });
    },

/**
     * Second dependency of the news request. News can be retrieved only with a valid access token.
     */
    getStage2AccessToken: function() {
        app.api.call('create', app.api.buildURL('stage2/token'), null, {
            success: _.bind(function(data) {
                if (!_.isUndefined(data.errorMessage)) {
                    this.setStage2errorCode('Failed to get Hint access token: ' ,data);
                    return;
                }
                this.stage2accessTokenExpireDate = Date.now() + this.tokenExpirationTimeOut;
                this.stage2accessToken = data.accessToken;
                this.initNewsRequest();
            }, this),
            error: _.bind(this.setStage2errorCode, this, ' ')
        });
    },

getNotificationServiceToken: function() {
        app.api.call('create', app.api.buildURL('stage2/notificationsServiceToken'), null, {
            success: _.bind(function(data) {
                if (!_.isUndefined(data.errorMessage)) {
                    this.setStage2errorCode('Failed to get Notifications Service Token: ' ,data);
                    return;
                }
                var now = new Date();
                now.setTime(now.getTime() + data.ttlMs);
                this.notificationsAccessTokenExpireDate = now;
                this.notificationsAccessToken = data.accessToken;
                this.initNewsRequest();
            }, this),
            error: _.bind(function(err) {
                this.setStage2errorCode('Failed to get Notifications Service Token: ', err);
            }, this)
        });
    },

/**
     * Checks the instance license AND user license to determine whether the hint dashlet should be displayed
     */
    getLicenseMetadataForHint: function() {
        var self = this;
        var url = app.api.buildURL('hint/license/check');
        app.api.call('GET', url, null, {
            success: function(data) {
                const instanceHasHintLicense = data.isHintUser;
                const userHasHintLicense = app.hint.isHintUser();
                const isHintUser = instanceHasHintLicense && userHasHintLicense;

self.isNotHintUser = !isHintUser;
                self.render();
            },
            error: function(err) {
                app.logger.error('Failed to get Hint license metadata: ' + JSON.stringify(err));
            }
        });
    },

/**
     * Will load every dependency of the news.
     * Without a context we will not be able to define what kind of news should be loaded.
     * In order to be able to retrieve some news, we need a url to address and an access token.
     */
    getDependencies: function() {
        this.getStage2Url();
        this.getStage2AccessToken();
        this.getLicenseMetadataForHint();
    },

/**
     * Checks if the notifications service access token is expired or not.
     * A non existing token is considered an expired token.
     *
     * @return {boolean} True if the token is expired.
     */
    isNotificationsAccessTokenExpired: function() {
        var isExpired = true;
        if (this.notificationsAccessToken) {
            isExpired = this.notificationsAccessTokenExpireDate < new Date();
        }
        return isExpired;
    },

isAccessTokenExpired: function() {
        var isExpired = true;
        if (this.stage2accessToken) {
            isExpired = this.stage2accessTokenExpireDate < new Date();
        }
        return isExpired;
    },

/**
     * Checks all dependencies and if they are met a request will be made to retrieve the last 50 news.
     * In case the notifications service access token expires, it will get a new one and trigger this
     * method on a successful get.
     */
    initNewsRequest: function() {
        if (this.isAccessTokenExpired()) {
            this.stage2accessToken =  null;
            this.stage2accessTokenExpireDate =  null;
            this.getStage2AccessToken();
            return;
        } else {
            if (this.stage2url && this.stage2accessToken && this.notificationsServiceUrl) {
                if (this.isNotificationsAccessTokenExpired()) {
                    this.getNotificationServiceToken();
                } else {
                    this.getNews();
                }
            }
        }
    },

/**
     * If there is no active request for getting news it will send out a request.
     */
    getNews: function() {
        if (this.activeRequest) {
            this.activeRequest.abort();
        }

this.toggleCogIcon(true);

var headers = {
            authtoken: this.notificationsAccessToken
        };

if (this.etag) {
            headers['if-none-match'] = this.etag;
        }

this.activeRequest = $.ajax({
            type: 'GET',
            url: this.notificationsServiceUrl.concat('/getNotifications'),
            headers: headers,
            context: self,
            success: _.bind(this.loadNews, this),
            error: _.bind(this.handleFailedNewsFetch, this)
        });
    },

/**
     * Error handler for the news request. Error should be handled only if the
     * request was not aborted manually. Also if the retrieval fails it will try
     * to fetch the news again for a limited number of times.
     */
    handleFailedNewsFetch: function(error) {
        this.activeRequest = null;
        if (error && error.statusText !== 'abort') {
            app.logger.error('Failed to fetch news on Hint: ' + JSON.stringify(error));
            this.toggleCogIcon();
            // Retry to get new token duplets for accessToken and NotificationServiceToken. These
            // access tokens will be reset when the autoUpdater interval runs after 1 minute.
            this.stage2accessToken =  null;
            this.notificationsAccessToken =  null;
        }
    },

/**
     * Each article should receive the following information:
     * an id, used for searching the news titles for a specific value
     * hide flag, used to show/hide news on the page - initially all news are hidden
     * Aditionally we create a map of the news' titles for being able to use search.
     *
     * @param {Array} news A list of news articles.
     */
    extendNews: function(news) {
        this.articleTitles = [];
        _.each(news, function(article, i) {
            article.id = i;
            article.hide = true;
            this.articleTitles.push(article.title);
        }, this);
        this.news = news;
    },

/**
     * All the news will be marked as hidden.
     * Used when applying a search term.
     */
    markNewsAsHidden: function() {
        _.each(this.news, function(news) {
            news.hide = true;
        });
    },

/**
     * This is where the actual search is happening. The searchResults will hold a list of news,
     * these news all contain the search term in their titles. Based on the searchResults
     * we will be able to tell, which  articles need to be marked visible.
     * Important note: here we make the search on ALL available news, however we display none,
     * it is the responsibility of `toggleNews` to display news that are found in the results saved here.
     *
     * @param {string} searchTerm A phrase or a single word.
     */
    searchNews: function(searchTerm) {
        if (searchTerm) {
            this.searchResults = [];
            _.each(this.news, function(article) {
                if (article.title.toLowerCase().indexOf(searchTerm.toLowerCase()) > -1) {
                    this.searchResults.push(article);
                }
            }, this);
        } else {
            this.searchResults = this.news;
        }
    },

/**
     * If the user did search already the news assigned to the current context
     * we reapply it on the list. Note that `null` means that the user desires to see all news.
     */
    applyExistingSearchTerm: function() {
        var searchTerm = this.readFilter();

if (searchTerm) {
            app.events.trigger('hint-news-dashlet:apply', searchTerm);
        }

this.searchNews(searchTerm);
        this.toggleNews();
    },

/**
     * Initializes the search process when the user changes the assigned field.
     *
     * @param {string|null} searchTerm
     */
    applySearchTerm: function(searchTerm) {
        if (this.news.length && this.readFilter() !== searchTerm) {
            this.loadMore = false;
            this.scrollPosition = 0;
            this.markNewsAsHidden();
            this.writeFilter(searchTerm);
            this.searchNews(searchTerm);
            this.toggleNews();
        }
    },

/**
     * Saves the last known ETag for later use.
     * Some browsers may return the ETag in lowercase format.
     *
     * @param {Object} request The request for getting news notifications.
     */
    setEtag: function(request) {
        this.etag = request.getResponseHeader('ETag') || request.getResponseHeader('etag');
    },

/**
     * News request success handler. If we managed to retrieve news,
     * they need to be processed, and displayed. Only a limited number of news will be displayed.
     * The rest of the news will get rendered on scroll. Render will happen through filtering.
     * In case the request returns 'notmodified' statues, we do not make any changes except cog icon.
     *
     * @param {Object} data The response to the news request.
     * @param {string} state Success or notmodified.
     * @param {Object} request The current request.
     */
    loadNews: function(data, state, request) {
        this.activeRequest = null;

if (!this.disposed) {
            this.toggleCogIcon();
            this.isHintRequestLoading = false;

if (!this.autoRefresh) {
                this.runAutoUpdater();
                this.extendNews(data);
                this.applyExistingSearchTerm();
            } else if (state !== 'notmodified') {
                this.setEtag(request);

if (data && data.length) {
                    if (this.news.length) {
                        this.countAndCacheNewArticles(data);
                        if (this.scrollPosition === 0) {
                            this.insertLatestNewsIfAny();
                        }
                    } else {
                        this.extendNews(data);
                        this.applyExistingSearchTerm();
                    }
                } else {
                    app.events.trigger('hint-news-panel-filter:set', null);
                    this._render();
                }
            } else {
                this._render();
            }
        }
    },

/**
     * An article is new if it has not yet been added to the list of articles
     * that can be displayed in the dashlet.
     *
     * @param {Object} article An article from the news request response.
     * @return {boolean} True if the article is new.
     */
    isNewArticle: function(article) {
        return !_.contains(this.articleTitles, article.title);
    },

/**
     * Checks if there are any new articles and caches them for later use.
     *
     * @param {Array} data The newest news.
     */
    countAndCacheNewArticles: function(data) {
        var newArticles = [];
        var showNotifier = false;
        _.every(data, function(article) {
            var isNewArticle = !_.contains(this.articleTitles, article.title);
            if (isNewArticle && !_.contains(this.newArticleTitles, article.title)) {
                newArticles.push(article);
                this.newArticleTitles.push(article.title);
                showNotifier = true;
            }
            return isNewArticle;
        }, this);
        this.newArticles = _.union(newArticles, this.newArticles);

if (showNotifier) {
            this.showUpdateNotifier();
        }
    },

/**
     * If there are any new news, we will insert them on top of the list.
     * We need to update the counters which depend on the amount of the news.
     */
    insertLatestNewsIfAny: function() {
        if (this.newArticles.length) {
            var updatedNews = _.union(this.newArticles, this.news);
            this.lastDisplayedNewsIndex += this.newArticles.length;
            this.scrollPosition = 0;
            this.extendNews(updatedNews);
            this.applyExistingSearchTerm();
            this.newArticles = [];
            this.newArticleTitles = [];
        } else {
            this.render();
            /* The else part here should not happen with normal, standard workflow.
            Is is intended for use case, when etag status is not sent as expected.
            In other words: the same news are being sent again without a different status. */
        }
    },

/**
     * In a given interval of times, we will fetch news again and
     * update the list accordingly.
     */
    runAutoUpdater: function() {
        if (!this.autoRefresh) {
            this.autoRefresh = setInterval(
                _.bind(this.initNewsRequest, this),
                this.autoUpdaterIntervals * 1000
            );
        }
    },

/**
     * @return {string} A unique id for identifying the filter for the current context.
     */
    getFilterKey: function() {
        return 'news-filter-option*dashlet';
    },

/**
     * Retrieves the filter applyed by the user the last time.
     */
    readFilter: function() {
        return app.user.lastState.get(this.getFilterKey());
    },

/**
     * Saves the filter value as a user preference. `Null` means no filter.
     *
     * @param {string|null} filter
     */
    writeFilter: function(filter) {
        app.user.lastState.set(this.getFilterKey(), filter);
    },

/**
     * This method may returns 2 kind of lists of news.
     * One is returned upon scrolling:
     * we need to apply the current search term on the news to be displayed.
     * The other just on searching/filtering:
     * we apply the search term on all the news.
     *
     * @return {Array} A list of news based on the last displayed news.
     */
    getNextSegmentForFilter: function() {
        var start = this.loadMore ? this.lastDisplayedNewsIndex : 0;
        this.lastDisplayedNewsIndex += this.loadMore ? this.loadThreshold : 0;
        return this.searchResults;
    },

/**
     * News articles will be marked as hidden if their title does not contain the search term.
     * Applying a render will show/hide the corresponding news.
     */
    toggleNews: function() {
        var targetNews = this.getNextSegmentForFilter();
        _.each(targetNews, function(article) {
            if (_.findWhere(this.searchResults, {id: article.id})) {
                article.hide = false;
            }
        }, this);
        this.loadMore = false;
        this.render();
    },

/**
     * Verifies if there are any news marked as visible among the news that have been already loaded.
     */
    checkNewsToDisplay: function() {
        var segment = this.searchResults;
        this.displayNews = _.find(segment, function(article) {
            return article.hide === false;
        });
    },

/**
     * Dashlet component usually means just the content area, however we would like to identify
     * the content area together with the header above as the dashlet. In here we do that by assigning
     * a class to the wrapper element. We also search and remember the cog icon element.
     */
    setDashletElements: function() {
        if (!this.cogIcon || !this.cogIcon.length) {
            var fullDashlet = this.$el.parent().parent();
            fullDashlet.addClass('hint-news-dashlet');
            this.cogIcon = fullDashlet.find('[data-action=loading]');
        }
    },

/**
     * Responsible for showing the message about new articles being ready to be shown.
     * The element is flushed on each render, so we need to attach the event each time.
     */
    showUpdateNotifier: function() {
        if (this.scrollPosition > 0) {
            var notifierFadeOutTimeSecs = 10;
            var notifierEl = this.$('.hint-news-dashlet-auto-notifier');

notifierEl.removeClass('vanished');
            notifierEl.on('click', _.bind(function() {
                this.$('#newsarea').scrollTop(0);
                this.insertLatestNewsIfAny();
                notifierEl.addClass('vanished');
            }, this));
            setTimeout(function() {
                notifierEl.addClass('vanished');
            }, notifierFadeOutTimeSecs * 1000);
        }
    },

/**
     * Scroll event has to be bound each time to the element because with each render
     * te attached event handler is cleared. Then again on each render we want to maintain
     * the last known scroll position.
     */
    applyScrollingAndNotifier: function() {
        var newsarea = this.$('#newsarea');
        newsarea.scrollTop(this.scrollPosition);
    },

/**
     * @inheritdoc
     */
    _render: function(options) {
        this.setDashletElements();
        this.checkNewsToDisplay();
        this._super('_render', [options]);
        this.applyScrollingAndNotifier();
    },

/**
     * @inheritdoc
     * Detach event handlers. Shut down the auto-updater.
     */
    _dispose: function() {
        clearInterval(this.autoRefresh);
        app.events.off('hint-news-dashlet:search', this.applySearchTerm, this);
        this._super('_dispose');
    },

/**
     * Tracks which news has been opened by the user.
     *
     * @param {EventObject} event Event information
     */
    trackNewsSelect: function(event) {
        $.ajax({
            type: 'POST',
            data: {
                clickType: 'news',
                origin: this.context.get('module'),
                clickedURL: event.currentTarget.href,
                title: event.currentTarget.innerText,
                metricsToken: app.user.get('hintMetricsToken')
            },
            url: this.stage2url.concat('/url-click'),
            headers: {
                authToken: this.stage2accessToken
            },
            error: function(err) {
                app.logger.error('Failed to record news click event: ' + JSON.stringify(err));
            }
        });
    }
}) },
"twitter": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Home.TwitterView
 * @alias SUGAR.App.view.views.BaseHomeTwitterView
 * @extends View.View
 */
({
	// Twitter View (base)

plugins: ['Dashlet', 'RelativeTime', 'Connector'],
    limit : 20,
    events: {
        'click .connect-twitter': 'onConnectTwitterClick',
        'click .create-case': 'createCase'
    },

initDashlet: function() {
        this.initDashletConfig();
        var serverInfo = app.metadata.getServerInfo();
        this.tweet2case = serverInfo.system_tweettocase_on ? true : false;
        var limit = this.settings.get('limit') || this.limit;
        this.settings.set('limit', limit);
        this.cacheKey = 'twitter.dashlet.current_user_cache';
        var currentUserCache = app.cache.get(this.cacheKey);
        if (currentUserCache && currentUserCache.current_twitter_user_name) {
            self.current_twitter_user_name = currentUserCache.current_twitter_user_name;
        }
        if (currentUserCache && currentUserCache.current_twitter_user_pic) {
            self.current_twitter_user_pic = currentUserCache.current_twitter_user_pic;
        }
        this.caseCreateAcl = app.acl.hasAccess('edit','Cases');
    },

initDashletConfig: function() {
        this.moduleType = app.controller.context.get('module');
        this.layoutType = app.controller.context.get('layout');
        // if config view override with module specific
        if (this.meta.config && this.layoutType === 'record') {
            this.dashletConfig = app.metadata.getView(this.moduleType, this.name) || this.dashletConfig;
            // if record view that's not the Home module's record view, disable twitter name settings config
            if (this.moduleType !== 'Home' &&
                this.dashletConfig.config &&
                this.dashletConfig.config.fields) {
                // get rid of the twitter name field
                this.dashletConfig.config.fields = _.filter(this.dashletConfig.config.fields,
                    function(field) {
                        return field.name !== 'twitter';
                    });
            }
        }
    },

onConnectTwitterClick: function(event) {
        if ( !_.isUndefined(event.currentTarget) ) {
            event.preventDefault();
            var href = this.$(event.currentTarget).attr('href');
            app.bwc.login(false, function(response){
                window.open(href);
            });
        }
    },
    /**
     * opens case create drawer with case attributes prefilled
     * @param event
     */
    createCase: function (event) {
        var module = 'Cases';
        var layout = 'create';
        var self = this;

// set up and open the drawer
        app.drawer.reset();
        app.drawer.open({
            layout: layout,
            context: {
                create: true,
                module: module
            }
        }, function (refresh, createModelPointer) {
            if (refresh) {
                var collection = app.controller.context.get('collection');
                if (collection && collection.module === module) {
                    collection.fetch({
                        //Don't show alerts for this request
                        showAlerts: false
                    });
                }
            }
        });

this.setCreateModelFields(this.createModel, createValues);

this.createModel.on('sync', _.once(function (model) {
            // add activity stream on save
            var activity = app.data.createBean('Activities', {
                activity_type: "post",
                comment_count: 0,
                data: {
                    value: app.lang.get('LBL_TWITTER_SOURCE') +' '+ self.$(event.target).data('url'),
                    tags: []
                },
                tags: [],
                value: app.lang.get('LBL_TWITTER_SOURCE') +' '+ self.$(event.target).data('url'),
                deleted: "0",
                parent_id: model.id,
                parent_type: "Cases"
            });

activity.save();

//relate contact if we can find one
            var contacts = app.data.createBeanCollection('Contacts');
            var options = {
                filter: [
                    {
                        "twitter": {
                            "$equals": self.$(event.target).data('screen_name')
                        }
                    }
                ],
                success: function (data) {
                    if (data && data.models && data.models[0]) {
                        var url = app.api.buildURL('Cases', 'contacts', {id: self.createModel.id, relatedId: data.models[0].id, link: true});
                        app.api.call('create', url);
                    }
                }
            };
            contacts.fetch(options);
        }));
    },
    /**
     * sets fields on model according to acls
     * @param model
     * @param fields
     * @return {Mixed}
     */
    setCreateModelFields: function(model, fields) {
        var action = 'edit', module = 'Cases', ownerId = app.user.get('id');
        _.each(fields, function(value, fieldName) {
            if(app.acl.hasAccess(action, module, ownerId, fieldName)) {
                model.set(fieldName, value);
            }
        });

return model;
    },
    _render: function () {
        if (this.tweets || this.meta.config) {
            app.view.View.prototype._render.call(this);
        }
    },

bindDataChange: function(){
        if(this.model) {
            this.model.on('change', this.loadData, this);
        }
    },

/**
     * Gets twitter name from one of various fields depending on context
     * @return {string} twitter name
     */
    getTwitterName: function() {
        var mapping = this.getConnectorModuleFieldMapping('ext_rest_twitter', this.moduleType);
        var twitter =
                this.model.get('twitter') ||
                this.model.get(mapping.name) ||
                this.model.get('name') ||
                this.model.get('account_name') ||
                this.model.get('full_name');
        //workaround because home module actually pulls a dashboard instead of an
        //empty home model
        if (this.layoutType === 'records' || this.moduleType === 'Home') {
            twitter = this.settings.get('twitter');
        }
        if (!twitter) {
            return false;
        }
        twitter = twitter.replace(/ /g, '');
        this.twitter = twitter;
        return twitter;
    },

/**
     * Load twitter data
     *
     * @param {object} options
     * @return {boolean} `false` if twitter name could not be established
     */
    loadData: function(options) {
        if (this.disposed || this.meta.config) {
            return;
        }

this.screen_name = this.settings.get('twitter') || false;
        this.tried = false;

if (this.viewName === 'config') {
            return false;
        }
        this.loadDataCompleteCb = options ? options.complete : null;
        this.connectorCriteria = ['eapm_bean', 'test_passed'];
        this.checkConnector('ext_rest_twitter',
            _.bind(this.loadDataWithValidConnector, this),
            _.bind(this.handleLoadError, this),
            this.connectorCriteria);
    },

/**
     * With a valid connector, load twitter data
     *
     * @param {object} connector - connector will have been validated already
     */
    loadDataWithValidConnector: function(connector) {
        if (!this.getTwitterName()) {
            if (_.isFunction(this.loadDataCompleteCb)) {
                this.loadDataCompleteCb();
            }
            return false;
        }

var limit = parseInt(this.settings.get('limit'), 10) || this.limit,
            self = this;

// Search for links and turn them into hrefs
                        for (j = 0; j < tokenText.length; j++) {
                            if (tokenText[j].charAt(0) == 'h' && tokenText[j].charAt(1) == 't') {
                                tokenText[j] = "<a class='googledoc-fancybox' href=" + '"' + tokenText[j] + '"' + "target='_blank'>" + tokenText[j] + "</a>";
                            }
                        }

text = tokenText.join(' ');
                        tweets.push({id: id, name: name, screen_name: screen_name, profile_image_url: profile_image_url, text: text, source: sourceUrl, date: date, useAbsTime: useAbsTime});
                    }, this);
                }

self.tweets = tweets;
                if (!this.disposed) {
                    self.template = app.template.get(self.name + '.Home');
                    self.render();
                }
            },
            error: function(data) {
                if (self.tried === false) {
                    self.tried = true;
                    // twitter get returned error, so re-get connectors
                    var name = 'ext_rest_twitter';
                    var funcWrapper = function () {
                        self.checkConnector(name,
                            _.bind(self.loadDataWithValidConnector, self),
                            _.bind(self.handleLoadError, self),
                            self.connectorCriteria);
                    };
                    self.getConnectors(name, funcWrapper);
                }
                else {
                    self.handleLoadError(null);
                }
            },
            complete: self.loadDataCompleteCb
        });
    },

/**
     * Error handler for if connector validation errors at some point
     *
     * @param {object} connector
     */
    handleLoadError: function(connector) {
        if (this.disposed) {
            return;
        }
        this.showGeneric = true;
        this.errorLBL = app.lang.get('ERROR_UNABLE_TO_RETRIEVE_DATA');
        this.template = app.template.get(this.name + '.twitter-need-configure.Home');
        if (connector === null) {
            //Connector doesn't exist
            this.errorLBL = app.lang.get('LBL_ERROR_CANNOT_FIND_TWITTER') + this.twitter;
        }
        else if (!connector.test_passed && connector.testing_enabled) {
            //OAuth failed
            this.needOAuth = true;
            this.needConnect = false;
            this.showGeneric = false;
            this.showAdmin = app.acl.hasAccess('admin', 'Administration');
        }
        else if (!connector.eapm_bean) {
            //Not connected
            this.needOAuth = false;
            this.needConnect = true;
            this.showGeneric = false;
            this.showAdmin = app.acl.hasAccess('admin', 'Administration');
        }
        app.view.View.prototype._render.call(this);
        if (_.isFunction(this.loadDataCompleteCb)) {
            this.loadDataCompleteCb();
        }
    },

_dispose: function() {
        if (this.model) {
            this.model.off('change', this.loadData, this);
        }

app.view.View.prototype._dispose.call(this);
    }
}) },
"dashboard-filter-group-widget": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * Dashboard filter group widget
 *
 * @class View.Views.Base.HomeDashboardFilterGroupWidget
 * @alias SUGAR.App.view.views.BaseHomeDashboardFilterGroupWidget
 * @extends View.View
 */
({
	// Dashboard-filter-group-widget View (base)

events: {
        'change [data-action="new-group-name"]': 'onGroupNameChanged',
        'click [data-action="remove-group"]': 'onRemoveGroup',
        'click [data-action="collapse-group"]': 'onCollapseGroup',
        'click .filter-widget-headerpane': 'onCollapseGroup',
        'click [data-action="remove-field"]': 'onRemoveField',
        'click [data-action="dashlet-group-widget"]': 'onGroupClick',
        'mouseenter .dashlet-group-filter-widget': 'mouseOverGroup',
        'mouseleave .dashlet-group-filter-widget': 'mouseOutGroup',
    },

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

this._initProperties();
        this._registerEvents();
    },

/**
     * Property initialization, nothing to do for this view
     *
     */
    _initProperties: function() {
        const options = this.options;

this._groupId = options.groupId;
        this._groupMeta = options.groupMeta || {};
        this._widgetNo = options.widgetNo;
        this._editMode = options.editMode || false;

this._groupFields = this._groupMeta.fields || [];
        this._filterDef = this._groupMeta.filterDef || [];
        this._groupType = this._groupMeta.fieldType || '';
        this._groupLabel = this._groupMeta.label || `Filter ${this._widgetNo}`;
        this._isEmptyGroup = _.isEmpty(this._groupFields);

const metadata = this.model.get('metadata');

this._users = metadata.users || [];
        this._operators = metadata.runtimeFilterOperators || [];
        this._groupOperators = this._operators[this._groupType] || [];

this._filterOperatorWidget = false;

this._currentUserRestrictedGroup = !!this._groupMeta.currentUserRestrictedGroup;

this._checkACLRestrictions();
    },

/**
     * Register events
     */
    _registerEvents: function() {
        this.listenTo(this.context, 'filter-groups-updated', this.groupsUpdated, this);
        this.listenTo(this.context, 'filter-operator-data-changed', this.updateItemsCount, this);
        this.listenTo(this.context, 'dashboard-filter-group-selected', this.newGroupSelected, this);
    },

/**
     * Check ACL restrictions
     */
    _checkACLRestrictions: function() {
        if (this._currentUserRestrictedGroup) {
            this._disabledACL = true;
            return;
        }

const metadata = this.model.get('metadata');
        const restrictedGroups =  metadata && _.has(metadata, 'currentUserRestrictedDashlets') ?
            metadata.currentUserRestrictedDashlets : [];

const fieldNotAllowed = _.find(this._groupFields, (field) => {
            if (_.isArray(restrictedGroups) && restrictedGroups.includes(field.dashletId)) {
                return true;
            }

const hasListAccess = app.acl.hasAccess('list', field.targetModule);

if (!hasListAccess) {
                return true;
            }

if (field.isRelated && !_.isEmpty(field.fieldDef.ext2)) {
                return !(
                    app.acl.hasAccess('view', field.fieldDef.ext2) &&
                    app.acl.hasAccess('list', field.fieldDef.ext2) &&
                    app.acl.hasAccess('read', field.fieldDef.ext2, {field: field.fieldName})
                );
            }  else if (field.isRelated && _.has(field, 'tableKey')) {
                const checkRelateAccess = function(relatedFieldsMeta) {
                    let access = true;

if (relatedFieldsMeta) {
                        const module = relatedFieldsMeta.module;
                        const relatedField = relatedFieldsMeta.fieldName;

if (module && relatedField) {
                            const fieldAccess = (
                                app.acl.hasAccess('view', module) &&
                                app.acl.hasAccess('list', module) &&
                                app.acl.hasAccess('read', module, {field: relatedField})
                            );

access = fieldAccess;
                        }
                    }

return access;
                };

const directlyRelatedFieldsMeta = this._getRelatedFieldMeta(field);
                const relatedFieldsMeta = this._getRelatedFieldMetaRel(field);

if (!directlyRelatedFieldsMeta && !relatedFieldsMeta) {
                    return false;
                }

let fieldhasAccess = true;

fieldhasAccess = checkRelateAccess(directlyRelatedFieldsMeta);

if (fieldhasAccess) {
                    fieldhasAccess = checkRelateAccess(relatedFieldsMeta);
                }

return !fieldhasAccess;
            } else {
                return !(
                    app.acl.hasAccess('view', field.targetModule) &&
                    app.acl.hasAccess('list', field.targetModule) &&
                    app.acl.hasAccess('read', field.targetModule, {field: field.fieldName})
                );
            }
        });

if (!_.isEmpty(fieldNotAllowed)) {
            this._disabledACL = true;
        }
    },

/**
     * Get the full table list for a specific field
     *
     * @param {Object} field - metadata of the field
     */
    _getFullTableListForField: function(field) {
        const meta = this.model.get('metadata');

if (!meta) {
            return false;
        }

if (!_.has(meta, 'dashlets')) {
            return false;
        }

const dashlets = meta.dashlets;

if (!dashlets) {
            return false;
        }

const fieldDashlet = _.find(dashlets, item => item.id === field.dashletId);

if (!fieldDashlet || !_.has(fieldDashlet, 'view') || !_.has(fieldDashlet.view, 'fullTableList')) {
            return false;
        }

const fullTableList = fieldDashlet.view.fullTableList;

if (!fullTableList) {
            return false;
        }

return fullTableList;
    },

/**
     * Metadata for the related fields without an Ext2 table
     *
     * @param {Object} field - metadata of the field
     */
    _getRelatedFieldMetaRel: function(field) {
        if (!_.isString(field.tableKey)) {
            return false;
        }

const linkPath = field.tableKey.split(':');

if (linkPath.length < 2) {
            return false;
        }

const fullTableList = this._getFullTableListForField(field);

if (!fullTableList) {
            return false;
        }

const linkDef = fullTableList[field.tableKey];

if (!linkDef) {
            return false;
        }

if (!_.has(linkDef, 'module')) {
            return false;
        }

const linkDefKey = 'link_def';
        const relationshipNameKey = 'relationship_name';
        const beanSideKey = 'bean_is_lhs';
        const rhsModuleKey = 'rhs_module';
        const lhsModuleKey = 'lhs_module';
        const lhsFieldKey = 'lhs_key';
        const rhsFieldKey = 'rhs_key';
        const linkNameKey = 'name';

if (!_.has(linkDef, 'module')) {
            return false;
        }

if (!_.has(linkDef, linkDefKey)) {
            return false;
        }

if (!_.has(linkDef[linkDefKey],[relationshipNameKey])) {
            return false;
        }

const linkMeta = linkDef[linkDefKey];

if (!_.has(linkMeta, beanSideKey) || !_.has(linkMeta, linkNameKey)) {
            return false;
        }

const relationshipName = linkMeta[relationshipNameKey];

if (!relationshipName) {
            return false;
        }

const relMeta = app.metadata.getRelationship(relationshipName);

if (!relMeta || !_.has(relMeta, rhsModuleKey) || !relMeta[rhsModuleKey]) {
            return false;
        }

const isInLhs = linkMeta[beanSideKey];

let module = '';
        let fieldName = '';

if (isInLhs && _.has(relMeta, lhsModuleKey)) {
            module = relMeta[lhsModuleKey];
            fieldName = relMeta[lhsFieldKey];
        } else if (_.has(relMeta, rhsModuleKey)) {
            module = relMeta[rhsModuleKey];
            fieldName = relMeta[rhsFieldKey];
        }

if (module && fieldName) {
            return {
                'module': module,
                'fieldName': fieldName,
            };
        }

return false;
    },

/**
     * Metadata for the related fields without an Ext2 table
     *
     * @param {Object} field - metadata of the field
     */
    _getRelatedFieldMeta: function(field) {
        if (!_.isString(field.tableKey)) {
            return false;
        }

const linkPath = field.tableKey.split(':');

if (linkPath.length < 2) {
            return false;
        }

const fullTableList = this._getFullTableListForField(field);

if (!fullTableList) {
            return false;
        }

const linkDef = fullTableList[field.tableKey];

if (!linkDef) {
            return false;
        }

if (!_.has(linkDef, 'module')) {
            return false;
        }

const targetModule = linkDef.module;

return {
            'module': targetModule,
            'fieldName': field.fieldName,
        };
    },

/**
     * Update items count
     */
    updateItemsCount: function() {
        if (!this._filterOperatorWidget) {
            return;
        }

const itemsCount = this._filterOperatorWidget.getItemsCount();

this.$('.items-selected-nr').html(itemsCount);
    },

/**
     * Listen when a group is updated
     *
     * @param {Object} filterGroups
     * @param {string} activeFilterGroupId
     * @param {boolean} isGroupClicked
     */
    groupsUpdated: function(filterGroups, activeFilterGroupId, isGroupClicked) {
        this._isSelected = this._groupId === activeFilterGroupId;

if (_.isUndefined(filterGroups[activeFilterGroupId])) {
            return;
        }

const {
            fieldType,
            fields,
            filterDef,
        } = filterGroups[this._groupId];

this._groupType = fieldType;
        this._groupFields = fields;
        this._filterDef = filterDef;
        this._groupOperators = this._operators[fieldType] || [];
        this._isEmptyGroup = _.isEmpty(this._groupFields);

const groupClicked = isGroupClicked ? isGroupClicked : false;

if (this._isSelected && !groupClicked) {
            this.render();
        }

this._toggleGroupActive(this._isSelected);

if (this._isSelected && this._isEmptyGroup && this._editMode) {
            this._highlightInput();
        }

if (!groupClicked) {
            this._updateFilterOperatorWidget();
        }
    },

/**
     * Handle text changed
     *
     * @param {UIEvent} e
     */
    onGroupNameChanged: function(e) {
        this._groupLabel = e.target.value;
        this.context.trigger('dashboard-filter-group-name-changed', this._groupLabel, this._groupId);
        this.context.trigger('dashboard-filters-interaction');
    },

/**
     * On group hover in
     *
     * @param {UIEvent} e
     */
    mouseOverGroup: function(e) {
        if (this._editMode) {
            return;
        }

const highlight = true;

this._groupHighlight(highlight, e);
    },

/**
     * On group hover in
     *
     * @param {UIEvent} e
     */
    mouseOutGroup: function(e) {
        if (this._editMode) {
            return;
        }

const highlight = false;

this._groupHighlight(highlight, e);
    },

/**
     *  Highlight current group and notify it's dashlets
     *
     * @param {boolean} highlight
     * @param {UIEvent} element
     */
    _groupHighlight: function(highlight, element) {
        this.$(element.currentTarget).toggleClass('hover-highlight', highlight);

if (!this._groupMeta || !_.has(this._groupMeta, 'fields') || this._groupMeta.fields === 0) {
            return;
        }

this._notifyGroupHighlight(highlight);
    },

/**
     * Notify to show/hide the highlight
     *
     * @param {boolean} highlight
     */
    _notifyGroupHighlight: function(highlight) {
        const dashletIds = _.pluck(this._groupMeta.fields, 'dashletId');

this.context.trigger('dashboard-filter-group-highlight', dashletIds, highlight);
    },

/**
     * On group click
     *
     * @param {UIEvent} e
     */
    onGroupClick: function(e) {
        if (this._disabledACL) {
            return;
        }

const $el = this.$('.dashlet-collapse-group');
        const collapsed = $el.is('.sicon-chevron-down');

if (collapsed) {
            this.onCollapseGroup(e);
        }

this.context.trigger('dashboard-filter-group-selected', this._groupId);
    },

/**
     * A new group was selected
     *
     * @param {string} selectedGroupId
     */
    newGroupSelected: function(selectedGroupId) {
        this._isSelected = this._groupId === selectedGroupId;

this._toggleGroupActive(this._isSelected);
    },

isValid: function() {
        return this._filterOperatorWidget && this._filterOperatorWidget.isValid();
    },

/**
     * Mark the group as invalid
     *
     * @param {boolean} show
     */
    toggleGroupInvalid: function(show) {
        this.$('.dashlet-group-filter-widget').toggleClass('dashlet-group-invalid', show);
    },

/**
     * Handle click on the remove group
     *
     * @param {UIEvent} e
     */
    onCollapseGroup: function(e) {
        if (e.target && e.target.dataset && e.target.dataset.action === 'new-group-name') {
            return;
        }

const $el = this.$('.dashlet-collapse-group');
        const collapsed = $el.is('.sicon-chevron-up');

$el.toggleClass('sicon-chevron-down', collapsed);
        $el.toggleClass('sicon-chevron-up', !collapsed);

this.$('.empty-group-message').toggleClass('hidden', collapsed);
        this.$('[data-container="fields-container"]').toggleClass('hidden', collapsed);
        this.$('[data-container="operators-container"]').toggleClass('hidden', collapsed);
        this.$('[data-container="collapsed-filter-group"]').toggleClass('hidden', !collapsed);
        this.$('[data-container="expanded-filter-group"]').toggleClass('hidden', collapsed);
        this.$('.dashlet-group-filter-widget').toggleClass('dashlet-group-filter-widget-collapsed', collapsed);
        this.$('.dashboard-group-edit-label').toggleClass('dashboard-group-edit-name', !collapsed);

if (e) {
            e.stopPropagation();
        }
    },

/**
     * Handle click on the remove group
     *
     * @param {UIEvent} e
     */
    onRemoveGroup: function(e) {
        this.context.trigger('dashboard-filter-group-removed', this._groupId);

e.preventDefault();
        e.stopPropagation();
        e.stopImmediatePropagation();
    },

/**
     * Handle click on the field to be removed
     *
     * @param {UIEvent} e
     */
    onRemoveField: function(e) {
        const fieldName = e.currentTarget.getAttribute('data-field-name');
        const dashletId = e.currentTarget.getAttribute('data-dashlet-id');

const fieldMeta = {
            dashletId,
            field: {
                name: fieldName,
            },
            highlighted: false,
        };

this.context.trigger('dashboard-filter-widget-clicked', fieldMeta);

e.preventDefault();
        e.stopPropagation();
        e.stopImmediatePropagation();
    },

/**
     * Select and highlight the input text
     */
    _highlightInput: function() {
        const inputEl = this.$('[data-action="new-group-name"]');

inputEl.focus();
        inputEl.select();
    },

/**
     * Update filter operator widget
     */
    _updateFilterOperatorWidget: function() {
        this._deleteFilterOperatorWidget();
        this._createFilterOperatorWidget();
    },

/**
     * Delete filter operator widget
     */
    _deleteFilterOperatorWidget: function() {
        if (this._filterOperatorWidget) {
            this._filterOperatorWidget.dispose();
            this._filterOperatorWidget = false;
        }
    },

/**
     * Create filter operator widget
     */
    _createFilterOperatorWidget: function() {
        const field = _.first(this._groupFields);

if (_.isUndefined(field)) {
            return;
        }

this._filterOperatorWidget = app.view.createView({
            type: 'filter-operator-widget',
            context: this.context,
            operators: this._groupOperators,
            users: this._users,
            filterData: this._filterDef,
            fieldType: this._groupType,
            filterId: this._groupId,
            seedFieldDef: field.fieldDef,
            seedModule: field.targetModule,
            tooltipTitle: this._groupLabel,
            manager: this,
        });

this._filterOperatorWidget.render();

this.$('[data-container="operators-container"]').append(this._filterOperatorWidget.$el);
        this.$('.runtime-filter-summary-text').html(this._filterOperatorWidget.getSummaryText());
        this.$('[data-tooltip="filter-summary"]').tooltip({
            delay: 200,
            container: 'body',
            placement: 'bottom',
            title: _.bind(this._filterOperatorWidget.getTooltipText, this._filterOperatorWidget),
            html: true,
            trigger: 'hover',
        });

this.updateItemsCount();
    },

/**
     * Handle the group style if is active/inactive
     *
     * @param {boolean} isActive
     */
    _toggleGroupActive: function(isActive) {
        isActive = isActive && this._editMode;

this._toogleGroupSelected(isActive);
    },

/**
     * Handle selected group
     *
     * @param {boolean} selected
     */
    _toogleGroupSelected: function(selected) {
        this.$('.dashlet-group-filter-widget').toggleClass('dashlet-group-active', selected);
    },

/**
     * @inheritdoc
     */
    _dispose: function() {
        this._deleteFilterOperatorWidget();

this._super('_dispose');
    },
}) },
"about-language-packs": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Home.AboutLanguagePacksView
 * @alias SUGAR.App.view.views.BaseHomeAboutLanguagePacksView
 * @extends View.View
 */
({
	// About-language-packs View (base)

linkTemplate: null,

/**
     * @inheritdoc
     *
     * Initializes the link template to be used on the render.
     */
    initialize: function(opts) {
        app.view.View.prototype.initialize.call(this, opts);

this.linkTemplate = app.template.getView(this.name + '.link', this.module);
    },

/**
     * @inheritdoc
     *
     * Override the title to pass the context with the server info.
     */
    _renderHtml: function() {
        _.each(this.meta.providers, function(provider) {
            provider.link = this.linkTemplate(provider);
        }, this);

app.view.View.prototype._renderHtml.call(this);
    }
}) },
"module-menu": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * Module menu provides a reusable and easy render of a module Menu.
 *
 * This also helps doing customization of the menu per module and provides more
 * metadata driven features.
 *
 * @class View.Views.Base.Home.ModuleMenuView
 * @alias SUGAR.App.view.views.BaseHomeModuleMenuView
 * @extends View.Views.Base.ModuleMenuView
 */
({
	// Module-menu View (base)

extendsFrom: 'ModuleMenuView',

plugins: ['Previewable'],

/**
     * The collection used to list dashboards on the dropdown.
     *
     * This is initialized on {@link #_initCollections}.
     *
     * @property
     * @type {Data.BeanCollection}
     */
    dashboards: null,

/**
     * The collection used to list the recently viewed on the dropdown,
     * since it needs to use a {@link Data.MixedBeanCollection}
     *
     * This is initialized on {@link #_initCollections}.
     *
     * @property
     * @type {Data.MixedBeanCollection}
     */
    recentlyViewed: null,

/**
     * Default settings used when none are supplied through metadata.
     *
     * Supported settings:
     * - {Number} dashboards Number of dashboards to show on the dashboards
     *   container. Pass 0 if you don't want to support dashboards listed here.
     * - {Number} favorites Number of records to show on the favorites
     *   container. Pass 0 if you don't want to support favorites.
     * - {Number} recently_viewed Number of records to show on the recently
     *   viewed container. Pass 0 if you don't want to support recently viewed.
     * - {Number} recently_viewed_toggle Threshold of records to use for
     *   toggling the recently viewed container. Pass 0 if you don't want to
     *   support recently viewed.
     *
     * Example:
     * ```
     * // ...
     * 'settings' => array(
     *     'dashboards' => 10,
     *     'favorites' => 5,
     *     'recently_viewed' => 9,
     *     'recently_viewed_toggle' => 4,
     *     //...
     * ),
     * //...
     * ```
     *
     * @protected
     */
    _defaultSettings: {
        dashboards: 50,
        favorites: 3,
        recently_viewed: 10,
        recently_viewed_toggle: 3
    },

/**
     * Key for storing the last state of the recently viewed toggle.
     *
     * @type {String}
     */
    TOGGLE_RECENTS_KEY: 'more',

/**
     * The lastState key to use in order to retrieve or save last recently
     * viewed toggle.
     */
    _recentToggleKey: null,

/**
     * @inheritdoc
     *
     * Initializes the collections that will be used when the dropdown is
     * opened.
     *
     * Initializes Legacy dashboards.
     *
     * Sets the recently viewed toggle key to be ready to use when the dropdown
     * is opened.
     */
    initialize: function(options) {
        this._super('initialize', [options]);

this.events = _.extend({}, this.events, {
            'click [data-toggle="recently-viewed"]': 'handleToggleRecentlyViewed'
        });

this._initCollections();

this.meta.last_state = { id: 'recent' };
        this._recentToggleKey = app.user.lastState.key(this.TOGGLE_RECENTS_KEY, this);

this._setLogoImage();
    },

/**
     * Sets the logo for Sugar top left corner
     * @param imageUrl
     * @protected
     */
    _setLogoImage: function(imageUrl) {
        this.logoImage = imageUrl ? imageUrl : app.utils.buildUrl('styleguide/assets/img/sugar-cube-black.svg');
    },

/**
     * Additional 'data:preview' callbacks to be invoked from Previewable
     *
     * @param hasChanges
     * @param data
     */
    dataPreviewCallbacks: function(hasChanges, data) {
        if (_.contains(data.properties, 'logoImage')) {
            this._setLogoImage(this.logoImage);
            this.render();
        }
    },

/**
     * Creates the collections needed for list of dashboards and recently
     * viewed.
     *
     * The views' collection is pointing to the Home module and we might need
     * to use that later for something that could be populated from that
     * module. Therefore, we create other collections to be used for extra
     * information that exists on the Home dropdown menu.
     *
     * @chainable
     * @private
     */
    _initCollections: function() {

this.dashboards = app.data.createBeanCollection('Dashboards');
        this.recentlyViewed = app.data.createMixedBeanCollection();

return this;
    },

/**
     * @inheritdoc
     *
     * Adds the title and the class for the Home module (Sugar cube).
     */
    _renderHtml: function() {
        this._super('_renderHtml');

this.$el.attr('title', app.lang.get('LBL_TABGROUP_HOME', this.module));
        this.$el.addClass('home btn-group py-2 px-5');
    },

/**
     * @override
     *
     * Populates all available dashboards when opening the menu. We override
     * this function without calling the parent one because we don't want to
     * reuse any of it.
     *
     * **Attention** We only populate up to 20 dashboards.
     *
     * TODO We need to keep changing the endpoint until SIDECAR-493 is
     * implemented.
     */
    populateMenu: function() {
        var pattern = /^(LBL|TPL|NTC|MSG)_(_|[a-zA-Z0-9])*$/;
        this.$('.active').removeClass('active');
        this.dashboards.fetch({
            'limit': this._settings['dashboards'],
            'filter': [{
                'dashboard_module': 'Home',
                '$or': [
                    {'$favorite': ''},
                    {'default_dashboard': 1}
                ]
            }],
            'order_by': {'date_modified': 'DESC'},
            'showAlerts': false,
            'success': _.bind(function(data) {
                var module = this.module;
                _.each(data.models, function(model) {
                    if (pattern.test(model.get('name'))) {
                        model.set('name', app.lang.get(model.get('name'), module));
                    }
                    // hardcode the module to `Home` due to different link that
                    // we support
                    model.module = 'Home';
                });

this._renderPartial('dashboards', {
                    collection: this.dashboards,
                    active: this.context.get('module') === 'Home' && this.context.get('model')
                });

}, this),
            'endpoint': function(method, model, options, callbacks) {
                app.api.records(method, 'Dashboards', model.attributes, options.params, callbacks);
            }
        });

this.populateRecentlyViewed(false);
    },

/**
     * Populates recently viewed records with a limit based on last state key.
     *
     * Based on the state it will read 2 different metadata properties:
     *
     * - `recently_viewed_toggle` for the value to start toggling
     * - `recently_viewed` for maximum records to retrieve
     *
     * Defaults to `recently_viewed_toggle` if no state is defined.
     *
     * @param {Boolean} focusToggle Whether to set focus on the toggle after rendering
     */
    populateRecentlyViewed: function(focusToggle) {

var visible = app.user.lastState.get(this._recentToggleKey),
            threshold = this._settings['recently_viewed_toggle'],
            limit = this._settings[visible ? 'recently_viewed' : 'recently_viewed_toggle'];

if (limit <= 0) {
            return;
        }

var modules = this._getModulesForRecentlyViewed();
        if (_.isEmpty(modules)) {
            return;
        }

this.recentlyViewed.fetch({
            'showAlerts': false,
            'fields': ['id', 'name'],
            'date': '-7 DAY',
            'limit': limit,
            'module_list': modules,
            'success': _.bind(function(data) {
                this._renderPartial('recently-viewed', {
                    collection: this.recentlyViewed,
                    open: !visible,
                    showRecentToggle: data.models.length > threshold || data.next_offset !== -1
                });
                if (focusToggle && this.isOpen()) {
                    // put focus back on toggle after renderPartial
                    this._focusRecentlyViewedToggle();
                }
            }, this),
            'endpoint': function(method, model, options, callbacks) {
                var url = app.api.buildURL('recent', 'read', options.attributes, options.params);
                app.api.call(method, url, null, callbacks, options.params);
            }
        });

return;
    },

/**
     * Set focus on the recently viewed toggle
     * @private
     */
    _focusRecentlyViewedToggle: function() {
        this.$('[data-toggle="recently-viewed"]').focus();
    },

/**
     * Retrieve a list of modules where support for recently viewed records is
     * enabled and current user has access to list their records.
     *
     * Dashboards is discarded since it is already populated by default on the
     * drop down list {@link #populateMenu}.
     *
     * To disable recently viewed items for a specific module, please set the
     * `recently_viewed => 0` on:
     *
     * - `{custom/,}modules/{module}/clients/{platform}/view/module-menu/module-menu.php`
     *
     * @return {Array} List of supported modules names.
     * @private
     */
    _getModulesForRecentlyViewed: function() {
        // FIXME: we should find a better option instead of relying on visible
        // modules
        var modules = app.metadata.getModuleNames({filter: 'visible', access: 'list'});

modules = _.filter(modules, function(module) {
            var view = app.metadata.getView(module, 'module-menu');
            return !view || !view.settings || view.settings.recently_viewed > 0;
        });

return modules;
    },

/**
     * Handles the toggle of the more recently viewed mixed records.
     *
     * This triggers a refresh on the data to be retrieved based on the amount
     * defined in metadata for the given state. This way we limit the amount of
     * data to be retrieve to the current state and not getting always the
     * maximum.
     *
     * @param {Event} event The click event that triggered the toggle.
     */
    handleToggleRecentlyViewed: function(event) {
        app.user.lastState.set(this._recentToggleKey, Number(!app.user.lastState.get(this._recentToggleKey)));
        this.populateRecentlyViewed(true);
        event.stopPropagation();
    }
}) },
"top-activity-user": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Home.TopActivityUserView
 * @alias SUGAR.App.view.views.BaseHomeTopActivityUserView
 * @extends View.View
 */
({
	// Top-activity-user View (base)

plugins: ['Dashlet', 'GridBuilder'],
    events: {
        'change select[name=filter_duration]': 'filterChanged'
    },
    /**
     * Track if current user is manager.
     */
    isManager: false,
    initDashlet: function(viewName) {
        this.collection = new app.BeanCollection();
        this.isManager = app.user.get('is_manager');
        if(!this.meta.config) {
            this.collection.on("reset", this.render, this);
        }
    },
    _mapping: {
        meetings: {
            icon: 'sicon-message',
            label: 'LBL_MOST_MEETING_HELD'
        },
        inbound_emails: {
            icon: 'sicon-email',
            label: 'LBL_MOST_EMAILS_RECEIVED'
        },
        outbound_emails: {
            icon: 'sicon-email',
            label: 'LBL_MOST_EMAILS_SENT'
        },
        calls: {
            icon: 'sicon-phone',
            label: 'LBL_MOST_CALLS_MADE'
        }
    },
    loadData: function(params) {
        if(this.meta.config) {
            return;
        }
        var url = app.api.buildURL('mostactiveusers', null, null, {days: this.settings.get("filter_duration")}),
            self = this;
        app.api.call("read", url, null, {
            success: function(data) {
                if(self.disposed) {
                    return;
                }
                var models = [];
                _.each(data, function(attributes, module){
                    if(_.isEmpty(attributes)) {
                        return;
                    }
                    var model = new app.Bean(_.extend({
                        id: _.uniqueId('aui')
                    }, attributes));
                    model.module = module;
                    model.set("name", model.get("first_name") + ' ' + model.get("last_name"));
                    model.set("icon", self._mapping[module]['icon']);
                    var template = Handlebars.compile(app.lang.get(self._mapping[module]['label'], self.module));
                    model.set("label", template({
                        count: model.get("count")
                    }));
                    model.set("pictureUrl", app.api.buildFileURL({
                        module: "Users",
                        id: model.get("user_id"),
                        field: "picture"
                    }));
                    models.push(model);
                }, this);
                self.collection.reset(models);
            },
            complete: params ? params.complete : null
        });
    },
    filterChanged: function(evt) {
        this.loadData();
    },

_dispose: function() {
        if(this.collection) {
            this.collection.off("reset", null, this);
        }
        app.view.View.prototype._dispose.call(this);
    }
}) },
"about-resources": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Home.AboutResourcesView
 * @alias SUGAR.App.view.views.BaseHomeAboutResourcesView
 * @extends View.View
 */
({
	// About-resources View (base)

/**
     * @inheritdoc
     *
     * Initializes the view with the serverInfo.
     */
    initialize: function(opts) {
        this.serverInfo = app.metadata.getServerInfo();
        app.view.View.prototype.initialize.call(this, opts);
    }
}) },
"search-facet": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Home.SearchFacetView
 * @alias SUGAR.App.view.views.BaseSearchFacetView
 * @extends View.View
 */
({
	// Search-facet View (base)

className: 'group/search-facet',

events: {
        'click [data-facet-criteria]': 'itemClicked'
    },

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

/**
         * The facet id.
         *
         * @property {String}
         */
        this.facetId = this.meta.facet_id;
        /**
         * Boolean to indicate if the facet is a single criteria facet or a multi
         * criterias facet. `true` is a single criteria facet.
         *
         * @type {boolean}
         */
        this.isSingleItem = this.meta.ui_type === 'single';
        /**
         * The array of facets criterias to be displayed.
         *
         * @property {Array} facetItems
         */
        this.facetItems = [];

if (this.context.get('facets') && this.context.get('facets')[this.facetId]) {
            this.parseFacetsData();
        }

this.bindFacetsEvents();
    },

/**
     * Binds context events related to facets changes.
     */
    bindFacetsEvents: function() {
        this.context.on('facets:change', this.parseFacetsData, this);
    },

/**
     * Parses facets data and renders the view.
     */
    parseFacetsData: function() {
        var currentFacet = this.context.get('facets')[this.facetId];
        var selectedFacets = this.context.get('selectedFacets');

if (_.isUndefined(currentFacet)) {
            this.render();
            return;
        }

if (this.isSingleItem && currentFacet.results.count === 0) {
            this.$el.addClass('disabled');
            this.$el.data('action', 'disabled');
        } else {
            this.$el.data('action', 'enabled');
            this.$el.removeClass('disabled');
        }

if (this.clickedFacet) {
            this.clickedFacet = false;
            return;
        }
        if (_.isUndefined(currentFacet)) {
            app.logger.warn('The facet type : ' + this.facetId + 'is not returned by the server.' +
                ' Therefore, the facet dashlet will have no data.');
            return;
        }
        var results = currentFacet.results;
        this.facetItems = [];

if (this.isSingleItem) {
            this.facetItems = [{
                key: this.facetId,
                label: app.lang.get(this.meta.label, 'Filters'),
                count: results.count,
                selected: selectedFacets[this.facetId]
            }];
            this.render();
            return;
        }

var labelFunction = this._getDefaultLabel;
        let modulesCount = 0;

_.each(results, function(val, key) {
            var selected = _.contains(selectedFacets[this.facetId], key);
            this.facetItems.push({key: key, label: labelFunction(key), count: val, selected: selected});
            modulesCount++;
        }, this);

if (_.isEmpty(this.facetItems)) {
            this.layout.context.trigger('dashboard:collapse:fire', true);
        } else {
            this.layout.context.trigger('dashboard:collapse:fire', false);
            this.facetItems = _.sortBy(this.facetItems, 'count').reverse();
        }

this.context.trigger('search:modules:number:change', modulesCount);
        this.render();
    },

/**
     * Selects or unselect a facet item.
     *
     * @param {Event} event The `click` event.
     */
    itemClicked: function(event) {
        var currentTarget = this.$(event.currentTarget);
        if (this.$el.data('action') === 'disabled') {
            return;
        }
        if (!this.clickedFacet && !this.collection.dataFetched) {
            return;
        }

var facetCriteriaId = currentTarget.data('facet-criteria');

currentTarget.toggleClass('selected');
        this.clickedFacet = true;
        this.context.trigger('facet:apply', this.facetId, facetCriteriaId, this.isSingleItem);
    },

/**
     * Gets the facet criteria id to use it as a label.
     *
     * @param {Object} bucket The facet item.
     * @return {string} The label for this item.
     * @private
     */
    _getDefaultLabel: function(key) {
        return app.lang.getModuleName(key, {plural: true});
    }
}) },
"activity-card-header": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Basic.ActivityCardHeaderView
 * @alias SUGAR.App.view.views.BaseBasicActivityCardHeaderView
 * @extends View.Views.Base.ActivityCardHeaderView
 */
({
	// Activity-card-header View (base)

extendsFrom: 'ActivityCardHeaderView',

/**
     * @inheritdoc
     */
    setUsersFields: function() {
        var panel = this.getUsersPanel();
        this.userField = _.find(panel.fields, function(field) {
            return field.name === 'assigned_user_name';
        });

this.hasAvatarUser = !!this.userField;
    }
}) }
}}
,
"layouts": {
"base": {
"console-side-drawer": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Layouts.Home.ConsoleSideDrawerLayout
 * @alias SUGAR.App.view.layouts.HomeConsoleSideDrawerLayout
 * @extends View.Layouts.Base.SideDrawerLayout
 * @deprecated ConsoleSideDrawerLayout controller is deprecated as of 11.2.0. Use SideDrawerLayout instead.
 */
({
	// Console-side-drawer Layout (base)

extendsFrom: 'SideDrawerLayout',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        app.logger.warn(
            'ConsoleSideDrawerLayout controller is deprecated as of 11.2.0. Use SideDrawerLayout instead.'
        );
        this._super('initialize', [options]);
    }
}) },
"sidebar-nav-flyout-module-menu": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */

/**
 * @class View.Layouts.Base.HomeSidebarNavFlyoutModuleMenuLayout
 * @alias SUGAR.App.view.layouts.BaseHomeSidebarNavFlyoutModuleMenuLayout
 * @extends View.Layout
 */
({
	// Sidebar-nav-flyout-module-menu Layout (base)

extendsFrom: 'SidebarNavFlyoutModuleMenuLayout',

/**
     * @inheritdoc
     */
    _getMenuActions: function() {
        const menu = this._super('_getMenuActions');
        return _.filter(menu, (v) =>
            !(v.route && v.route === '#activities' && !app.config.activityStreamsEnabled));
    },
}) },
"dashboard-filters": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Layouts.Base.Home.DashboardFiltersLayout
 * @alias SUGAR.App.view.layouts.BaseHomeDashboardFiltersLayout
 * @extends View.Layouts.Base.Layout
 */
({
	// Dashboard-filters Layout (base)

className: 'h-full hidden',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['DashboardFiltersVisibility']);

this._super('initialize', [options]);

this._initProperties();
        this._registerEvents();

this._manageDashboardFiltersVisibility();
    },

/**
     * Init properties
     */
    _initProperties: function() {
        this._activeFilterGroupId = false;
        this._dashboardFilterView = false;
        this._filterGroups = false;

this.dashboardId = this.model.id;

this.componentLastStateKey = 'dashboard-filters';

this.hasAccessToReports = app.acl.hasAccess('view', 'Reports');

this.initFiltersVisibilityProperties();
    },

/**
     * @inheritdoc
     */
    _registerEvents: function() {
        if (!this.hasAccessToReports) {
            return;
        }

this.listenTo(this.context, 'dashboard-filter-toggled', this.toggleFilterComponent);
        this.listenTo(this.context, 'dashboard-filter-mode-updated', this.manageFilterState);
        this.listenTo(this.context, 'dashboard-filters-canceled', this.cancelDashboardFilters);
        this.listenTo(this.context, 'dashboard-filters-save', this.saveDashboardFilters);
        this.listenTo(this.context, 'dashboard-filters-apply', this.applyDashboardFilters);
        this.listenTo(this.model, 'sync', this.modelSync);
        this.listenTo(this.context, 'filter-operator-data-changed', this.updateGroupFilters);
        this.listenTo(this.context, 'dashboard-filters-interaction', this.updateGroupFilters);
    },

/**
     * Model synced
     */
    modelSync: function() {
        const metadata = this.model.get('metadata');
        let filterGroups = {};

if (_.has(metadata, 'filters')) {
            filterGroups = metadata.filters;
        }

const currentUserRestrictedGroups = this.model.get('metadata').currentUserRestrictedGroups;

if (!_.isUndefined(currentUserRestrictedGroups)) {
            this.currentUserRestrictedGroups = currentUserRestrictedGroups;
        }

if (JSON.stringify(filterGroups) !== JSON.stringify(this._filterGroups)) {
            this._syncGroups();
        }
    },

/**
     * Get the groups from meta, or create a new one
     *
     * @param {Object} options
     */
    _syncGroups: function(options = {}) {
        let filterGroups = {};
        const metadata = this.model.get('metadata');

if (_.has(metadata, 'filters')) {
            filterGroups = _.isEmpty(metadata.filters) ? {} : metadata.filters;
        }

this._filterGroups = app.utils.deepCopy(filterGroups);

this._applyUserFilters(metadata, options);

this.context.trigger('dashboard-filters-metadata-loaded', this._filterGroups);

this.manageFilterState('detail');
    },

/**
     * Apply User filters
     *
     * @param {Object} metadata
     */
    _applyUserFilters: function(metadata, options) {
        const lastStateKey = this._getUserLastStateKey();
        const userDashboardMetadata = app.user.lastState.get(lastStateKey);

if (this.model.get('is_template') && !_.isEmpty(userDashboardMetadata)) {
            this._filterGroups = userDashboardMetadata.filters;
            return;
        }

if (_.isEmpty(userDashboardMetadata) ||
            userDashboardMetadata.runtimeFiltersDateModified === metadata.runtimeFiltersDateModified) {
            return;
        }

if (!_.isUndefined(metadata.runtimeFiltersDateModified) &&
            moment(userDashboardMetadata.runtimeFiltersDateModified).isBefore(metadata.runtimeFiltersDateModified)) {
            let showNotifyLastRefresh = true;

if (!_.isEmpty(options) && _.has(options, 'notifyLastRefresh')) {
                showNotifyLastRefresh = options.notifyLastRefresh;
            }

if (showNotifyLastRefresh) {
                app.alert.show('modify_since_last_refresh', {
                    level: 'info',
                    messages: app.lang.get('LBL_FILTER_UPDATES_SINCE_LAST_REFRESH', 'Dashboards'),
                    autoClose: true,
                });
            }

this._resetLastState();
            return;
        }

this._filterGroups = userDashboardMetadata.filters;
    },

/**
     * Manage dashboard filters visibility
     */
    _manageDashboardFiltersVisibility: function() {
        const filtersVisible = this.isDashboardFiltersPanelActive();

if (filtersVisible === true) {
            this.toggleFilterComponent(true);
        }
    },

/**
     * Manage state
     *
     * @param {string} state
     */
    manageFilterState: function(state) {
        const isEdit = state === 'edit';
        const viewNameToBeCreated = isEdit ? 'dashboard-filters-edit' : 'dashboard-filters-detail';

if (!this._dashboardFilterView || this._dashboardFilterView._editMode !== isEdit) {
            this._destroyDashboardFilterView();
            this._createDashboardFilterView(viewNameToBeCreated);
            this.toggleDashboardFabButton(state);

return;
        }

this._dashboardFilterView.manageDashboardFilters(this._filterGroups);
    },

/**
     * Show/Hide fab button
     *
     * @param {string} state
     */
    toggleDashboardFabButton: function(state) {
        if (!_.has(this, 'layout') || !_.has(this.layout, 'layout')) {
            return;
        }

const fabComponent = this.layout.layout.getComponent('dashboard-fab');

if (!fabComponent) {
            return;
        }

state === 'edit' ? fabComponent.hide() : fabComponent.show();
    },

/**
     * Destroy dashboard filter view
     */
    _destroyDashboardFilterView: function() {
        if (this._dashboardFilterView) {
            this._dashboardFilterView.dispose();
            this._dashboardFilterView = false;
        }
    },

/**
     * Create dashboard filter view
     *
     * @param {string} viewNameToBeCreated
     */
    _createDashboardFilterView: function(viewNameToBeCreated) {
        this._dashboardFilterView = app.view.createView({
            type: viewNameToBeCreated,
            context: this.context,
            model: this.model,
            layout: this,
        });

this._dashboardFilterView.render();
        this.$('[data-container="dashboard-filters-container"]').append(this._dashboardFilterView.$el);

this._dashboardFilterView.manageDashboardFilters(this._filterGroups);

if (viewNameToBeCreated === 'dashboard-filters-detail') {
            this._dashboardFilterView.toggleLoading(true);
        }
    },

/**
     * Set the new filters on the model
     */
    updateGroupFilters: function() {
        const metadata = app.utils.deepCopy(this.model.get('metadata'));
        metadata.filters = this._filterGroups;

this.model.set('metadata', metadata, {silent: true});
        this.context.trigger('filter-field-updated');
    },

/**
     * Cancel the dashboard filters state
     */
    cancelDashboardFilters: function() {
        if (this.model.revertAttributes) {
            this.model.revertAttributes({silent: true});
        }

this._syncGroups();
    },

/**
     * Return invalid groups
     *
     * @return {Array}
     */
    _invalidGroupsForSave: function() {
        const filterGroups = app.utils.deepCopy(this._filterGroups);

return invalidGroups;
    },

/**
     * Check if we are able to save
     *
     * @return {boolean}
     */
    _isValidSave: function() {
        const invalidGroups = this._invalidGroupsForSave();

if (invalidGroups.length > 0) {
            this.context.trigger('dashboard-filter-group-invalid-save', invalidGroups);

app.alert.show('invalid_groups', {
                level: 'error',
                messages: app.lang.get('LBL_ONE_GROUP_REQUIRED', this.module),
                autoClose: true,
            });

return false;
        }

// validate each filter of each group
        if (this._dashboardFilterView && !this._dashboardFilterView.isValid()) {
            app.alert.show('runtime-filter-invalid', {
                level: 'error',
                messages: app.lang.get('LBL_RUNTIME_FILTERS_INVALID'),
                autoClose: true,
            });

return false;
        }

return true;
    },

/**
     * Apply Dashboard Filters
     */
    applyDashboardFilters: function() {
        if (!this._isValidSave()) {
            return;
        }

this.context.trigger('show-dashlet-loading');
        this._dashboardFilterView.toggleLoading(true);

const metadata = app.utils.deepCopy(this.model.get('metadata'));
        const runtimeFiltersDateModified = this._getCurrentDatetime();

metadata.runtimeFiltersDateModified = runtimeFiltersDateModified;
        metadata.filters = this._filterGroups;

this._updateUserLastState(metadata);

if (this.model.revertAttributes) {
            this.model.revertAttributes({silent: true});
        }
    },

/**
     *
     * Save the dashboard filters state
     *
     */
    saveDashboardFilters: function() {
        if (!this._isValidSave()) {
            return;
        }

this.context.trigger('show-dashlet-loading');
        this._dashboardFilterView.toggleLoading(true);

const metadata = app.utils.deepCopy(this.model.get('metadata'));

metadata.filters = this._filterGroups;

const runtimeFiltersDateModified = this._getCurrentDatetime();
        metadata.runtimeFiltersDateModified = runtimeFiltersDateModified;

this.model.set('metadata', metadata, {silent: true});
        this.model.save({}, {
            silent: true,
            showAlerts: false,
            success: () => {
                this._syncGroups({
                    notifyLastRefresh: false,
                });
                this._dashboardFilterView.toggleLoading(false);
                this.context.trigger('dashboard-saved-success');
                this.context.trigger('dashboard-filter-mode-changed', 'detail', true);
            },
            error: () => {
                app.alert.show('error_while_save', {
                    level: 'error',
                    title: app.lang.get('ERR_INTERNAL_ERR_MSG'),
                    messages: ['ERR_HTTP_500_TEXT_LINE1', 'ERR_HTTP_500_TEXT_LINE2']
                });
            }
        });
    },

/**
     * Update user last state
     *
     * Only update the values for the user and not for the dashboard
     *
     * @param {Object} metadata
     */
    _updateUserLastState: function(metadata) {
        this._setLastState({
            filters: metadata.filters,
            runtimeFiltersDateModified: metadata.runtimeFiltersDateModified,
        });

this._syncGroups();
        this._dashboardFilterView.toggleLoading(false);
        this.context.trigger('silent-refresh-dashlet-results', true);
    },

/**
     * Get current UTC time
     *
     * @return {string}
     */
    _getCurrentDatetime: function() {
        return app.date().format('YYYY-MM-DD HH:mm:ss');
    },

/**
     * Set last state
     *
     * @param {Object} filtersMetadata
     */
    _setLastState: function(filtersMetadata) {
        const lastStateKey = this._getUserLastStateKey();

app.user.lastState.set(
            lastStateKey,
            filtersMetadata
        );
    },

/**
     * Reset last state
     */
    _resetLastState: function() {
        const lastStateKey = this._getUserLastStateKey();

app.user.lastState.set(lastStateKey, {});
    },

/**
     * Get the unique key for the Dashboard and User combination
     *
     * @return {string}
     */
    _getUserLastStateKey: function() {
        const dashboardKey = `Dashboards:${this.dashboardId}`;
        const lastStateKey = app.user.lastState.buildKey(
            this.componentLastStateKey,
            app.user.id,
            dashboardKey
        );

return lastStateKey;
    },

/**
     * Function that adds the filter component to the dashboard
     *
     * @param {boolean} toggle
     */
    toggleFilterComponent: function(toggle) {
        this.$el.toggleClass('hidden', !toggle);

this.context.trigger('dashboard-filter-mode-changed', 'detail');
        this.context.trigger('dashboard-filter-mode-updated', 'detail');
    },

/**
     * @inheritdoc
     */
    _dispose: function() {
        this._destroyDashboardFilterView();

this._super('_dispose');
    },
}) },
"dashboard": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Layouts.Home.DashboardLayout
 * @alias SUGAR.App.view.layouts.HomeDashboardLayout
 * @extends View.Layouts.DashboardLayout
 * @deprecated 7.9.0 Will be removed in 7.11.0. Use
 *   {@link View.Layouts.Dashboards.DashboardLayout} instead.
 */
({
	// Dashboard Layout (base)

extendsFrom: 'DashboardLayout',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        app.logger.warn('View.Layouts.Home.DashboardLayout has been deprecated since 7.9.0.0. ' +
        'It will be removed in 7.11.0.0. Please use View.Layouts.Dashboards.DashboardLayout instead.');
        this._super('initialize', [options]);
    }
}) },
"records": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Layouts.Home.RecordsLayout
 * @alias SUGAR.App.view.layouts.HomeRecordsLayout
 * @extends View.Layout
 * @deprecated 7.9.0 Will be removed in 7.11.0. Use
 *   {@link View.Layouts.Home.Record} instead.
 */
({
	// Records Layout (base)

/**
     * @inheritdoc
     */
    initialize: function(options) {

app.logger.warn('View.Layouts.Home.RecordsLayout has been deprecated since 7.9.0.0. ' +
        'It will be removed in 7.11.0.0. Please use View.Layouts.Home.Record instead.');
        this._super('initialize', [options]);
    }
}) },
"list": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Layouts.Home.ListLayout
 * @alias SUGAR.App.view.layouts.HomeListLayout
 * @extends View.DashboardLayout
 * @deprecated 7.9.0 Will be removed in 7.11.0. Use
 *   {@link View.Layouts.Home.Record} instead.
 */
({
	// List Layout (base)

extendsFrom: 'DashboardLayout',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        app.logger.warn('View.Layouts.Home.ListLayout has been deprecated since 7.9.0.0. ' +
        'It will be removed in 7.11.0.0. Please use View.Layouts.Home.Record instead.');
        this._super('initialize', [options]);
    }
}) }
}}
,
"datas": {}

},
		"Contacts":{"fieldTemplates": {}
,
"views": {
"base": {
"subpanel-for-cases": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * Custom RecordlistView used within Subpanel layouts.
 *
 * @class View.Views.Base.Contacts.SubpanelForCasesView
 * @alias SUGAR.App.view.views.SubpanelForCasesView
 * @extends View.Views.Base.SubpanelListView
 */
({
	// Subpanel-for-cases View (base)

extendsFrom: 'SubpanelListView',

unlinkPrimary: false,

/**
     * Formats the messages to display in the alerts when unlinking a record.
     *
     * @override
     * @param {Data.Bean} model The model concerned.
     * @return {Object} The list of messages.
     * @return {string} return.confirmation Confirmation message.
     * @return {string} return.success Success message.
     */
    getUnlinkMessages: function(model) {
        var message = this._super('getUnlinkMessages', [model]);
        var context = this.getMessageContext(model);

if (this.unlinkPrimary) {
            // Show the message about clearing Primary Conact Field
            // if it's similar with the unlinked Contact
            message.confirmation = app.utils.formatString(
                app.lang.get('NTC_UNLINK_CASES_CONTACT_CONFIRMATION'),
                [context]
            );
        }

return message;
    },

/**
     * Show the alert in the time of unlinking a record.
     *
     * @override
     * @param {Data.Bean} model The model concerned.
     */
    showUnlinkMessage: function(model) {
        var recordModel = this.context.parent.children[0].parent.get('model');
        var contactField = recordModel.fields.primary_contact_name;

this.unlinkPrimary =
            (recordModel.get('primary_contact_id') === model.get('id')) ||
            (recordModel.previous('primary_contact_id') === model.get('id'));

if (this.unlinkPrimary && contactField.required === true) {
            var context = this.getMessageContext(model);

// Show message about it's not possible to unlink the Primary Contact
            // if it's a required field
            app.alert.show('unlink_error', {
                level: 'error',
                messages: app.utils.formatString(
                    app.lang.get('NTC_UNLINK_CASES_CONTACT_ERROR'),
                    [context]
                ),
            });

this._modelToUnlink = null;

return;
        }

this._super('showUnlinkMessage', [model]);
    },
}) },
"record": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Record View (base)

extendsFrom: 'RecordView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['HistoricalSummary']);
        this.plugins.push('ContactsPortalMetadataFilter');
        this._super('initialize', [options]);
        this.removePortalFieldsIfPortalNotActive(this.meta);
        this.listenTo(this.context, 'button:custom_sf_iframebutton:click', this.viewInMarket);
    }
}) },
"create": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Contacts.CreateView
 * @alias SUGAR.App.view.views.ContactsCreateView
 * @extends View.Views.Base.CreateView
 */
({
	// Create View (base)

extendsFrom: 'CreateView',

/*
     * Enable pre-population from Omnichanel
     */
    omniPopulation: true,

/**
     * Gets the portal status from metadata to know if we render portal specific fields.
     * @override
     * @param options
     */
    initialize: function(options) {
        //Plugin is registered by the Contact record view
        this.plugins = _.union(this.plugins || [], ["ContactsPortalMetadataFilter"]);
        this._super("initialize", [options]);
        this.removePortalFieldsIfPortalNotActive(this.meta);
    }
}) },
"activity-card-header": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Contacts.ActivityCardHeaderView
 * @alias SUGAR.App.view.views.BaseContactsActivityCardHeaderView
 * @extends View.Views.Base.ActivityCardHeaderView
 */
({
	// Activity-card-header View (base)

extendsFrom: 'ActivityCardHeaderView',

/**
     * @inheritdoc
     */
    setUsersFields: function() {
        const panel = this.getUsersPanel();

this.userField = _.find(panel.fields, function(field) {
            return field.name === 'account_name';
        });

this.hasAvatarUser = !!this.userField;
    }
}) },
"preview": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Contacts.PreviewView
 * @alias SUGAR.App.view.views.BaseContactsPreviewView
 * @extends View.Views.Base.PreviewView
 */
({
	// Preview View (base)

extendsFrom: 'PreviewView',

initialize: function(options) {
        //Plugin is registered by the Contact record view
        this.plugins = _.union(this.plugins || [], ["ContactsPortalMetadataFilter"]);
        this._super("initialize", [options]);
    },

/**
     * Gets the portal status from metadata to know if we render portal specific fields.
     * @override
     * @param options
     */
    _previewifyMetadata: function(meta) {
        meta = this._super("_previewifyMetadata", [meta]);
        this.removePortalFieldsIfPortalNotActive(meta);
        return meta;
    }
}) }
}}
,
"layouts": {}
,
"datas": {}

},
		"Accounts":{"fieldTemplates": {}
,
"views": {
"base": {
"record": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Accounts.RecordView
 * @alias SUGAR.App.view.views.BaseAccountsRecordView
 * @extends View.Views.Base.RecordView
 */
 ({
	// Record View (base)

extendsFrom: 'RecordView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['HistoricalSummary']);
        this._super('initialize', [options]);
    }
}) },
"activity-card-header": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Basic.ActivityCardHeaderView
 * @alias SUGAR.App.view.views.BaseBasicActivityCardHeaderView
 * @extends View.Views.Base.ActivityCardHeaderView
 */
({
	// Activity-card-header View (base)

extendsFrom: 'ActivityCardHeaderView',

this.hasAvatarUser = !!this.userField;
    }
}) }
}}
,
"layouts": {}
,
"datas": {}

},
		"Opportunities":{"fieldTemplates": {
"base": {
"enum-cascade": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Opportunities.EnumCascadeField
 * @alias SUGAR.App.view.fields.BaseOpportunitiesEnumCascadeField
 * @extends View.Fields.Base.EnumField
 */
({
	// Enum-cascade FieldTemplate (base)

extendsFrom: 'EnumField',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['Cascade']);
        this._super('initialize', [options]);
    },

/**
     * @inheritdoc
     */
    _loadTemplate: function() {
        if (this.action !== 'edit' && this.action !== 'disabled') {
            this.type = 'enum';
        }
        this._super('_loadTemplate');
        this.type = this.def.type;
    }
}) },
"editablelistbutton": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Editablelistbutton FieldTemplate (base)

extendsFrom: 'EditablelistbuttonField',
    /**
     * extend save options
     * @param {Object} options save options.
     * @return {Object} modified success param.
     */
    getCustomSaveOptions: function(options) {
        // make copy of original function we are extending
        var origSuccess = options.success;
        // return extended success function with added alert
        return {
            success: _.bind(function() {
                if (_.isFunction(origSuccess)) {
                    origSuccess.apply(this, arguments);
                }

if(this.context.parent) {
                    var oppsCfg = app.metadata.getModule('Opportunities', 'config'),
                        reloadLinks = ['opportunities'];
                    if (oppsCfg && oppsCfg.opps_view_by == 'RevenueLineItems') {
                        reloadLinks.push('revenuelineitems');
                    }

this.context.parent.set('skipFetch', false);

// reload opportunities subpanel
                    this.context.parent.trigger('subpanel:reload', {links: reloadLinks});
                    // catch the after save moment
                    this.context.parent.trigger('opportunities:record:saved');
                }
            }, this)
        };
    }
}) },
"pipeline-type": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */

/**
 * @class View.Fields.Base.Opportunities.PipelineTypeField
 * @alias SUGAR.App.view.fields.BaseOpportunitiesPipelineTypeField
 * @extends View.Fields.Base.PipelineTypeField
 */
({
	// Pipeline-type FieldTemplate (base)

extendsFrom: 'PipelineTypeField',

/**
     * @inheritdoc
     */
    getTabs: function() {
        this.tabs = [];
        var fieldsForTabs = ['date_closed'];
        var config = app.metadata.getModule('VisualPipeline', 'config');
        fieldsForTabs.push(config.table_header[this.module]);
        var fieldMeta = app.metadata.getModule(this.module, 'fields');

_.each(fieldsForTabs, function(field) {
            var label = field === 'date_closed' ?
                'LBL_TIME' : fieldMeta[field].vname;
            var fieldLabel = app.lang.getModString(label, this.module);
            var metaObject = {
                headerLabel: fieldLabel,
                moduleField: field,
                tabLabel: app.lang.get('LBL_PIPELINE_VIEW_TAB_NAME', this.module, {
                    module: app.lang.get('LBL_MODULE_NAME', this.module),
                    fieldName: fieldLabel
                })
            };

this.tabs.push(metaObject);
        }, this);
    }
}) },
"rowactions": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/*
 * @class View.Fields.Base.Opportunities.RowactionsField
 * @alias SUGAR.App.view.fields.BaseOpportunitiesRowactionsField
 * @extends View.Fields.Base.RowactionsField
 */
({
	// Rowactions FieldTemplate (base)

extendsFrom: 'RowactionsField',

/**
     * Enable or disable caret depending on if there are any enabled actions in the dropdown list
     *
     * @inheritdoc
     * @private
     */
    _updateCaret: function() {
        // Left empty on purpose, the menu should always show
    }
}) },
"renewal": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Opportunities.RenewalField
 * @alias SUGAR.App.view.fields.BaseOpportunitiesRenewalField
 * @extends View.Fields.Base.BaseField
 */
({
	// Renewal FieldTemplate (base)

/**
     * @inheritdoc
     *
     * This field doesn't support `showNoData`.
     */
    showNoData: false,
    month: '',
    year: '',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        options.def.readonly = true;
        var date = this.model.get('date_closed');
        this.month = app.date(date).format('MMMM');
        this.year = app.date(date).format('YYYY');
        this._super('initialize', [options]);
    },

bindDataChange: function() {
        this._super('bindDataChange');
        this.model.on('change:date_closed', function() {
            var date = this.model.get('date_closed');
            this.month = app.date(date).format('MMMM');
            this.year = app.date(date).format('YYYY');
            this.render();
        }, this);
    },
}) },
"rowaction": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Rowaction FieldTemplate (base)

extendsFrom: "RowactionField",
    
    /**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins, ['DisableDelete']);
        this._super("initialize", [options]);
    }
}) },
"date-cascade": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Opportunities.DateCascadeField
 * @alias SUGAR.App.view.fields.BaseOpportunitiesDateCascadeField
 * @extends View.Fields.Base.DateField
 */
({
	// Date-cascade FieldTemplate (base)

extendsFrom: 'DateField',

/**
     * Name of validation task for Service Start Date
     */
    validationName: null,

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['Cascade']);
        this._super('initialize', [options]);

var config = app.metadata.getModule('Opportunities', 'config');
        if (this.name === 'service_start_date' && config.opps_view_by === 'RevenueLineItems') {
            app.error.errorName2Keys.service_start_date_exceeds_end_date = 'LBL_SERVICE_START_DATE_INVALID';

this.validationName = 'start_date_before_fixed_end_' + this.cid;
            this.model.addValidationTask(this.validationName, _.bind(this.validateServiceStartDate, this));
        }
    },

/**
     * Validates that the service start date is not after the end date of any
     * add on RLIs.
     * @param fields
     * @param errors
     * @param callback
     */
    validateServiceStartDate: function(fields, errors, callback) {
        // We don't want to perform this check when creating an opportunity or if the service
        // start date is empty (no service RLIs, for example)
        var serviceStartDate = this.model.get('service_start_date');
        if (this.field.action !== 'edit' || _.isEmpty(serviceStartDate)) {
            callback(null, fields, errors);
            return;
        }

// Show the Saving alert while validation runs. Otherwise the UI appears to be
        // unresponsive during this time.
        app.alert.show('service_start_date_validation', {
            level: 'process',
            title: app.lang.get('LBL_SAVING'),
            autoClose: false
        });

var forecastConfig = app.metadata.getModule('Forecasts', 'config');
        var closedSalesStages = _.union(forecastConfig.sales_stage_won, forecastConfig.sales_stage_lost);

var moduleName = app.data.getRelatedModule(this.model.module, 'revenuelineitems');
        var rliCollection = app.data.createBeanCollection(moduleName);

rliCollection.filterDef = {
            'filter': [
                {'opportunity_id': {'$equals': this.model.get('id')}},
                {'add_on_to_id': {'$not_empty': ''}},
                {'sales_stage': {'$not_in': closedSalesStages}},
                {'service_end_date': {'$lt': serviceStartDate}}
            ]
        };

rliCollection.fetch({
            showAlerts: false,
            fields: ['id'],
            relate: false,
            success: _.bind(function(data) {
                if (data.length > 0) {
                    _.extend(errors, {
                        'service_start_date': {
                            'service_start_date_exceeds_end_date': true
                        }
                    });
                    this._showValidationMessage();
                }
            }, this),
            complete: function() {
                app.alert.dismiss('service_start_date_validation');
                callback(null, fields, errors);
            }
        });
    },

/**
     * Shows the invalid service start date error message
     * @private
     */
    _showValidationMessage: function() {
        app.alert.show('service_start_date_exceeds_end_date', {
            level: 'error',
            messages: app.lang.get('LBL_SERVICE_START_DATE_INVALID', 'Opportunities'),
        });
    },

/**
     * @inheritdoc
     */
    _dispose: function() {
        if (this.validationName) {
            this.model.removeValidationTask(this.validationName);
        }
        this._super('_dispose');
    }
}) },
"fieldset-cascade": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Opportunities.FieldsetCascadeField
 * @alias SUGAR.App.view.fields.BaseOpportunitiesFieldsetCascadeField
 * @extends View.Fields.Base.FieldsetField
 */
({
	// Fieldset-cascade FieldTemplate (base)

extendsFrom: 'FieldsetField',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['Cascade']);
        this._super('initialize', [options]);
    },

/**
     * @inheritdoc
     */
    _loadTemplate: function() {
        // If the field isn't editable or disabled, fall back to fieldset's
        // base templates.
        if (this.action !== 'edit' && this.action !== 'disabled') {
            this.type = 'fieldset';
        }

// If this field is disabled, setDisabled will cascade that down
        // to the subfields
        if (this.action === 'disabled') {
            this.setDisabled(true);
        }

this._super('_loadTemplate');
        this.type = this.def.type;
    }
}) },
"actiondropdown": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * Create a dropdown button that contains multiple
 * {@link View.Fields.Base.RowactionField} fields.
 *
 * @class View.Fields.Base.Opportunities.ActiondropdownField
 * @alias SUGAR.App.view.fields.BaseOpportunitiesActiondropdownField
 * @extends View.Fields.Base.ActiondropdownField
 */
({
	// Actiondropdown FieldTemplate (base)

extendsFrom: 'ActiondropdownField',

/**
     * Enable or disable caret depending on if there are any enabled actions in the dropdown list
     *
     * @inheritdoc
     * @private
     */
    _updateCaret: function() {
        // Left empty on purpose, the menu should always show
    }
}) }
}}
,
"views": {
"base": {
"product-quick-picks": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Opportunities.ProductQuickPicksView
 * @alias SUGAR.App.view.views.OpportunitiesProductQuickPicksView
 * @extends View.Views.Base.ProductQuickPicksView
 * @deprecated Use {@link View.Views.Base.ProductQuickPicksView} instead
 */
({
	// Product-quick-picks View (base)

extendsFrom: 'ProductQuickPicksView',

initialize: function(options) {
        app.logger.warn('View.Views.Base.Opportunities.ProductQuickPicksView is deprecated. Use ' +
            'View.Views.Base.ProductQuickPicksView instead');
        this._super('initialize', [options]);
    }
}) },
"massupdate": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Massupdate View (base)

extendsFrom: "MassupdateView",
    
    /**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['DisableMassDelete', 'CommittedDeleteWarning']);
        this._super("initialize", [options]);
    },

/**
     *
     * @inheritdoc
     */
    setMetadata: function(options) {
        var config = app.metadata.getModule('Forecasts', 'config');

this._super("setMetadata", [options]);

if (!config || (config && !config.is_setup)) {
            _.each(options.meta.panels, function(panel) {
                _.every(panel.fields, function (item, index) {
                    if (_.isEqual(item.name, "commit_stage")) {
                        panel.fields.splice(index, 1);
                        return false;
                    }
                    return true;
                }, this);
            }, this);
        }
    },

/**
     * @inheritdoc
     */
    save: function(forCalcFields) {
        var forecastCfg = app.metadata.getModule("Forecasts", "config");
        if (forecastCfg && forecastCfg.is_setup) {
            // Forecasts is enabled and setup
            var hasCommitStage = _.some(this.fieldValues, function(field) {
                    return field.name === 'commit_stage';
                }),
                hasClosedModels = false;

if(!hasCommitStage && this.defaultOption.name === 'commit_stage') {
                hasCommitStage = true;
            }

if(hasCommitStage) {
                hasClosedModels = this.checkMassUpdateClosedModels();
            }

if(!hasClosedModels) {
                // if this has closed models, first time through will uncheck but not save
                // if this doesn't it will save like normal
                this._super('save', [forCalcFields]);
            }
        } else {
            // Forecasts is not enabled and the commit_stage field isn't in the mass update list
            this._super('save', [forCalcFields]);
        }
    }
}) },
"pipeline-recordlist-content": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Opportunities.PipelineRecordlistContentView
 * @alias App.view.views.BaseOpportunitiesPipelineRecordlistContentView
 * @extends View.Views.Base.PipelineRecordlistContentView
 */
({
	// Pipeline-recordlist-content View (base)

extendsFrom: 'PipelineRecordlistContentView',

/**
     * Don't change the expected close date or the sales stage of an opp that is already closed
     * @inheritdoc
     */
    saveModel: function(model, pipelineData) {
        var oppCfg = app.metadata.getModule('Opportunities', 'config');
        var rliMode = oppCfg.opps_view_by === 'RevenueLineItems';

if (_.contains(['date_closed', 'sales_stage'], this.headerField) && rliMode) {
            var forecastConfig = app.metadata.getModule('Forecasts', 'config') || {};
            var closedWon = forecastConfig.sales_stage_won || ['Closed Won'];
            var closedLost = forecastConfig.sales_stage_lost || ['Closed Lost'];
            var closedStatuses = closedWon.concat(closedLost);
            var status = model.get('sales_status');

if (_.contains(closedStatuses, status)) {
                this._postChange(model, true, pipelineData);
                var moduleName = app.lang.getModuleName(this.module, {plural: false});
                var fieldLabel = app.metadata.getField({module: 'Opportunities', name: this.headerField}).vname;
                var fieldName = app.lang.get(fieldLabel, this.module);
                app.alert.show('error_converted', {
                    level: 'error',
                    messages: app.lang.get(
                        'LBL_PIPELINE_ERR_CLOSED_SALES_STAGE',
                        this.module, {moduleSingular: moduleName, fieldName: fieldName}
                        )
                });
                return;
            }
        }

this._super('saveModel', [model, pipelineData]);
    },

/**
     * @inheritdoc
     */
    getFieldsForFetch: function() {
        var fields = this._super('getFieldsForFetch');
        var cfg = app.metadata.getModule('Opportunities', 'config');
        var newFields = ['closed_revenue_line_items'];

if (cfg && cfg.opps_view_by) {
            newFields.push(cfg.opps_view_by === 'RevenueLineItems' ? 'sales_status' : 'sales_stage');
        }

return _.union(fields, newFields, [this.headerField]);
    },

/**
     * @inheritdoc
     */
    _setNewModelValues: function(model, ui) {
        var ctxModel = this.context.get('model');
        var $ulEl = this.$(ui.item).parent('ul');
        var headerFieldValue = $ulEl.attr('data-column-key');

if (ctxModel && ctxModel.get('pipeline_type') === 'date_closed') {
            var dateClosed = app.date(headerFieldValue, 'MMMM YYYY')
                .endOf('month')
                .formatServer(true);

model.set('date_closed', dateClosed);
            model.set('date_closed_cascade', dateClosed);
        } else {
            model.set(this.headerField, headerFieldValue);

if (this.headerField === 'sales_stage') {
                model.set({
                    probability: app.utils.getProbabilityBySalesStage(headerFieldValue),
                    commit_stage: app.utils.getCommitStageBySalesStage(headerFieldValue),
                    sales_stage_cascade: headerFieldValue
                });
            }
        }
    }
}) },
"recordlist": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.OpportunitiesRecordlistView
 * @alias SUGAR.App.view.views.BaseOpportunitiesRecordlistView
 * @extends View.Views.Base.RecordlistView
 */
({
	// Recordlist View (base)

extendsFrom: 'RecordlistView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['CommittedDeleteWarning']);
        this._super("initialize", [options]);
    },

/**
     * @inheritdoc
     */
    parseFieldMetadata: function(options) {
        options = this._super('parseFieldMetadata', [options]);

app.utils.hideForecastCommitStageField(options.meta.panels);

return options;
    },
}) },
"subpanel-list": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.OpportunitiesSubpanelListView
 * @alias SUGAR.App.view.views.BaseOpportunitiesSubpanelListView
 * @extends View.Views.Base.SubpanelListView
 */
({
	// Subpanel-list View (base)

extendsFrom: 'SubpanelListView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['CommittedDeleteWarning']);
        this._super('initialize', [options]);
    },
}) },
"record": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Record View (base)

extendsFrom: 'RecordView',

/**
     * Holds a reference to the alert this view triggers
     */
    alert: undefined,

/**
     * Holds a reference to the alert this view triggers
     */
    cancelClicked: function() {
        /**
         * todo: this is a sad way to work around some problems with sugarlogic and revertAttributes
         * but it makes things work now. Probability listens for Sales Stage to change and then by
         * SugarLogic, it updates probability when sales_stage changes. When the user clicks cancel,
         * it goes to revertAttributes() which sets the model back how it was, but when you try to
         * navigate away, it picks up those new changes as unsaved changes to your model, and tries to
         * falsely warn the user. This sets the model back to those changed attributes (causing them to
         * show up in this.model.changed) then calls the parent cancelClicked function which does the
         * exact same thing, but that time, since the model was already set, it doesn't see anything in
         * this.model.changed, so it doesn't warn the user.
         */
        var changedAttributes = this.model.changedAttributes(this.model.getSynced());
        this.model.set(changedAttributes, {revert: true, hideDbvWarning: true});
        this._super('cancelClicked');
    },

/**
     * @inheritdoc
     * @param {Object} options
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins, ['LinkedModel', 'HistoricalSummary', 'CommittedDeleteWarning']);
        this.addInitListener();

this._super('initialize', [options]);

app.utils.hideForecastCommitStageField(this.meta.panels);
    },

/**
     * Add the initListener if RLI's are being used and the current user has Edit access to RLI's
     */
    addInitListener: function() {
        // if we are viewing by RevenueLineItems and we have access to edit/create RLI's then we should
        // display the warning if no rli's exist
        if (app.metadata.getModule('Opportunities', 'config').opps_view_by == 'RevenueLineItems' &&
            app.acl.hasAccess('edit', 'RevenueLineItems')) {
            this.once('init', function() {
                var rlis = this.model.getRelatedCollection('revenuelineitems');
                rlis.once('reset', function(collection) {
                    // check if the RLI collection is empty
                    // and make sure there isn't another RLI warning on the page
                    if (collection.length === 0 && $('#createRLI').length === 0) {
                        this.showRLIWarningMessage(this.model.module);
                    }
                }, this);
                rlis.fetch({relate: true});
            }, this);
        }
    },

/**
     * Loops through all fields on the model returning only the fields with calculated => true set
     * @returns {Array}
     */
    getCalculatedFields: function() {
        return _.filter(this.model.fields, function (field) {
            return field.calculated;
        });
    },

/**
     * @inheritdoc
     */
    setupDuplicateFields: function(prefill) {
        // Clear sugar predict fields
        const predictFields = [
            'ai_opp_conv_score_enum',
            'ai_opp_conv_score_enum_c'
        ];
        predictFields.forEach(fieldName => prefill.unset(fieldName));

if (app.metadata.getModule('Opportunities', 'config').opps_view_by === 'RevenueLineItems') {
            var calcFields = this.getCalculatedFields();
            if (calcFields) {
                _.each(calcFields, function(field) {
                    prefill.unset(field.name);
                }, this);
            }
        }
    },

/**
     * Display the warning message about missing RLIs
     */
    showRLIWarningMessage: function() {
        // add a callback to close the alert if users navigate from the page
        app.routing.before('route', this.dismissAlert, this);

var message = app.lang.get('TPL_RLI_CREATE', 'Opportunities') +
            '  <a href="javascript:void(0);" id="createRLI">' +
            app.lang.get('TPL_RLI_CREATE_LINK_TEXT', 'Opportunities') + '</a>';

this.alert = app.alert.show('opp-rli-create', {
            level: 'warning',
            autoClose: false,
            title: app.lang.get('LBL_ALERT_TITLE_WARNING') + ':',
            messages: message,
            onLinkClick: _.bind(function() {
                this.openRLICreate();
            }, this),
            onClose: _.bind(function() {
                app.routing.offBefore('route', this.dismissAlert, this);
            }, this)
        });
    },

/**
     * Handle dismissing the RLI create alert
     */
    dismissAlert: function() {
        // close RLI warning alert
        app.alert.dismiss('opp-rli-create');
        // remove before route event listener
        app.routing.offBefore('route', this.dismissAlert, this);
    },

/**
     * Open a new Drawer with the RLI Create Form
     */
    openRLICreate: function() {
        // close RLI warning alert
        this.dismissAlert();

var model = this.createLinkModel(this.createdModel || this.model, 'revenuelineitems');

app.drawer.open({
            layout: 'create',
            context: {
                create: true,
                module: model.module,
                model: model
            }
        }, _.bind(this.rliCreateClose, this));
    },

/**
     * Callback for when the create drawer closes
     * @param {String} model
     */
    rliCreateClose: function(model) {
        if (!model) {
            return;
        }

var ctx = this.listContext || this.context;

ctx.resetLoadFlag();
        ctx.set('skipFetch', false);
        ctx.loadData();

// find the child collection for the RLI subpanel
        // if we find one and it has the loadData method, call that method to
        // force the subpanel to load the data.
        var rli_ctx = _.find(ctx.children, function(child) {
            return child.get('module') === 'RevenueLineItems';
        }, this);
        if (!_.isUndefined(rli_ctx) && _.isFunction(rli_ctx.loadData)) {
            rli_ctx.loadData();
        }
    }
}) },
"config-header-buttons": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */

/**
 * @class View.Views.Base.OpportunitiesConfigHeaderButtonsView
 * @alias SUGAR.App.view.views.BaseOpportunitiesConfigHeaderButtonsView
 * @extends View.Views.Base.ConfigHeaderButtonsView
 */
({
	// Config-header-buttons View (base)

extendsFrom: 'ConfigHeaderButtonsView',

/**
     * The current opps_view_by config setting when the view is initialized
     */
    currentOppsViewBySetting: undefined,

/**
     * Stores if Forecasts is set up or not
     */
    isForecastsSetup: false,

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

this.currentOppsViewBySetting = this.model.get('opps_view_by');

// get the boolean form of if Forecasts is configured
        this.isForecastsSetup = !!app.metadata.getModule('Forecasts', 'config').is_setup;
    },

/**
     * Before the save triggers, we need to show the alert so the users know it's doing something.
     * @private
     */
    _beforeSaveConfig: function() {
        app.alert.show('opp.config.save', {level: 'process', title: app.lang.getAppString('LBL_SAVING')});
    },

/**
     * @inheritdoc
     * @param {function} onClose
     */
    showSavedConfirmation: function(onClose) {
        app.alert.dismiss('opp.config.save');
        this._super('showSavedConfirmation', [onClose]);
    },

/**
     * Displays the Forecast warning confirm alert
     */
    displayWarningAlert: function() {
        var opportunity = this.model.get('opps_view_by') === 'Opportunities';
        var message = opportunity ? app.lang.get('LBL_OPPS_CONFIG_ALERT_TO_OPPS', 'Opportunities') :
            app.lang.get('LBL_OPPS_CONFIG_ALERT', 'Opportunities');

app.alert.show('forecast-warning', {
            level: 'confirmation',
            title: app.lang.get('LBL_WARNING'),
            messages: message,
            onConfirm: _.bind(function() {
                this._super('saveConfig');
            }, this),
            onCancel: _.bind(function() {
                this.model.set('opps_view_by', this.currentOppsViewBySetting);
            }, this)
        });
    },

/**
     * Overriding the default saveConfig to display the warning alert first, then on confirm of the
     * warning alert, save the config settings. Reloads metadata.
     *
     * @inheritdoc
     */
    saveConfig: function() {
        if (this.isForecastsSetup && this.currentOppsViewBySetting !== this.model.get('opps_view_by')) {
            this.displayWarningAlert();
        } else {
            this._super('saveConfig');
        }
    }
}) },
"filter-rows": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Filter-rows View (base)

extendsFrom: 'FilterRowsView',

/**
     * @inheritdoc
     */
    loadFilterFields: function(moduleName) {
        this._super('loadFilterFields', [moduleName]);

/**
     * @inheritdoc
     */
    formatDate: function(date) {
        return date.formatUser(true);
    },
}) },
"config-opps-view-by": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.OpportunitiesConfigOppsViewByView
 * @alias SUGAR.App.view.views.BaseOpportunitiesConfigOppsViewByView
 * @extends View.Views.Base.ConfigPanelView
 */
({
	// Config-opps-view-by View (base)

extendsFrom: 'ConfigPanelView',

/**
     * The current opps_view_by config setting when the view is initialized
     */
    currentOppsViewBySetting: undefined,

/**
     * Are we currently waiting for the field items?
     */
    waitingForFieldItems: false,

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

// get the initial opps_view_by setting
        this.currentOppsViewBySetting = this.model.get('opps_view_by');
    },

/**
     * @inheritdoc
     */
    bindDataChange: function() {
        this.model.on('change:opps_view_by', function() {
            this.showRollupOptions();
        }, this);
    },

/**
     * Displays the Latest/Earliest Date toggle
     */
    showRollupOptions: function() {
        if (this.currentOppsViewBySetting === 'RevenueLineItems' &&
            this.model.get('opps_view_by') === 'Opportunities') {
            this.getField('opps_closedate_rollup').show();
            this.$('[for=opps_closedate_rollup]').show();
            this.$('#sales-stage-text').show();

// if there's no value here yet, set to latest
            if (!this.model.has('opps_closedate_rollup')) {
                this.$('input[value="latest"]').prop('checked', true);
            }
        } else {
            this.getField('opps_closedate_rollup').hide();
            this.$('[for=opps_closedate_rollup]').hide();
            this.$('#sales-stage-text').hide();
        }

// update the title based on settings
        this.updateTitle();
    },

/**
     * @inheritdoc
     */
    _render: function(options) {
        this._super('_render', [options]);

this.showRollupOptions();
    },

/**
     * @inheritdoc
     */
    _updateTitleValues: function() {
        var items = this._getFieldOptions();
        if (items) {
            // defensive coding in case user removed this options dom
            var title = '';
            if (items && _.isObject(items)) {
                title = items[this.model.get('opps_view_by')];
            }

this.titleSelectedValues = title;
        }
    },

/**
     * Get the options from the field, vs form the dom, since it's
     * customized to show the correct module names by the end point
     *
     * @return {boolean|Object}
     * @private
     */
    _getFieldOptions: function() {
        var f = this.getField('opps_view_by');

if (_.isUndefined(f.items)) {
            if (this.waitingForFieldItems === false) {
                this.waitingForFieldItems = true;
                f.once('render', function() {
                    this.waitingForFieldItems = false;
                    this.updateTitle();
                }, this);
            }

return false;
        } else {
            return f.items;
        }
    }
}) },
"create": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Opportunities.CreateView
 * @alias SUGAR.App.view.views.OpportunitiesCreateView
 * @extends View.Views.Base.CreateView
 */
({
	// Create View (base)

extendsFrom: 'CreateView',

/**
     * Used by the alert openRLICreate method
     */
    createdModel: undefined,

/**
     * Used by the openRLICreate method
     */
    listContext: undefined,

/**
     * The original success message to call from the new one we set in the getCustomSaveOptions method
     */
    originalSuccess: undefined,

/**
     * Holds a reference to the alert this view triggers
     */
    alert: undefined,

/**
     * What are we viewing by
     */
    viewBy: 'Opportunities',

/**
     * Does the current user has access to RLI's?
     */
    hasRliAccess: true,

/**
     * Flag to store if the user has confirmed the save if there are validation warnings
     *
     * @property {boolean}
     */
    hasConfirmedSave: false,

/**
     * If subpanel models are valid
     */
    validSubpanelModels: true,

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins, ['LinkedModel']);
        this.viewBy = app.metadata.getModule('Opportunities', 'config').opps_view_by;
        this.hasRliAccess = app.acl.hasAccess('edit', 'RevenueLineItems');
        this._super('initialize', [options]);
        app.utils.hideForecastCommitStageField(this.meta.panels);
    },

/**
     * @inheritdoc
     */
    initiateSave: function(callback) {
        this.disableButtons();
        async.waterfall([
            _.bind(function(cb) {
                async.parallel([
                    _.bind(this.validateSubpanelModelsWaterfall, this),
                    _.bind(this.validateModelWaterfall, this)
                ], function(err) {
                    // err is undefined or null if no errors
                    cb(!(_.isUndefined(err) || _.isNull(err)));
                });
            }, this),
            _.bind(this.dupeCheckWaterfall, this),
            _.bind(this.createRecordWaterfall, this)
        ], _.bind(function(error) {
            this.enableButtons();
            if (error && error.status == 412 && !error.request.metadataRetry) {
                this.handleMetadataSyncError(error);
            } else if (!error && !this.disposed) {
                this.context.lastSaveAction = null;
                callback();
            }
        }, this));
    },

/**
     * Check to see if all fields are valid
     *
     * @inheritdoc
     */
    validateModelWaterfall: function(callback) {
        // override this.model.doValidate() to display error if subpanel model validation failed
        this.model.trigger('validation:start');
        this.model.isValidAsync(this.getFields(this.module), _.bind(function(isValid, errors) {
            this._handleValidationComplete(isValid, errors, callback);
        }, this));
    },

/**
     * Check to see if there are subpanel create models on this view
     * And trigger an event to tell the subpanel to validate itself
     *
     * @inheritdoc
     */
    validateSubpanelModelsWaterfall: function(callback) {
        this.hasSubpanelModels = false;
        this.validSubpanelModels = true;
        _.each(this.context.children, function(child) {
            if (child.get('isCreateSubpanel')) {
                this.hasSubpanelModels = true;
                this.context.trigger('subpanel:validateCollection:' + child.get('link'),
                    _.bind(function(notValid) {
                        if (this.validSubpanelModels && notValid) {
                            this.validSubpanelModels = false;
                        }
                        callback(notValid);
                    }, this),
                    true
                );
            }
        }, this);

// If there are no subpanel models, callback false so the waterfall can continue
        if (!this.hasSubpanelModels) {
            return callback(false);
        }
    },

/**
     * When validation is complete, see if there are any cascade warnings to show
     * @param isValid
     * @param errors
     * @param callback
     * @private
     */
    _handleValidationComplete: function(isValid, errors, callback) {
        let hasRlis = this.viewBy === 'RevenueLineItems' && this.hasRliAccess;
        let cascadeWarning = this.validateCascadeFields();
        if (this.validSubpanelModels &&
            isValid &&
            hasRlis &&
            cascadeWarning &&
            (!this._isOnLeadConvert() || !this.hasConfirmedSave)
        ) {
            app.alert.show('delete_recurrence_confirmation', {
                title: app.lang.get('LBL_WARNING'),
                level: 'confirmation',
                messages: cascadeWarning,
                onConfirm: () => {
                    this.hasConfirmedSave = true;
                    this.model.trigger('validation:success');
                    this.model.trigger('validation:complete', this.model._processValidationErrors(errors));
                    callback(!isValid);
                },
                onCancel: () => {
                    this.enableButtons();
                }
            });
        } else {
            if (this.validSubpanelModels && isValid) {
                this.model.trigger('validation:success');
            } else if (!this.validSubpanelModels) {
                this.model.trigger('error:validation');
            }
            this.model.trigger('validation:complete', this.model._processValidationErrors(errors));
            callback(!isValid);
        }
    },

/**
     * Checks if the Opp create view is on the leads convert layout
     * @return {boolean}
     * @private
     */
    _isOnLeadConvert: function() {
        return this.context && this.context.parent && this.context.parent.get('convertModuleList');
    },

/**
     * Gets the RLIs under this Opp
     * @return {*}
     * @private
     */
    _getRliCollection: function() {
        let rliContext = this.context.getChildContext({link: 'revenuelineitems'});
        rliContext.prepare();
        return rliContext.get('collection');
    },

/**
     * Returns true if every RLI is not marked as a service
     * @param rliCollection
     * @return {boolean}
     * @private
     */
    _checkForNonServiceRlis: function(rliCollection) {
        return rliCollection.models.every(model => !app.utils.isTruthy(model.get('service')));
    },

/**
     * Returns true if every RLI has an uneditable duration
     * @param rliCollection
     * @return {boolean}
     * @private
     */
    _checkForLockedDurationServiceRlis: function(rliCollection) {
        let serviceRlis = rliCollection.models.filter(model => app.utils.isTruthy(model.get('service')));
        if (serviceRlis.length === 0) {
            return false;
        }
        return serviceRlis.every(model => {
            return !_.isEmpty(model.get('add_on_to_id')) || app.utils.isTruthy(model.get('lock_duration'));
        });
    },

/**
     * Checks if there are any warnings to show for the cascade fields. Returns the message if a warning exists,
     * or null otherwise.
     * @return {null|string}
     */
    validateCascadeFields: function() {
        if (this.viewBy !== 'RevenueLineItems' || !this.hasRliAccess) {
            return null;
        }

let rliCollection = this._getRliCollection();
        if (_.isEmpty(rliCollection)) {
            return null;
        }

let durationFields = ['service_duration_value', 'service_duration_unit'];
        let durationFieldsEmpty = durationFields.every(field => !this.model.get(field));
        let startDateEmpty = _.isEmpty(this.model.get('service_start_date'));
        let durationChecked = app.utils.isTruthy(this.model.get('service_duration_cascade_checked'));
        let startDateChecked = app.utils.isTruthy(this.model.get('service_start_date_cascade_checked'));

if (this._checkForNonServiceRlis(rliCollection)) {
            let fieldsWithErrors = [];
            if (!durationFieldsEmpty && durationChecked) {
                fieldsWithErrors.push('LBL_SERVICE_DURATION');
            }
            if (!startDateEmpty && startDateChecked) {
                fieldsWithErrors.push('LBL_SERVICE_START_DATE');
            }
            if (!_.isEmpty(fieldsWithErrors)) {
                return this._buildCascadeWarning(fieldsWithErrors, 'LBL_CASCADE_SERVICE_WARNING');
            }
        }

if (this._checkForLockedDurationServiceRlis(rliCollection) && !durationFieldsEmpty && durationChecked) {
            return this._buildCascadeWarning(['LBL_SERVICE_DURATION'], 'LBL_CASCADE_DURATION_WARNING');
        }

return null;
    },

/**
     * Builds the cascade field warnings from the provided field labels
     * @param fieldLabels
     * @param baseLabel
     * @return {string}
     * @private
     */
    _buildCascadeWarning: function(fieldLabels, baseLabel) {
        let translatedFieldLabels = fieldLabels.map(fieldLabel => app.lang.get(fieldLabel, 'Opportunities'));
        let andLabel = app.lang.get('LBL_AND').toLowerCase().trim();
        return translatedFieldLabels.join(` ${andLabel} `) + app.lang.get(baseLabel, 'Opportunities');
    },

/**
     * @inheritdoc
     */
    resetDefaults: function() {
        this._super('resetDefaults');
        if (this.viewBy === 'RevenueLineItems' && this.hasRliAccess) {
            // now lets check for RLI's
            let rliContext = this.context.getChildContext({link: 'revenuelineitems'});
            rliContext.prepare();

// there should be only one record in the related context collection
            // when sugarlogic is initialized on create view
            if (rliContext.get('collection').length === 1) {
                let model = rliContext.get('collection').at(0);
                model.setDefault(model.attributes);
            }
        }
    },

/**
     * Custom logic to make sure that none of the rli records have changed
     *
     * @inheritdoc
     */
    hasUnsavedChanges: function() {
        var ret = this._super('hasUnsavedChanges');
        if (this.viewBy === 'RevenueLineItems' && this.hasRliAccess && ret === false) {
            // now lets check for RLI's
            var rli_context = this.context.getChildContext({link: 'revenuelineitems'});
            rli_context.prepare();

// if there is more than one record in the related context collection, then return true
            if (rli_context.get('collection').length > 1) {
                ret = true;
            } else if (rli_context.get('collection').length === 0) {
                // if there is no RLI in the related context collection, then return false
                ret = false;
            } else {
                // if there is only one model, we need to verify that the model is not dirty.
                // check the non default attributes to make sure they are not empty.
                var model = rli_context.get('collection').at(0),
                    attr_keys = _.difference(_.keys(model.attributes), ['id']),
                    // if the value is not empty and it doesn't equal the default value
                    // we have a dirty model
                    unsavedRliChanges = _.find(attr_keys, function(attr) {
                        var val = model.get(attr);
                        return (!_.isEmpty(val) && (model._defaults[attr] !== val));
                    });

ret = (!_.isUndefined(unsavedRliChanges));
            }
        }

return ret;
    },

/**
     * @inheritdoc
     */
    getCustomSaveOptions: function(options) {
        if (this.viewBy === 'RevenueLineItems') {
            this.createdModel = this.model;
            // since we are in a drawer
            this.listContext = this.context.parent || this.context;
            this.originalSuccess = options.success;

if (app.metadata.getModule(this.module).isTBAEnabled === true) {
                // make sure new RLIs inherit opportunity's teamset and selected teams
                var addedRLIs = this.createdModel.get('revenuelineitems') || false;
                if (addedRLIs && addedRLIs.create && addedRLIs.create.length) {
                    _.each(addedRLIs.create, function (data) {
                        data.team_name = this.createdModel.get('team_name');
                    }, this);
                }
            }

var success = _.bind(function(model) {
                this.originalSuccess(model);
                this._checkForRevenueLineItems(model, options);
            }, this);

return {
                success: success
            };
        }
    },

/**
     * Check for Revenue Line Items, if the user has edit access and non exist, then
     * display the RLI Warning Message.
     *
     * @param {{Data.Bean}} model
     * @param {{object}} options
     * @private
     */
    _checkForRevenueLineItems: function(model, options) {
        // lets make sure we have edit/create access to RLI's
        // if we do, lets make sure that the values where added
        if (this.hasRliAccess) {
            // check to see if we added RLIs during create
            var addedRLIs = model.get('revenuelineitems') || false;
            addedRLIs = (addedRLIs && addedRLIs.create && addedRLIs.create.length);
            if (!addedRLIs) {
                this.showRLIWarningMessage(this.listContext.get('module'));
            }
        }
    },

this.alert = app.alert.show('opp-rli-create', {
            level: 'warning',
            autoClose: false,
            title: app.lang.get('LBL_ALERT_TITLE_WARNING') + ':',
            messages: message,
            onLinkClick: _.bind(function() {
                app.alert.dismiss('create-success');
                this.openRLICreate();
            }, this),
            onClose: _.bind(function() {
                app.routing.offBefore('route', this.dismissAlert, this);
            }, this)
        });
    },

/**
     * Handle dismissing the RLI create alert
     */
    dismissAlert: function(data) {
        // if we are not navigating to the Opps list view, dismiss the alert
        if (data && !(data.args && data.args[0] === 'Opportunities' && data.route === 'list')) {
            app.alert.dismiss('opp-rli-create');
            // close RLI warning alert
            // remove before route event listener
            app.routing.offBefore('route', this.dismissAlert, this);
        }
    },

/**
     * Open a new Drawer with the RLI Create Form
     */
    openRLICreate: function() {
        // close RLI warning alert
        this.dismissAlert(true);

var model = this.createLinkModel(this.createdModel || this.model, 'revenuelineitems');

app.drawer.open({
            layout: 'create',
            context: {
                create: true,
                module: model.module,
                model: model
            }
        }, _.bind(function(model) {
            if (!model) {
                return;
            }

var ctx = this.listContext || this.context;

ctx.reloadData({recursive: false});

// reload opportunities and RLIs subpanels
            ctx.trigger('subpanel:reload', {links: ['opportunities', 'revenuelineitems']});
        }, this));
    },

/**
     * @inheritdoc
     */
    _dispose: function() {
        if (this.alert) {
            this.alert.getCloseSelector().off('click');
        }

this._super('_dispose', []);
    }
}) },
"product-quick-picks-dashlet": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.OpportunitiesProductQuickPicksDashletView
 * @alias SUGAR.App.view.views.BaseOpportunitiesProductQuickPicksDashletView
 * @extends View.Views.Base.ProductQuickPicksDashletView
 * @deprecated Use {@link View.Views.Base.ProductQuickPicksDashletView} instead
 */
({
	// Product-quick-picks-dashlet View (base)

extendsFrom: 'ProductQuickPicksDashletView',

initialize: function(options) {
        app.logger.warn('View.Views.Base.Opportunities.ProductQuickPicksDashletView is deprecated. Use ' +
            'View.Views.Base.ProductQuickPicksDashletView instead');
        this._super('initialize', [options]);
    }
}) },
"activity-card-header": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Basic.ActivityCardHeaderView
 * @alias SUGAR.App.view.views.BaseBasicActivityCardHeaderView
 * @extends View.Views.Base.ActivityCardHeaderView
 */
({
	// Activity-card-header View (base)

extendsFrom: 'ActivityCardHeaderView',

this.hasAvatarUser = !!this.userField;
    }
}) },
"multi-line-list": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Opportunities.MultiLineListView
 * @alias SUGAR.App.view.views.BaseOpportunitiesMultiLineListView
 * @extends View.Views.Base.MultiLineListView
 */
({
	// Multi-line-list View (base)

/**
     * Opportunities sales_status can be customized to included multiple values
     * @override
     */
    setFilterDef: function(options) {
        var meta = options.meta || {};
        // if filterDef exists in meta
        if (meta.filterDef) {
            // perform actions as per the parent class method
            this._super('setFilterDef', [options]);
            return;
        }
        var closedWon = ['Closed Won'];
        var closedLost = ['Closed Lost'];
        var forecastCfg = app.metadata.getModule('Forecasts', 'config');
        if (forecastCfg && forecastCfg.is_setup) {
            closedWon = forecastCfg.sales_stage_won;
            closedLost = forecastCfg.sales_stage_lost;
        }

extendsFrom: "PanelTopView",

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

if (['Accounts', 'Documents'].includes(this.parentModule)) {
            this.on('linked-model:create', this._reloadRevenueLineItems, this);
        }
    },

/**
     * Refreshes the RevenueLineItems subpanel when a new Opportunity is added
     * @private
     */
    _reloadRevenueLineItems: function() {
        if (app.metadata.getModule('Opportunities', 'config').opps_view_by == 'RevenueLineItems') {
            var $rliSubpanel = $('div[data-subpanel-link="revenuelineitems"]');
            // only reload RLI subpanel if it is opened
            if (!$('li.subpanel', $rliSubpanel).hasClass('closed')) {
                this.context.parent.trigger('subpanel:reload', {links: ['revenuelineitems']});
            } else {
                // RLI Panel is closed, filter components to find the RLI panel and update count
                var rliComponent = _.find(this.layout.layout._components, function(component) {
                    return component.module === 'RevenueLineItems';
                });

var cc_field = rliComponent.getComponent('panel-top').getField('collection-count');

app.api.count(this.parentModule, {
                    id: this.context.parent.get('modelId'),
                    link:'revenuelineitems'
                }, {
                    success: function(data) {
                        cc_field.updateCount({ length: data.record_count });
                    }
                });
            }
        }
    }
}) },
"merge-duplicates": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Merge-duplicates View (base)

extendsFrom: 'MergeDuplicatesView',

/**
     * @inheritdoc
     */
    bindDataChange: function() {
        this._super('bindDataChange');

var config = app.metadata.getModule('Forecasts', 'config');

if (config && config.is_setup && config.forecast_by === 'Opportunities' &&
            app.metadata.getServerInfo().flavor !== 'PRO') {
            // make sure forecasts exists and is setup
            this.collection.on('change:sales_stage change:commit_stage reset', function(model) {
                var myModel = model;

//check to see if this is a collection (for the reset event), use this.primaryRecord instead if true;
                if (!_.isUndefined(model.models)) {
                    myModel = this.primaryRecord;
                }
                var salesStage = myModel.get('sales_stage'),
                    commitStage = this.getField('commit_stage');

if (salesStage && commitStage) {
                    if(_.contains(config.sales_stage_won, salesStage)) {
                        // check if the sales_stage has changed to a Closed Won stage
                        if(config.commit_stages_included.length) {
                            // set the commit_stage to the first included stage
                            myModel.set('commit_stage', _.first(config.commit_stages_included));
                        } else {
                            // otherwise set the commit stage to just "include"
                            myModel.set('commit_stage', 'include');
                        }
                        commitStage.setDisabled(true);
                        this.$('input[data-record-id="' + myModel.get('id') + '"][name="copy_commit_stage"]').prop("checked", true);
                    } else if(_.contains(config.sales_stage_lost, salesStage)) {
                        // check if the sales_stage has changed to a Closed Lost stage
                        // set the commit_stage to exclude
                        myModel.set('commit_stage', 'exclude');
                        commitStage.setDisabled(true);
                        this.$('input[data-record-id="' + myModel.get('id') + '"][name="copy_commit_stage"]').prop("checked", true);
                    } else {
                        commitStage.setDisabled(false);
                    }
                }
            }, this);
        }
    }
}) }
}}
,
"layouts": {
"base": {
"config-drawer": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Layouts.Base.OpportunitiesConfigDrawerLayout
 * @alias SUGAR.App.view.layouts.BaseOpportunitiesConfigDrawerLayout
 * @extends View.Layouts.Base.ConfigDrawerLayout
 */
({
	// Config-drawer Layout (base)

extendsFrom: 'ConfigDrawerLayout',

/**
     * Checks Opportunities ACLs to see if the User is a system admin
     * or if the user has a developer role for the Opportunities module
     *
     * @inheritdoc
     */
    _checkModuleAccess: function() {
        var acls = app.user.getAcls().Opportunities,
            isSysAdmin = (app.user.get('type') == 'admin'),
            isDev = (!_.has(acls, 'developer'));

return (isSysAdmin || isDev);
    }
}) },
"config-drawer-content": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Layouts.Base.OpportunitiesConfigDrawerContentLayout
 * @alias SUGAR.App.view.layouts.BaseOpportunitiesConfigDrawerContentLayout
 * @extends View.Layouts.Base.ConfigDrawerContentLayout
 */
({
	// Config-drawer-content Layout (base)

extendsFrom: 'ConfigDrawerContentLayout',

viewOppsByTitle: undefined,
    viewOppsByOppsTpl: undefined,
    viewOppsByRLIsTpl: undefined,

/**
     * @inheritdoc
     */
    _initHowTo: function() {
        this.viewOppsByTitle = app.lang.get('LBL_OPPS_CONFIG_VIEW_BY_LABEL', 'Opportunities');

var helpUrl = {
                more_info_url: '<a href="' + app.help.getMoreInfoHelpURL('config', 'OpportunitiesConfig')
                    + '" target="_blank">',
                more_info_url_close: '</a>'
            },
            viewOppsByOppsObj = app.help.get('Opportunities', 'config_opps', helpUrl),
            viewOppsByRLIsObj = app.help.get('Opportunities', 'config_rlis', helpUrl);

this.viewOppsByOppsTpl = app.template.getLayout(this.name + '.help', this.module)(viewOppsByOppsObj);
        this.viewOppsByRLIsTpl = app.template.getLayout(this.name + '.help', this.module)(viewOppsByRLIsObj);
    },

bindDataChange: function() {
        this._super('bindDataChange');

this.model.on('change:opps_view_by', function(model, oppsViewBy) {
            this.changeHowToData(this.viewOppsByTitle, this._getText(oppsViewBy));
        }, this);
    },
    /**
     * @inheritdoc
     */
    _switchHowToData: function(helpId) {
        switch(helpId) {
            case 'config-opps-view-by':
                this.currentHowToData.title = this.viewOppsByTitle;
                this.currentHowToData.text = this._getText(this.model.get('opps_view_by'));
        }

this._super('_switchHowToData');
    },

/**
     * Returns the proper template text depending on the opps_view_by setting being passed in
     *
     * @param {String} oppsViewBy The Opps View By setting 'Opportunities' | 'RevenueLineItems'
     * @returns {String} HTML Template text for the right help text
     * @private
     */
    _getText: function(oppsViewBy) {
        return (oppsViewBy === 'Opportunities') ? this.viewOppsByOppsTpl : this.viewOppsByRLIsTpl;
    }
}) }
}}
,
"datas": {}

},
		"Cases":{"fieldTemplates": {
"base": {
"case-status": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Cases.CaseStatusField
 * @alias SUGAR.App.view.fields.BaseCasesCaseStatusField
 * @extends View.Fields.Base.EnumColorcodedField
 */
({
	// Case-status FieldTemplate (base)

extendsFrom: 'EnumColorcodedField',
}) }
}}
,
"views": {
"base": {
"request-closed-cases-dashlet": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Cases.RequestClosedCasesDashlet
 * @alias SUGAR.App.view.views.BaseCasesRequestClosedCasesDashlet
 * @extends @extends View.Views.Base.ListView
 */
({
	// Request-closed-cases-dashlet View (base)

plugins: ['Dashlet'],

extendsFrom: 'ListView',

/**
     * Fields displayed in dashlet
     *
     * @property {Array}
     */
    displayedFields: [
        'case_number',
        'name',
        'priority',
        'status',
        'date_modified',
    ],

/**
     * Cases bean collection.
     *
     * @property {Data.BeanCollection}
     */
    collection: null,

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);
        this._initCollection();
    },

/**
     * Initialize feature collection.
     */
    _initCollection: function() {
        var today = app.date().formatServer(true);
        var self = this;
        this.collection = app.data.createBeanCollection(this.module);
        this.collection.setOption({
            fields: this.displayedFields,
            filter: {
                'request_close': {
                    '$equals': 1
                },
                'status': {
                    '$not_in': ['Closed']
                },
                '$owner': ''
            },
        });
        this.collection.displayedFields = this._initDisplayedFields();

// set meta last state id so sorting order is maintained
        this.meta.last_state = {id: 'request-closed-cases-dashlet'};
        this.orderByLastStateKey = app.user.lastState.key('order-by', this);
        this.orderBy = this._initOrderBy();
        if (this.collection) {
            this.collection.orderBy = this.orderBy;
        }

return this;
    },

/**
     * Returns the displayed field objects
     *
     * @return {Array} the field objects
     * @private
     */
    _initDisplayedFields: function() {
        var displayedFields = [];

_.each(this.displayedFields, function(field) {
            if (!this.model.fields) {
                return;
            }
            var toPush = this.model.fields[field];
            toPush.link = (field === 'name') ? true : false;
            displayedFields.push(toPush);
        }, this);

return displayedFields;
    },

/**
     * @inheritdoc
     *
     * Once collection has been changed, the view should be refreshed.
     */
    bindDataChange: function() {
        if (this.collection) {
            this.collection.on('add remove reset', function() {
                if (this.disposed) {
                    return;
                }
                this.render();
            }, this);
        }
    },

/**
     * @inheritdoc
     */
    _setOrderBy: function(options) {
        if (this.orderByLastStateKey) {
            app.user.lastState.set(this.orderByLastStateKey, this.orderBy);
        }
        this.loadData(options);
    },

/**
     * @inheritdoc
     */
    loadData: function(options) {
        this.collection.fetch(options);
    },

}) },
"record": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Record View (base)

extendsFrom: 'RecordView',

contactsSubpanel: null,

this._bindEvents();
    },

/**
     * Initiates listening to application events.
     */
    _bindEvents: function() {
        this.context.on('context:child:add', this.addChildHandler, this);
    },

/**
     * Bind events on Contacts subpanel
     */
    addChildHandler: function(childModel) {
        if (childModel.get('link') === 'contacts') {
            this.contactsSubpanel = childModel;

this.contactsSubpanel.on('reload', _.bind(function() {
                this.context.reloadData();
            }, this));
        }
    },

/**
     * @inheritdoc
     */
    _dispose: function() {
        this.context.off('context:child:add', this.addChildHandler, this);

this._super('_dispose');
    },
}) },
"activity-card-content": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Cases.ActivityCardContentView
 * @alias SUGAR.App.view.views.BaseCasesActivityCardContentView
 * @extends View.Views.Base.ActivityCardContentView
 */
({
	// Activity-card-content View (base)

extendsFrom: 'ActivityCardContentView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);
        this.initAttachmentDetails('attachment_list');
    },
}) },
"create": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Cases.CreateView
 * @alias SUGAR.App.view.views.CasesCreateView
 * @extends View.Views.Base.CreateView
 */
({
	// Create View (base)

extendsFrom: 'CreateView',

/*
     * Enable pre-population from Omnichanel
     */
    omniPopulation: true,
}) },
"activity-card-header": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Cases.ActivityCardHeaderView
 * @alias SUGAR.App.view.views.BaseNotesActivityCardHeaderView
 * @extends View.Views.Base.ActivityCardHeaderView
 */
({
	// Activity-card-header View (base)

extendsFrom: 'ActivityCardHeaderView',

/**
     * @inheritdoc
     */
    setUsersFields: function() {
        const panel = this.getUsersPanel();
        this.userField = _.find(panel.fields, function(field) {
            return field.name === 'assigned_user_name';
        });

this.hasAvatarUser = !!this.userField;
    }
}) },
"multi-line-list": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Cases.MultiLineListView
 * @alias SUGAR.App.view.views.CasesCreateView
 * @extends View.Views.Base.MultiLineListView
 */
({
	// Multi-line-list View (base)

/**
     * @inheritdoc
     */
    extendsFrom: 'MultiLineListView',

/**
     * @inheritdoc
     */
    _setConfig: function(options) {
        this._super('_setConfig', [options]);
        if (this.metric &&
            ['follow_up_datetime'].includes(this.metric.order_by_primary, this.metric.order_by_secondary)) {
            options.meta.collectionOptions.params.order_by += ',case_number:asc';
        }
    }
}) }
}}
,
"layouts": {}
,
"datas": {}

},
		"Notes":{"fieldTemplates": {
"base": {
"multi-attachments": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */

/**
 * Multi Attachment modifications specific to Notes. These
 * modifications create a pill for files stored directly
 * on the note record's file fields.
 *
 * @class View.Fields.Base.Notes.MultiAttachmentsField
 * @alias SUGAR.App.view.fields.BaseNotesMultiAttachmentsField
 * @extends View.Fields.Base.MultiAttachmentsField
 */

({
	// Multi-attachments FieldTemplate (base)

/**
     * Override multi-attachments field for notes
     */
    extendsFrom: 'BaseMultiAttachmentsField',

/**
     * Name of file field on model
     */
    fileFieldName: 'filename',

/**
     * Name of field holding file mime type
     */
    fileMimeTypeFieldName: 'file_mime_type',

/**
     * If we are displaying only a single image, we show preview for it
     */
    singleImage: false,

/**
     * Mapping of accepted image mimetypes to file extensions
     */
    supportedImageExtensions: {
        'image/jpeg': 'jpg',
        'image/png': 'png',
        'image/gif': 'gif'
    },

/**
     * Re-render when the file and mimetype fields change
     */
    bindDataChange: function() {
        this._super('bindDataChange');
        this.model.on('change:' + this.fileFieldName, this.render, this);
        this.model.on('change:' + this.fileMimeTypeFieldName, this.render, this);
    },

/**
     * Override format to add/remove single file pills, and set flag for image
     * preview
     *
     * @param {array} value array of field pills
     * @returns {array} formatted array of field pills
     */
    format: function(value) {
        if (!this._pillAdded(value) && this._modelHasFileAttachment()) {
            var attr = this._getPillFromFile();

if (value instanceof app.BeanCollection) {
                var model = app.data.createBean('Notes', attr);
                value.models.push(model);
            } else {
                value.push(attr);
            }
        }
        value = this._super('format', [value]);
        this.singleImage = this._singleImagePill(value);
        return value;
    },

/**
     * Determine if a pill has already been added to this field for an
     * attachment stored directly on the note.
     * @param value
     * @returns {boolean}
     * @private
     */
    _pillAdded: function(value) {
        value = value instanceof app.BeanCollection ? value.models : value;

return _.reduce(value, function(base, item) {
            item = item instanceof Backbone.Model ? item.toJSON() : item;
            return base || item.id === this.model.id;
        }, false, this);
    },

/**
     * Util to see if this model has a file stored directly
     * @returns {boolean}
     * @private
     */
    _modelHasFileAttachment: function() {
        return !!(this.model.get(this.fileFieldName) &&
                  this.model.get(this.fileMimeTypeFieldName));
    },

/**
     * Creates a pill in the format needed by select2 for file stored directly
     * on the note.
     * @returns {Object} {filename: file name,
     *                    id: ID of this note for file link,
     *                    file_mime_type: file mime type}
     * @private
     */
    _getPillFromFile: function() {
        var attr = {id: this.model.get('id')};
        attr[this.fileFieldName] = this.model.get(this.fileFieldName);
        attr[this.fileMimeTypeFieldName] = this.model.get(this.fileMimeTypeFieldName);
        return attr;
    },

/**
     * Override base field's removeAttachment method to remove file stored
     * directly on the note if needed
     * @param event {Object}
     */
    removeAttachment: function(event) {
        if (event.val === this.model.get('id')) {
            this._removeLegacyAttachment();
            this.pillAdded = false;
            this.render();
        } else {
            this._super('removeAttachment', [event]);
        }
    },

/**
     * Removes file stored directly on the note
     * @private
     */
    _removeLegacyAttachment: function() {
        this.model.set(this.fileFieldName, '');
        var value = this.model.get(this.name).models;
        this.model.get(this.name).models = _.filter(value, function(model) {
            return model.get('id') !== this.model.get('id');
        }, this);
    },

/**
     * Check if input mime type is an image or not.
     *
     * @param {String} mimeType - file mime type.
     * @return {Boolean} true if mime type is an image.
     * @private
     */
    _isImage: function(mimeType) {
        return !!this.supportedImageExtensions[mimeType];
    },

/**
     * Check if we're rendering a single pill for an image file
     * @param {array} value - list of pills to display
     * @returns {boolean}
     * @private
     */
    _singleImagePill: function(value) {
        return value && value.length === 1 && value[0].mimeType === 'image';
    }
}) }
}}
,
"views": {
"base": {
"recordlist": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.NotesRecordlistView
 * @alias SUGAR.App.view.views.BaseNotesRecordlistView
 * @extends View.Views.Base.RecordlistView
 */
({
	// Recordlist View (base)

extendsFrom: 'RecordlistView',

/**
     * Get row fields (except 'multi-attachments') of the model
     *
     * @param {string} modelId Model Id.
     * @return {Array} list of fields objects
     */
    getModelRowFields: function(modelId) {
        var fields = _.filter(this.rowFields[modelId], _.bind(function(field) {
            return (field.type !== 'multi-attachments');
        }, this));

return fields;
    },
}) },
"record": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Record View (base)

extendsFrom: 'RecordView',

duplicateClicked: function() {
        let self = this;
        let prefill = app.data.createBean('Notes');

prefill.copy(this.model);
        this._copyNestedCollections(this.model, prefill);
        self.model.trigger('duplicate:before', prefill);
        prefill.unset('id');
        prefill.unset('is_escalated');
        prefill.attributes.attachment_list.models = [];

app.drawer.open({
            layout: 'create',
            context: {
                create: true,
                model: prefill,
                copiedFromModelId: this.model.get('id')
            }
        }, function(context, newModel) {
            if (newModel && newModel.id) {
                if (self.closestComponent('side-drawer')) {
                    let recordContext = {
                        layout: 'record',
                        dashboardName: newModel.get('name'),
                        context: {
                            layout: 'record',
                            name: 'record-drawer',
                            contentType: 'record',
                            modelId: newModel.id,
                            dataTitle: app.sideDrawer.getDataTitle('Notes', 'LBL_RECORD', newModel.get('name'))
                        }
                    };
                    app.sideDrawer.open(recordContext, null, true);
                    return;
                }
                app.router.navigate('Notes' + '/' + newModel.id, {trigger: true});
            }
        });

prefill.trigger('duplicate:field', self.model);
    }
}) },
"activity-card-content": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Notes.ActivityCardContentView
 * @alias SUGAR.App.view.views.BaseNotesActivityCardContentView
 * @extends View.Views.Base.ActivityCardContentView
 */
({
	// Activity-card-content View (base)

extendsFrom: 'ActivityCardContentView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);
        this.formatDescriptionField();
        this.initAttachmentDetails('attachment_list');
    },

/**
     * Formats the description field to account for line breaks
     */
    formatDescriptionField: function() {
        if (this.activity) {
            var description = this.activity.get('description');
            this.descriptionField = this.formatContent(description);
        }
    }
}) },
"activity-card-detail": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Notes.ActivityCardDetailView
 * @alias SUGAR.App.view.views.BaseNotesActivityCardDetailView
 * @extends View.Views.Base.ActivityCardDetailView
 */
({
	// Activity-card-detail View (base)

extendsFrom: 'ActivityCardDetailView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);
        this.initPortalFlagDetails();
    },

/**
     * Initializes hbs entry source variable
     */
    initPortalFlagDetails: function() {
        if (this.activity) {
            this.portalFlag = this.activity.get('portal_flag');
        }
    }
}) },
"activity-card-header": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Notes.ActivityCardHeaderView
 * @alias SUGAR.App.view.views.BaseNotesActivityCardHeaderView
 * @extends View.Views.Base.ActivityCardHeaderView
 */
({
	// Activity-card-header View (base)

extendsFrom: 'ActivityCardHeaderView',

/**
     * @inheritdoc
     */
    setUsersFields: function() {
        var panel = this.getUsersPanel();
        this.userField = _.find(panel.fields, function(field) {
            return field.name === 'modified_by_name';
        });

this.hasAvatarUser = !!this.userField;
    }
}) }
}}
,
"layouts": {}
,
"datas": {}

},
		"Calls":{"fieldTemplates": {
"base": {
"label": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Calls.LabelField
 * @alias SUGAR.App.view.fields.BaseCallsLabelField
 * @extends View.Fields.Base.LabelField
 */
({
	// Label FieldTemplate (base)

/**
     * @inheritdoc
     *
     * Returns the `detail` template for this type of field
     */
    _getFallbackTemplate: function(viewName) {
        return 'detail';
    },
}) },
"call-recording": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Calls.CallRecordingField
 * @alias SUGAR.App.view.fields.BaseCallsCallRecordingField
 * @extends View.Fields.Base.BaseField
 */
({
	// Call-recording FieldTemplate (base)

/**
     * The call recording URL
     */
    recordingUrl: '',

/**
     * The friendly display name
     */
    recordingName: '',

/**
     * @inheritdoc
     */
    _render: function() {
        this.setRecordingUrl();
        this._super('_render');
    },

/**
     * Set the call recording URL and the friendly display name
     */
    setRecordingUrl: function() {
        this.recordingUrl = this.model.get('call_recording_url');

if (this.recordingUrl) {
            this.recordingName = app.date(this.model.get('date_entered')).formatUser();
        }
    }
}) },
"record-decor": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Calls.RecordDecorFields
 * @alias SUGAR.App.view.fields.BaseCallsRecordDecorField
 * @extends View.Fields.Base.RecordDecorField
 */
({
	// Record-decor FieldTemplate (base)

extendsFrom: 'RecordDecorField',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['RecurringEvents']);
        this._super('initialize', [options]);
    }
}) },
"textarea": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Calls.TextareaField
 * @alias SUGAR.App.view.fields.BaseCallsTextareaField
 * @extends View.Fields.Base.TextareaField
 */
({
	// Textarea FieldTemplate (base)

extendsFrom: 'textarea',

transcriptFields: [
        'transcript',
    ],

/**
     * Add empty-transcript class to transcript fields if the field is empty.
     *
     * @param {string} value - field contents
     * @return {string} value - formatted field contents
     */
    format: function(value) {
        if (_.contains(this.transcriptFields, this.name)) {
            this.$el.toggleClass('empty-transcript', !value);
        }
        return this._super('format', [value]);
    }
}) }
}}
,
"views": {
"base": {
"create-no-cancel-button": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Calls.CreateNoCancelButtonView
 * @alias SUGAR.App.view.views.CallsCreateNoCancelButtonView
 * @extends View.Views.Base.CreateNoCancelButtonView
 */
({
	// Create-no-cancel-button View (base)

extendsFrom: 'CreateNoCancelButtonView',

/**
     * Additional plugins for this module
     */
    additionalPlugins: [
        'AddAsInvitee',
        'ReminderTimeDefaults',
    ],

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], this.additionalPlugins);
        this._super('initialize', [options]);
    }
}) },
"dashablerecord": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */

/**
 * @class View.Views.Base.Calls.DashablerecordView
 * @alias SUGAR.App.view.views.CallsDashablerecordView
 * @extends View.Views.Base.DashablerecordView
 */
({
	// Dashablerecord View (base)

extendsFrom: 'DashablerecordView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['RecurringEvents']);
        this._super('initialize', [options]);
    },
}) },
"resolve-conflicts-list": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Calls.ResolveConflictsListView
 * @alias SUGAR.App.view.views.BaseCallsResolveConflictsListView
 * @extends View.Views.Base.ResolveConflictsListView
 */
({
	// Resolve-conflicts-list View (base)

extendsFrom: 'ResolveConflictsListView',

/**
     * @inheritdoc
     *
     * The invitees field should not be displayed on list views. It is removed
     * before comparing models so that it doesn't get included.
     */
    _buildFieldDefinitions: function(modelToSave, modelInDb) {
        modelToSave.unset('invitees');
        this._super('_buildFieldDefinitions', [modelToSave, modelInDb]);
    }
}) },
"record": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Record View (base)

extendsFrom: 'RecordView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['EditAllRecurrences', 'AddAsInvitee', 'RecurringEvents']);
        this._super('initialize', [options]);
    }
}) },
"create": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Calls.CreateView
 * @alias SUGAR.App.view.views.CallsCreateView
 * @extends View.Views.Base.CreateView
 */
({
	// Create View (base)

extendsFrom: 'CreateView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['AddAsInvitee', 'ReminderTimeDefaults']);
        this._super('initialize', [options]);
    }
}) },
"activity-card-header": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Calls.ActivityCardHeaderView
 * @alias SUGAR.App.view.views.BaseCallsActivityCardHeaderView
 * @extends View.Views.Base.ActivityCardHeaderView
 */
({
	// Activity-card-header View (base)

extendsFrom: 'ActivityCardHeaderView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);
        this.setUsersFields();
    },

/**
     * @inheritdoc
     *
     * Do not set user fields as that will be set after activity fetch
     */
    setUsersPanel: function() {
        this.setUsersTemplate();
    },

/**
     * @inheritdoc
     */
    setUsersFields: function() {
        this.setInvitees();
    },
}) },
"create-nodupecheck": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Calls.CreateNodupecheckView
 * @alias SUGAR.App.view.views.CallsCreateNodupecheckView
 * @extends View.Views.Base.CreateNodupecheckView
 */
({
	// Create-nodupecheck View (base)

extendsFrom: 'CreateNodupecheckView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['AddAsInvitee', 'ReminderTimeDefaults']);
        this._super('initialize', [options]);
    }
}) }
}}
,
"layouts": {}
,
"datas": {
"base": {
"model": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class Model.Datas.Base.CallsModel
 * @alias SUGAR.App.model.datas.BaseCallsModel
 * @extends Model.Bean
 */
({
	// Model Data (base)

plugins: ['VirtualCollection']
}) }
}}

},
		"Emails":{"fieldTemplates": {
"base": {
"sender": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Emails.SenderField
 * @alias SUGAR.App.view.fields.BaseEmailsSenderField
 * @extends View.Fields.Base.BaseField
 * @deprecated Use {@link View.Fields.Base.Emails.OutboundEmailField} instead.
 */
({
	// Sender FieldTemplate (base)

fieldTag: 'input.select2',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        app.logger.warn('View.Fields.Base.Emails.SenderField is deprecated. Use ' +
            'View.Fields.Base.Emails.OutboundEmailField instead.');

this._super('initialize', [options]);
        this.endpoint = this.def.endpoint;
    },

_render: function() {
        var result = app.view.Field.prototype._render.call(this);

if (this.tplName === 'edit') {
            var action = (this.endpoint.action) ? this.endpoint.action : null,
                attributes = (this.endpoint.attributes) ? this.endpoint.attributes : null,
                params = (this.endpoint.params) ? this.endpoint.params : null,
                myURL = app.api.buildURL(this.endpoint.module, action, attributes, params);

app.api.call('GET', myURL, null, {
                success: _.bind(this.populateValues, this),
                error: function(error) {
                    // display error if not a metadata refresh
                    if (error.status !== 412) {
                        app.alert.show('server-error', {
                            level: 'error',
                            messages: 'ERR_GENERIC_SERVER_ERROR'
                        });
                    }
                    app.error.handleHttpError(error);
                }
            });
        }

return result;
    },

populateValues: function(results) {
        var self = this,
            defaultResult,
            defaultValue = {};

if (this.disposed === true) {
            return; //if field is already disposed, bail out
        }

if (!_.isEmpty(results)) {
            defaultResult = _.find(results, function(result) {
                return result.default;
            });

defaultValue = (defaultResult) ? defaultResult : results[0];

if (!this.model.has(this.name)) {
                this.model.set(this.name, defaultValue.id);
                this.model.setDefault(this.name, defaultValue.id);
            }
        }

var format = function(item) {
            return item.display;
        };

this.$(this.fieldTag).select2({
            data:{ results: results, text: 'display' },
            formatSelection: format,
            formatResult: format,
            width: '100%',
            placeholder: app.lang.get('LBL_SELECT_FROM_SENDER', this.module),
            initSelection: function(el, callback) {
                if (!_.isEmpty(defaultValue)) {
                      callback(defaultValue);
                }
            }
        }).on("change", function(e) {
            if (self.model.get(self.name) !== e.val) {
                self.model.set(self.name, e.val, {silent: true});
            }
        });
    },

/**
     * @inheritdoc
     *
     * We need this empty so it won't affect refresh the select2 plugin
     */
    bindDomChange: function() {
    }
}) },
"attachment-button": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * Attachment button is a label that is styled like a button and will trigger a
 * given file input field.
 *
 * @class View.Fields.Base.Emails.AttachmentButtonField
 * @alias SUGAR.App.view.fields.BaseEmailsAttachmentButtonField
 * @extends View.Fields.Base.ButtonField
 * @deprecated Use {@link View.Fields.Base.Emails.EmailAttachmentsField}
 * instead.
 */
({
	// Attachment-button FieldTemplate (base)

extendsFrom: 'ButtonField',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        app.logger.warn('View.Fields.Base.Emails.AttachmentButtonField is deprecated. Use ' +
            'View.Fields.Base.Emails.EmailAttachmentsField instead.');

this._super('initialize',[options]);
        this.fileInputId = this.context.get('attachment_field_email_attachment');
    }
}) },
"from": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Emails.FromField
 * @alias SUGAR.App.view.fields.BaseEmailsFromField
 * @extends View.Fields.Base.BaseField
 */
({
	// From FieldTemplate (base)

/**
     * @inheritdoc
     *
     * This field doesn't support `showNoData`.
     */
    showNoData: false,

/**
     * The selector for accessing the Select2 field when in edit mode. The
     * Select2 field is where the sender is displayed.
     *
     * @property {string}
     */
    fieldTag: 'input.select2',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['EmailParticipants', 'ListEditable']);
        this._super('initialize', [options]);

// Specify the error label for when the sender's email address is
        // invalid.
        app.error.errorName2Keys[this.type] = app.lang.get('ERR_INVALID_SENDER', this.module);
    },

/**
     * @inheritdoc
     */
    bindDataChange: function() {
        if (this.model) {
            // Avoids a full re-rendering when editing. The current value of
            // the field is formatted and passed directly to Select2 when in
            // edit mode.
            this.listenTo(this.model, 'change:' + this.name, _.bind(function() {
                var $el = this.$(this.fieldTag);

if (_.isEmpty($el.data('select2'))) {
                    this.render();
                } else {
                    $el.select2('data', this.getFormattedValue());
                }
            }, this));
        }
    },

/**
     * @inheritdoc
     */
    bindDomChange: function() {
        var $el = this.$(this.fieldTag);

$el.on('select2-selecting', _.bind(function(event) {
            if (this.disposed) {
                event.preventDefault();
            }
        }, this));

$el.on('change', _.bind(function(event) {
            var collection;

if (this.model && !this.disposed) {
                collection = this.model.get(this.name);

if (!_.isEmpty(event.added)) {
                    // Replace the current model in the collection, as there
                    // can only be one.
                    collection.remove(collection.models);
                    collection.add(event.added);
                }

if (!_.isEmpty(event.removed)) {
                    collection.remove(event.removed);
                }
            }
        }, this));
    },

/**
     * @inheritdoc
     *
     * Destroys the Select2 element.
     */
    unbindDom: function() {
        this.$(this.fieldTag).select2('destroy');
        this._super('unbindDom');
    },

/**
     * @inheritdoc
     */
    _render: function() {
        var $el;
        var options;

this._super('_render');

$el = this.$(this.fieldTag);

if ($el.length > 0) {
            options = this.getSelect2Options();
            options = _.extend(options, {
                allowClear: !this.def.required,
                multiple: false,

/**
                 * Constructs a representation for a selected sender to be
                 * displayed in the field.
                 *
                 * See [Select2 Documentation](http://ivaynberg.github.io/select2/#documentation).
                 *
                 * @param {Data.Bean} sender
                 * @return {string}
                 * @private
                 */
                formatSelection: _.bind(function(sender) {
                    var template = app.template.getField(this.type, 'select2-selection', this.module);

return sender ? template({value: sender.toHeaderString({quote_name: true})}) : '';
                }, this),

/**
                 * Constructs a representation for the sender to be displayed
                 * in the dropdown options after a query.
                 *
                 * See [Select2 Documentation](http://ivaynberg.github.io/select2/#documentation).
                 *
                 * @param {Data.Bean} sender
                 * @return {string}
                 */
                formatResult: _.bind(function(sender) {
                    var template = app.template.getField(this.type, 'select2-result', this.module);

return template({
                        value: sender.toHeaderString({quote_name: true}),
                        module: sender.get('parent_type')
                    });
                }, this),

/**
                 * Don't escape a choice's markup since we built the HTML.
                 *
                 * See [Select2 Documentation](https://select2.github.io/select2/#documentation).
                 *
                 * @param {string} markup
                 * @return {string}
                 */
                escapeMarkup: function(markup) {
                    return markup;
                }
            });
            $el.select2(options).select2('val', []);

if (this.isDisabled()) {
                $el.select2('disable');
            }
        }
    },

/**
     * @inheritdoc
     * @return {Data.Bean}
     */
    format: function(value) {
        // Reset the tooltip.
        this.tooltip = '';

if (value instanceof app.BeanCollection) {
            value = value.first();

if (value) {
                value = this.prepareModel(value);
            }

if (value) {
                this.tooltip = value.toHeaderString();
            }
        }

return value;
    }
}) },
"forward-action": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * Forward action.
 *
 * This allows a user to "forward" an existing email.
 *
 * @class View.Fields.Base.Emails.ForwardActionField
 * @alias SUGAR.App.view.fields.EmailsBaseForwardActionField
 * @extends View.Fields.Base.EmailactionField
 */
({
	// Forward-action FieldTemplate (base)

extendsFrom: 'EmailactionField',

/**
     * Template for forward header.
     *
     * @protected
     */
    _tplHeaderHtml: null,

/**
     * The name of the template for forward header.
     *
     * @protected
     */
    _tplHeaderHtmlName: 'forward-header-html',

/**
     * The prefix to apply to the subject.
     *
     * @protected
     */
    _subjectPrefix: 'LBL_FW',

/**
     * The element ID to use to identify the forward content.
     *
     * The ID is added to the div wrapper around the content for later
     * identifying the portion of the email body which is the forward content
     * (e.g., when inserting templates into an email, but maintaining the
     * forward content).
     *
     * @protected
     */
    _contentId: 'forwardcontent',

/**
     * @inheritdoc
     *
     * The forward content is built ahead of the button click to support the
     * option of doing a mailto link which needs to be built and set in the DOM
     * at render time.
     */
    initialize: function(options) {
        this._super('initialize', [options]);

// Use field templates from emailaction.
        this.type = 'emailaction';

this.addEmailOptions({
            // If there is a default signature in email compose, it should be
            // placed above the forward content in the email body.
            signature_location: 'above',
            // Focus the editor and place the cursor at the beginning of all
            // content.
            cursor_location: 'above',
            // Prevent prepopulating the email with case data.
            skip_prepopulate_with_case: true
        });
    },

/**
     * Returns the subject to use in the email.
     *
     * Any instances of "Re: ", "FW: ", and "FWD: " (case-insensitive) found at
     * the beginning of the subject are removed prior to applying the prefix.
     *
     * @see EmailClientLaunch plugin.
     * @param {Data.Bean} model Use this model when constructing the subject.
     * @return {undefined|string}
     */
    emailOptionSubject: function(model) {
        var pattern = /^((?:re|fw|fwd): *)*/i;
        var subject = model.get('name') || '';

return app.lang.get(this._subjectPrefix, model.module) + ': ' + subject.replace(pattern, '');
    },

/**
     * Returns the plain-text body to use in the email.
     *
     * @see EmailClientLaunch plugin.
     * @param {Data.Bean} model Use this model when constructing the body.
     * @return {undefined|string}
     */
    emailOptionDescription: function(model) {
        var headerParams;
        var header;
        var body;
        var description;

if (!this.useSugarEmailClient()) {
            headerParams = this._getHeaderParams(model);
            header = this._getHeader(headerParams);
            body = model.get('description') || '';
            description = '\n' + header + '\n' + body;
        }

return description;
    },

/**
     * Returns the HTML body to use in the email.
     *
     * Ensure the result is a defined string and strip any signature wrapper
     * tags to ensure it doesn't get stripped if we insert a signature above
     * the forward content. Also strip any reply content class if this is a
     * forward to a previous reply. And strip any forward content class if this
     * is a forward to a previous forward.
     *
     * @see EmailClientLaunch plugin.
     * @param {Data.Bean} model Use this model when constructing the body.
     * @return {undefined|string}
     */
    emailOptionDescriptionHtml: function(model) {
        var tplHeaderHtml = this._getHeaderHtmlTemplate();
        var headerParams = this._getHeaderParams(model);
        var headerHtml = tplHeaderHtml(headerParams);
        var body = model.get('description_html') || '';

body = body.replace('<div class="signature">', '<div>');
        body = body.replace('<div id="replycontent">', '<div>');
        body = body.replace('<div id="forwardcontent">', '<div>');

return '<div></div><div id="' + this._contentId + '">' + headerHtml + body + '</div>';
    },

/**
     * Returns the attachments to use in the email.
     *
     * @see EmailClientLaunch plugin.
     * @param {Data.Bean} model Use this model when building the attachments.
     * @return {undefined|Array}
     */
    emailOptionAttachments: function(model) {
        return model.get('attachments_collection').map(function(attachment) {
            var filename = attachment.get('filename') || attachment.get('name');

return {
                _link: 'attachments',
                upload_id: attachment.get('upload_id') || attachment.get('id'),
                name: filename,
                filename: filename,
                file_mime_type: attachment.get('file_mime_type'),
                file_size: attachment.get('file_size'),
                file_ext: attachment.get('file_ext')
            };
        });
    },

/**
     * Returns the bean to use as the email's related record.
     *
     * @see EmailClientLaunch plugin.
     * @param {Data.Bean} model This model's parent is used as the email's
     * related record.
     * @return {undefined|Data.Bean}
     */
    emailOptionRelated: function(model) {
        if (model.link && model.link.type === 'card-link' && model.link.bean) {
            return model.link.bean;
        }

var parent;

if (model.get('parent') && model.get('parent').type && model.get('parent').id) {
            // We omit type because it is actually the module name and should
            // not be treated as an attribute.
            parent = app.data.createBean(model.get('parent').type, _.omit(model.get('parent'), 'type'));
        } else if (model.get('parent_type') && model.get('parent_id')) {
            parent = app.data.createBean(model.get('parent_type'), {
                id: model.get('parent_id'),
                name: model.get('parent_name')
            });
        }

return parent;
    },

/**
     * Returns the teamset array to seed the email's teams.
     *
     * @see EmailClientLaunch plugin.
     * @param {Data.Bean} model This model's teams is used as the email's
     * teams.
     * @return {undefined|Array}
     */
    emailOptionTeams: function(model) {
        return model.get('team_name');
    },

/**
     * Build the header for text only emails.
     *
     * @param {Object} params
     * @param {string} params.from
     * @param {string} [params.date] Date original email was sent
     * @param {string} params.to
     * @param {string} [params.cc]
     * @param {string} params.name The subject of the original email.
     * @return {string}
     * @private
     */
    _getHeader: function(params) {
        var header = '-----\n' + app.lang.get('LBL_FROM', params.module) + ': ' + (params.from || '') + '\n';
        var date;

if (params.date) {
            date = app.date(params.date).formatUser();
            header += app.lang.get('LBL_DATE', params.module) + ': ' + date + '\n';
        }

header += app.lang.get('LBL_TO_ADDRS', params.module) + ': ' + (params.to || '') + '\n';

if (params.cc) {
            header += app.lang.get('LBL_CC', params.module) + ': ' + params.cc + '\n';
        }

header += app.lang.get('LBL_SUBJECT', params.module) + ': ' + (params.name || '') + '\n';

return header;
    },

/**
     * Returns the template for producing the header HTML for the top of the
     * forward content.
     *
     * @return {Function}
     * @private
     */
    _getHeaderHtmlTemplate: function() {
        // Use `this.def.type` because `this.type` was changed to `emailaction`
        // during initialization.
        this._tplHeaderHtml = this._tplHeaderHtml ||
            app.template.getField(this.def.type, this._tplHeaderHtmlName, this.module);
        return this._tplHeaderHtml;
    },

/**
     * Get the data required by the header template.
     *
     * @param {Data.Bean} model The params come from this model's attributes.
     * EmailClientLaunch plugin should dictate the model based on the context.
     * @return {Object}
     * @protected
     */
    _getHeaderParams: function(model) {
        return {
            module: model.module,
            from: this._formatEmailList(model.get('from_collection')),
            date: model.get('date_sent'),
            to: this._formatEmailList(model.get('to_collection')),
            cc: this._formatEmailList(model.get('cc_collection')),
            name: model.get('name')
        };
    },

/**
     * Given a list of people, format a text only list for use in a forward
     * header.
     *
     * @param {Data.BeanCollection} collection A list of models
     * @protected
     */
    _formatEmailList: function(collection) {
        return collection.map(function(model) {
            return model.toHeaderString();
        }).join(', ');
    }
}) },
"recipients-fieldset": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * Recipients field group for handling expand to edit
 *
 * @class View.Fields.Base.Emails.RecipientsFieldsetField
 * @alias SUGAR.App.view.fields.BaseEmailsRecipientsFieldsetField
 * @extends View.Fields.Base.FieldsetField
 */
({
	// Recipients-fieldset FieldTemplate (base)

extendsFrom: 'FieldsetField',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.events = _.extend({}, this.events, {
            'click [data-toggle-field]': '_handleToggleButtonClick'
        });
        this._super('initialize', [options]);
    },

/**
     * Adds the CC and BCC toggle buttons to the From field and sets the
     * visibility of those fields. Switches the field to edit mode when there
     * are no recipients and the user is creating an email.
     *
     * @inheritdoc
     */
    _render: function() {
        var cc = this.model.get('cc_collection');
        var bcc = this.model.get('bcc_collection');

this._super('_render');

this._addToggleButtons('outbound_email_id');
        this._toggleFieldVisibility('cc_collection', !!cc.length);
        this._toggleFieldVisibility('bcc_collection', !!bcc.length);
    },

/**
     * @inheritdoc
     * @example
     * // Only the To field has recipients.
     * a@b.com, b@c.com
     * @example
     * // All fields have recipients.
     * a@b.com; CC: c@d.com; BCC: e@f.com
     * @example
     * // CC does not have recipients.
     * a@b.com; BCC: e@f.com
     * @example
     * Only the CC field has recipients.
     * CC: c@d.com
     */
    format: function(value) {
        return _.chain(this.fields)
            // The from field is not used for calculating the value.
            .where({type: 'email-recipients'})
            // Construct each field's string from it's formatted value.
            .reduce(function(fields, field) {
                var models = field.getFormattedValue();
                var str = _.map(models, function(model) {
                    var name = model.get('parent_name') || '';
                    var email = model.get('email_address') || '';

// The name was erased, so let's use the label.
                    if (_.isEmpty(name) && model.isNameErased()) {
                        name = app.lang.get('LBL_VALUE_ERASED', model.module);
                    }

if (!_.isEmpty(name)) {
                        return name;
                    }

// The email was erased, so let's use the label.
                    if (_.isEmpty(email) && model.isEmailErased()) {
                        email = app.lang.get('LBL_VALUE_ERASED', model.module);
                    }

return email;
                }).join(', ');

if (!_.isEmpty(str)) {
                    fields[field.name] = str;
                }

return fields;
            }, {})
            // Add the label for each field's string.
            .map(function(field, fieldName) {
                var label = '';

if (fieldName === 'cc_collection') {
                    label = app.lang.get('LBL_CC', this.module) + ': ';
                } else if (fieldName === 'bcc_collection') {
                    label = app.lang.get('LBL_BCC', this.module) + ': ';
                }

return label + field;
            }, this)
            .value()
            // Separate each field's string by a semi-colon.
            .join('; ');
    },

/**
     * Add CC and BCC toggle buttons to the field.
     *
     * @param {string} fieldName The name of the field where the buttons are
     * added.
     * @private
     */
    _addToggleButtons: function(fieldName) {
        var field = this.view.getField(fieldName);
        var $field;
        var template;
        var html;

if (!field) {
            return;
        }

$field = field.$el.closest('.fieldset-field');

if ($field.length > 0) {
            template = app.template.getField(this.type, 'recipient-options', this.module);
            html = template({module: this.module});
            $(html).appendTo($field);
        }
    },

/**
     * Toggle the visibility of the field associated with the button that was
     * clicked.
     *
     * @param {Event} event
     * @private
     */
    _handleToggleButtonClick: function(event) {
        var $toggleButton = $(event.currentTarget);
        var fieldName = $toggleButton.data('toggle-field');

this._toggleFieldVisibility(fieldName);
    },

/**
     * Toggles the visibility of the field and the toggle state of its
     * associated button.
     *
     * @param {string} fieldName The name of the field to toggle.
     * @param {boolean} [show] True when the button should be inactive and the
     * field should be shown. The toggle is flipped when undefined.
     * @private
     */
    _toggleFieldVisibility: function(fieldName, show) {
        var toggleButtonSelector = '[data-toggle-field="' + fieldName + '"]';
        var $toggleButton = this.$(toggleButtonSelector);
        var field = this.view.getField(fieldName);

// if explicit active state not set, toggle to opposite
        if (_.isUndefined(show)) {
            show = !$toggleButton.hasClass('active');
        }

$toggleButton.toggleClass('active', show);

if (field) {
            field.$el.closest('.fieldset-group').toggleClass('hide', !show);
        }

this.view.trigger('email-recipients:toggled');
    }
}) },
"reply-all-action": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * Reply all action.
 *
 * This allows a user to "reply all" to an existing email.
 *
 * @class View.Fields.Base.Emails.ReplyAllActionField
 * @alias SUGAR.App.view.fields.EmailsBaseReplyAllActionField
 * @extends View.Fields.Base.Emails.ReplyActionField
 */
({
	// Reply-all-action FieldTemplate (base)

extendsFrom: 'EmailsReplyActionField',

/**
     * Returns the recipients to use in the To field of the email. The sender
     * and the recipients in the To field from the original email are included.
     *
     * @see EmailClientLaunch plugin.
     * @param {Data.Bean} model Use this model when identifying the recipients.
     * @return {undefined|Array}
     */
    emailOptionTo: function(model) {
        var originalTo = model.get('to_collection');
        var to = this._super('emailOptionTo', [model]) || [];

to = _.union(to, this._createRecipients(originalTo));

return to;
    },

/**
     * Returns the recipients to use in the CC field of the email. These
     * recipients are the same ones who appeared in the original email's CC
     * field.
     *
     * @see EmailClientLaunch plugin.
     * @param {Data.Bean} model Use this model when identifying the recipients.
     * @return {undefined|Array}
     */
    emailOptionCc: function(model) {
        var originalCc = model.get('cc_collection');
        var cc = this._createRecipients(originalCc);

return cc;
    },

/**
     * Returns the template from View.Fields.Base.Emails.ReplyActionField.
     *
     * @inheritdoc
     */
    _getHeaderHtmlTemplate: function() {
        this._tplHeaderHtml = this._tplHeaderHtml ||
            app.template.getField('reply-action', this._tplHeaderHtmlName, 'Emails');

return this._tplHeaderHtml;
    }
}) },
"quickcreate": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Emails.QuickcreateField
 * @alias SUGAR.App.view.fields.BaseEmailsQuickcreateField
 * @extends View.Fields.Base.QuickcreateField
 */
({
	// Quickcreate FieldTemplate (base)

extendsFrom: 'QuickcreateField',

events: {
        'click [data-event]': '_handleEventItemClick',
    },

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['EmailClientLaunch']);
        this._super('initialize', [options]);
    },

bindDataChange: function() {
        this._super('bindDataChange');
        if (this.context && this.context.has('model')) {
            // call updateEmailLinks if the user changes something on the context model
            // so if user changes the email address we make sure we've got the latest
            // email address in the quick Compose Email link
            this.context.get('model').on('change', this.updateEmailLinks, this);
        }

app.routing.before('route', this._beforeRouteChanged, this);
        app.router.on('route', this._routeChanged, this);
    },

/**
     * Trigger sidebar collapse event
     */
    _handleEventItemClick: function() {
        app.events.trigger('sidebar-nav:expand:toggle', false);
    },

/**
     * Before we navigate to a different page, we need to remove the
     * change event listener we added on the context model
     *
     * @protected
     */
    _beforeRouteChanged: function() {
        if (this.context && this.context.has('model')) {
            // route is about to change, need to remove previous
            // listeners before model gets changed
            this.context.get('model').off('change', null, this);
        }
    },

/**
     * After the route has changed, we need to re-add the model listener
     * on the new context model. This also calls updateEmailLinks to blank
     * out any existing email on the current quickcreate link; e.g. re-set the
     * quick Compose Email link back to "mailto:"
     *
     * @protected
     */
    _routeChanged: function() {
        if (this.context && this.context.has('model')) {
            // route has changed, most likely a new model, need to add new listeners
            this.context.get('model').on('change', this.updateEmailLinks, this);
        }
        this.updateEmailLinks();
    },

/**
     * @inheritdoc
     * @private
     */
    _render: function() {
        this.usingInternalEmailClient = this.useSugarEmailClient();
        this._super('_render');
    },

/**
     * Used by EmailClientLaunch as a hook point to retrieve email options that are specific to a view/field
     * In this case we are using it to retrieve the parent model to make this email compose launching
     * context aware - prepopulating the to address with the given model and the parent relate field
     *
     * @return {Object}
     * @private
     */
    _retrieveEmailOptionsFromLink: function() {
        var context = this.context.parent || this.context,
            parentModel = context.get('model'),
            emailOptions = {};

if (parentModel && parentModel.id) {
            // set parent model as option to be passed to compose for To address & relate
            // if parentModel does not have email, it will be ignored as a To recipient
            // if parentModel's module is not an available module to relate, it will also be ignored
            emailOptions = {
                to: [{bean: parentModel}],
                related: parentModel
            };
        }

return emailOptions;
    },

/**
     * @inheritdoc
     */
    _dispose: function() {
        // remove context model change listeners if they exist
        this._beforeRouteChanged();
        app.routing.offBefore('route', this.beforeRouteChanged, this);
        app.router.off('route', this.routeChanged, this);

this._super('_dispose');
    }
}) },
"compose-actionbar": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * Actionbar for the email compose view
 *
 * @class View.Fields.Base.Emails.ComposeActionbarField
 * @alias SUGAR.App.view.fields.BaseEmailsComposeActionbarField
 * @extends View.Fields.Base.FieldsetField
 *
 * @deprecated Use {@link View.Fields.Base.Emails.Htmleditable_tinymceField}
 * instead to add buttons for email composition.
 */
({
	// Compose-actionbar FieldTemplate (base)

extendsFrom: 'FieldsetField',

events: {
        'click a:not(.dropdown-toggle)': 'handleButtonClick'
    },

/**
     * @inheritdoc
     */
    initialize: function(options) {
        app.logger.warn('View.Fields.Base.Emails.SenderField is deprecated. Use ' +
            'View.Fields.Base.Emails.Htmleditable_tinymceField instead.');

this._super('initialize', [options]);
        this.type = 'fieldset';
    },

/**
     * Fire an event when any of the buttons on the actionbar are clicked
     * Events could be set via the data-event attribute or an event is built using the button name
     *
     * @param evt
     */
    handleButtonClick: function(evt) {
        var triggerName, buttonName,
            $currentTarget = $(evt.currentTarget);
        if ($currentTarget.data('event')) {
            triggerName = $currentTarget.data('event');
        } else {
            buttonName = $currentTarget.attr('name') || 'button';
            triggerName = 'actionbar:' + buttonName + ':clicked';
        }
        this.view.context.trigger(triggerName);
    }
}) },
"email-attachments": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Emails.EmailAttachmentsField
 * @alias SUGAR.App.view.fields.BaseEmailsEmailAttachmentsField
 * @extends View.Fields.Base.EmailAttachmentsField
 */
({
	// Email-attachments FieldTemplate (base)

extendsFrom: 'BaseEmailAttachmentsField',

/**
     * @inheritdoc
     *
     * Adds a listener for the `email_attachments:template` event, which is
     * triggered on the view to add attachments. The handler will fetch the
     * attachments from a template, so that they can be copied to the email.
     */
    initialize: function(options) {
        this._super('initialize', [options]);
        this.listenTo(this.view, 'email_attachments:template', this._fetchTemplateAttachments);
    },

/**
     * Retrieves all of an email template's attachments so they can be added to
     * the email.
     *
     * @param {Data.Bean} template The email template whose attachments are to
     * be added.
     * @private
     */
    _fetchTemplateAttachments: function(template) {
        var notes = app.data.createRelatedCollection(template, 'attachments');
        var request;

if (this.disposed === true) {
            return;
        }

request = notes.fetch({
            success: _.bind(this._handleTemplateAttachmentsFetchSuccess, this),
            complete: _.bind(function(request) {
                if (request && request.uid) {
                    delete this._requests[request.uid];
                }
            }, this)
        });

// This request is not associated with a placeholder because
        // placeholders aren't used when handling templates.
        if (request && request.uid) {
            this._requests[request.uid] = request;
        }
    },

/**
     * Handles a successful response from the API for retrieving an email
     * template's attachments.
     *
     * The relevant data is taken from each record and added as an attachment.
     * Before adding the new attachments, all existing attachments that came
     * from another email template are removed.
     *
     * @param {Data.BeanCollection} notes The collection of attachments from
     * the template.
     * @private
     */
    _handleTemplateAttachmentsFetchSuccess: function(notes) {
        var attachments;
        var existingTemplateAttachments;
        var newTemplateAttachments;

if (this.disposed === true) {
            return;
        }

// Remove all existing attachments that came from an email template.
        attachments = this.model.get(this.name);
        existingTemplateAttachments = attachments.where({file_source: 'EmailTemplates'});
        attachments.remove(existingTemplateAttachments);

// Add the attachments from the new email template.
        newTemplateAttachments = notes.map(function(model) {
            return {
                _link: 'attachments',
                upload_id: model.get('upload_id') || model.get('id'),
                name: model.get('filename') || model.get('name'),
                filename: model.get('filename') || model.get('name'),
                file_mime_type: model.get('file_mime_type'),
                file_size: model.get('file_size'),
                file_ext: model.get('file_ext'),
                file_source: 'EmailTemplates'
            };
        });
        attachments.add(newTemplateAttachments, {merge: true});
    }
}) },
"outbound-email": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
 /**
 * @class View.Fields.Base.Emails.OutboundEmailField
 * @alias SUGAR.App.view.fields.BaseEmailsOutboundEmailField
 * @extends View.Fields.Base.EnumField
 */
({
	// Outbound-email FieldTemplate (base)

extendsFrom: 'BaseEnumField',

/**
     * Sets the field type to `enum` so that the `BaseEnumField` templates are
     * loaded. This is necessary when extending a field and using a
     * different name without any custom templates.
     *
     * Adds help text (LBL_OUTBOUND_EMAIL_ID_HELP) for admins.
     *
     * @inheritdoc
     */
    initialize: function(options) {
        if (app.user.get('type') === 'admin') {
            options.def.help = 'LBL_OUTBOUND_EMAIL_ID_HELP';
        }

this._super('initialize', [options]);
        this.type = 'enum';
    },

/**
     * @inheritdoc
     *
     * Only add the help tooltip if the help text is being hidden.
     */
    decorateHelper: function() {
        if (this.def.hideHelp) {
            this._super('decorateHelper');
        }
    },

/**
     * @inheritdoc
     *
     * Dismisses any alerts with the key `email-client-status`.
     */
    _dispose: function() {
        app.alert.dismiss('email-client-status');
        this._super('_dispose');
    },

/**
     * Shows a warning to the user when a not_authorized error is returned.
     *
     * @inheritdoc
     * @fires email_not_configured Triggered on the view to allow the view to
     * decide what should be done beyond warning the user. The error is passed
     * to listeners.
     */
    loadEnumOptions: function(fetch, callback, error) {
        var oError = error;
        const oCallback = _.bind(callback, this);

callback = _.bind(function() {
            if (!this.items || _.isEmpty(this.items)) {

const messageLabel = app.user.get('type') === 'admin' ?
                    'LBL_EMAIL_INVALID_USER_CONFIGURATION' :
                    'LBL_EMAIL_INVALID_SYSTEM_CONFIGURATION';

app.alert.show('email-client-status', {
                    level: 'error',
                    messages: app.lang.get(messageLabel, this.module),
                    autoClose: false,
                    onLinkClick: function() {
                        app.alert.dismiss('email-client-status');
                    }
                });
            }

if (oCallback) {
                oCallback();
            }
        }, this);

error = _.bind(function(e) {
            if (e.code === 'not_authorized') {
                // Mark the error as having been handled so that it doesn't get
                // handled again.
                e.handled = true;
                app.alert.show('email-client-status', {
                    level: 'warning',
                    messages: app.lang.get(e.message, this.module),
                    autoClose: false,
                    onLinkClick: function() {
                        app.alert.dismiss('email-client-status');
                    }
                });
                this.view.trigger('email_not_configured', e);
            }

if (oError) {
                oError(e);
            }
        }, this);

this._super('loadEnumOptions', [fetch, callback, error]);
    }
}) },
"name": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
 /**
 * @class View.Fields.Base.Emails.NameField
 * @alias SUGAR.App.view.fields.BaseEmailsNameField
 * @extends View.Fields.Base.NameField
 */
({
	// Name FieldTemplate (base)

extendsFrom: 'BaseNameField',

/**
     * @inheritdoc
     *
     * Returns "(no subject)" when the email has no subject and not in edit
     * mode. This allows for the subject to be a link in a list view.
     */
    format: function(value) {
        if (_.isEmpty(value) && this.action !== 'edit') {
            return app.lang.get('LBL_NO_SUBJECT', this.module);
        }

return value;
    },

/**
     * Build email record route depending on whether or not the email is a
     * draft and whether the user has the Sugar Email Client option enabled.
     *
     * @return {string}
     */
    buildHref: function() {
        var action = this.def.route && this.def.route.action ? this.def.route.action : null;
        var module = this.model.module || this.context.get('module');

if (this.model.get('state') === 'Draft' &&
            app.acl.hasAccessToModel('edit', this.model) &&
            this._useSugarEmailClient() &&
            !action
        ) {
            action = 'compose';
        }

return '#' + app.router.buildRoute(module, this.model.get('id'), action);
    },

/**
     * Determine if the user is configured to use the Sugar Email Client for
     * editing existing draft emails.
     *
     * @return {boolean}
     * @private
     */
    _useSugarEmailClient: function() {
        var emailClientPreference = app.user.getPreference('email_client_preference');

return (
            emailClientPreference &&
            emailClientPreference.type === 'sugar' &&
            app.acl.hasAccess('edit', 'Emails')
        );
    }
}) },
"reply-action": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * Reply action.
 *
 * This allows a user to "reply" to an existing email.
 *
 * @class View.Fields.Base.Emails.ReplyActionField
 * @alias SUGAR.App.view.fields.EmailsBaseReplyActionField
 * @extends View.Fields.Base.Emails.ForwardActionField
 */
({
	// Reply-action FieldTemplate (base)

extendsFrom: 'EmailsForwardActionField',

/**
     * The name of the template for the reply header.
     *
     * @inheritdoc
     */
    _tplHeaderHtmlName: 'reply-header-html',

/**
     * @inheritdoc
     */
    _subjectPrefix: 'LBL_RE',

/**
     * The element ID to use to identify the reply content.
     *
     * @inheritdoc
     */
    _contentId: 'replycontent',

/**
     * @inheritdoc
     *
     * Updates the reply_to_id email option anytime the model's id attribute
     * changes.
     */
    bindDataChange: function() {
        var context = this.context.parent || this.context;
        var model = context.get('model');

this._super('bindDataChange');

if (model) {
            // Set the reply_to_id email option if the ID already exists.
            this.addEmailOptions({reply_to_id: model.get('id')});

// Update the reply_to_id email option anytime the ID changes. This
            // might occur if the ID was discovered later. It is an edge-case.
            this.listenTo(model, 'change:id', function() {
                this.addEmailOptions({reply_to_id: model.get('id')});
            });
        }
    },

/**
     * Returns the recipients to use in the To field of the email. The sender
     * from the original email is included.
     *
     * @see EmailClientLaunch plugin.
     * @param {Data.Bean} model Use this model when identifying the recipients.
     * @return {undefined|Array}
     */
    emailOptionTo: function(model) {
        var originalTo;
        var originalSender = model.get('from_collection');
        var to = this._createRecipients(originalSender);

if (this.def.reply_all) {
            app.logger.warn('The reply_all option is deprecated. Use View.Fields.Base.Emails.ReplyAllActionField ' +
                'instead.');
            originalTo = model.get('to_collection');
            to = _.union(to, this._createRecipients(originalTo));
        }

return to;
    },

/**
     * Returns the recipients to use in the CC field of the email. The
     * `reply_all` option is deprecated. Use
     * View.Fields.Base.Emails.ReplyAllActionField instead.
     *
     * @see EmailClientLaunch plugin.
     * @param {Data.Bean} model Use this model when identifying the recipients.
     * @return {undefined|Array}
     */
    emailOptionCc: function(model) {
        var originalCc;
        var cc;

if (this.def.reply_all) {
            app.logger.warn('The reply_all option is deprecated. Use View.Fields.Base.Emails.ReplyAllActionField ' +
                'instead.');
            originalCc = model.get('cc_collection');
            cc = this._createRecipients(originalCc);
        }

return cc;
    },

/**
     * Attachments are not carried over to replies.
     *
     * @inheritdoc
     */
    emailOptionAttachments: function(model) {
    },

/**
     * Sets up the email options for the EmailClientLaunch plugin to use -
     * passing to the email compose drawer or building up the mailto link.
     *
     * @protected
     * @deprecated The EmailClientLaunch plugin handles email options.
     */
    _updateEmailOptions: function() {
        app.logger.warn('View.Fields.Base.Emails.ReplyActionField#_updateEmailOptions is deprecated. ' +
            'The EmailClientLaunch plugin handles email options.');
    },

/**
     * Build the reply recipients based on the original email's from, to, and cc
     *
     * @param {boolean} all Whether this is reply to all (true) or just a standard
     *   reply (false).
     * @return {Object} To and Cc values for the reply email.
     * @return {Array} return.to The to values for the reply email.
     * @return {Array} return.cc The cc values for the reply email.
     * @protected
     * @deprecated Use
     * View.Fields.Base.Emails.ReplyActionField#emailOptionTo and
     * View.Fields.Base.Emails.ReplyActionField#emailOptionCc instead.
     */
    _getReplyRecipients: function(all) {
        app.logger.warn('View.Fields.Base.Emails.ReplyActionField#_getReplyRecipients is deprecated. Use ' +
            'View.Fields.Base.Emails.ReplyActionField#emailOptionTo and ' +
            'View.Fields.Base.Emails.ReplyActionField#emailOptionCc instead.');

if (all) {
            app.logger.warn('The reply_all option is deprecated. Use View.Fields.Base.Emails.ReplyAllActionField ' +
                'instead.');
        }

return {
            to: this.emailOptionTo(this.model) || [],
            cc: this.emailOptionCc(this.model) || []
        };
    },

/**
     * Given the original subject, generate a reply subject.
     *
     * @param {string} subject
     * @protected
     * @deprecated Use
     * View.Fields.Base.Emails.ReplyActionField#emailOptionSubject instead.
     */
    _getReplySubject: function(subject) {
        app.logger.warn('View.Fields.Base.Emails.ReplyActionField#_getReplySubject is deprecated. Use ' +
            'View.Fields.Base.Emails.ReplyActionField#emailOptionSubject instead.');

return this.emailOptionSubject(this.model);
    },

/**
     * Get the data required by the header template.
     *
     * @return {Object}
     * @protected
     * @deprecated Use
     * View.Fields.Base.Emails.ReplyActionField#_getHeaderParams instead.
     */
    _getReplyHeaderParams: function() {
        app.logger.warn('View.Fields.Base.Emails.ReplyActionField#_getReplyHeaderParams is deprecated. Use ' +
            'View.Fields.Base.Emails.ReplyActionField#_getHeaderParams instead.');

return this._getHeaderParams(this.model);
    },

/**
     * Build the reply header for text only emails.
     *
     * @param {Object} params
     * @param {string} params.from
     * @param {string} [params.date] Date original email was sent
     * @param {string} params.to
     * @param {string} [params.cc]
     * @param {string} params.name The subject of the original email.
     * @return {string}
     * @private
     * @deprecated Use
     * View.Fields.Base.Emails.ReplyActionField#_getHeader instead.
     */
    _getReplyHeader: function(params) {
        app.logger.warn('View.Fields.Base.Emails.ReplyActionField#_getReplyHeader is deprecated. Use ' +
            'View.Fields.Base.Emails.ReplyActionField#_getHeader instead.');

return this._getHeader(params);
    },

/**
     * Create an array of email recipients from the collection, which can be
     * used as recipients to pass to the new email.
     *
     * @param {Data.BeanCollection} collection
     * @return {Array}
     * @private
     */
    _createRecipients: function(collection) {
        return collection.map(function(recipient) {
            var data = {
                email: app.data.createBean('EmailAddresses', recipient.get('email_addresses'))
            };
            var parent;

if (recipient.hasParent()) {
                parent = recipient.getParent();

if (parent) {
                    data.bean = parent;
                }
            }

return data;
        });
    },

/**
     * Retrieve the plain text version of the reply body.
     *
     * @param {Data.Bean} model The body should come from this model's
     * attributes. EmailClientLaunch plugin should dictate the model based on
     * the context.
     * @return {string} The reply body
     * @private
     */
    _getReplyBody: function(model) {
        // Falls back to the `this.model` for backward compatibility.
        model = model || this.model;

return model.get('description') || '';
    },

/**
     * Retrieve the HTML version of the email body.
     *
     * Ensure the result is a defined string and strip any signature wrapper
     * tags to ensure it doesn't get stripped if we insert a signature above
     * the forward content. Also strip any reply content class if this is a
     * forward to a previous reply. And strip any forward content class if this
     * is a forward to a previous forward.
     *
     * @return {string}
     * @protected
     * @deprecated Use
     * View.Fields.Base.Emails.ReplyActionField#emailOptionDescriptionHtml
     * instead.
     */
    _getReplyBodyHtml: function() {
        app.logger.warn('View.Fields.Base.Emails.ReplyActionField#_getReplyBodyHtml is deprecated. Use ' +
            'View.Fields.Base.Emails.ReplyActionField#emailOptionDescriptionHtml instead.');

return this.emailOptionDescriptionHtml(this.model);
    }
}) },
"recipients": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Emails.RecipientsField
 * @alias SUGAR.App.view.fields.BaseEmailsRecipientsField
 * @extends View.Fields.Base.BaseField
 * @deprecated Use {@link View.Fields.Base.Emails.EmailRecipientsField}
 * instead.
 */
({
	// Recipients FieldTemplate (base)

/**
     * @inheritdoc
     *
     * This field doesn't support `showNoData`.
     */
    showNoData: false,

events: {
        'click .btn': '_showAddressBook'
    },

fieldTag: 'input.select2',

plugins: ['DragdropSelect2'],

/**
     * @inheritdoc
     */
    initialize: function(options) {
        app.logger.warn('View.Fields.Base.Emails.RecipientsField is deprecated. Use ' +
            'View.Fields.Base.Emails.EmailRecipientsField instead.');

this._super('initialize', [options]);
        // initialize the value to an empty collection
        this.model.setDefault(this.name, new Backbone.Collection);
    },

/**
     * Sets up event handlers for syncing between the model and the recipients field.
     *
     * See {@link #format} for the acceptable formats for recipients.
     */
    bindDataChange: function() {
        /**
         * Sets up event handlers that allow external forces to manipulate the contents of the collection, while
         * maintaining the requirement for storing formatted recipients.
         */
        var bindCollectionChange = _.bind(function() {
            var value = this.model.get(this.name);
            if (value instanceof Backbone.Collection) {
                // on "add" we want to force the collection to be reset to guarantee that all models in the collection
                // have been properly formatted for use in this field
                value.on('add', function(models, collection) {
                    // Backbone destroys the models currently in the collection on reset, so we must clone the
                    // collection in order to add the same models again
                    collection.reset(collection.clone().models);
                }, this);
                // on "remove" the requisite models have already been removed, so we only need to bother updating the
                // value in the DOM
                value.on('remove', function(models, collection) {
                    // format the recipients and put them in the DOM
                    this._updateTheDom(this.format(this.model.get(this.name)));
                }, this);
                // on "reset" we want to replace all models in the collection with their formatted versions
                value.on('reset', function(collection) {
                    var recipients = this.format(collection.models);
                    // do this silently so we don't trigger another reset event and end up in an infinite loop
                    collection.reset(recipients, {silent: true});
                    // put the newly formatted recipients in the DOM
                    this._updateTheDom(recipients);
                }, this);
            }
        }, this);

// set up collection event handlers for the initial collection (initialized during this.initialize)
        bindCollectionChange();

// handle the value on the model being changed to something other than the initial collection
        this.model.on('change:' + this.name, function(model, recipients) {
            var value = this.model.get(this.name);
            if (!(value instanceof Backbone.Collection)) {
                // whoa! someone changed the value to be something other than a collection
                // stick that new value inside a collection and reset the value, so we're always dealing with a
                // collection... another change event will be triggered, so we'll end up in the else block right after
                // this
                this.model.set(this.name, new Backbone.Collection(value));
            } else {
                // phew! the value is a collection
                // but it's not the initial collection, so we'll have to set up collection event handlers for this
                // instance
                bindCollectionChange();
                // you never know what data someone sticks on the field, so we better reset the values in the collection
                // so that the recipients become formatted as we expect
                value.reset(recipients.clone().models);
            }
        }, this);
    },

/**
     * Sets the value of the Select2 element, decorates any invalid recipients,
     * and rebuilds the tooltips for all recipients.
     *
     * @param {Array} recipients the return value for {@link #format}.
     */
    _updateTheDom: function(recipients) {
        // put the formatted recipients in the DOM
        this.getFieldElement().select2('data', recipients);
        this._decorateInvalidRecipients();
        if (!this.def.readonly) {
            this.setDragDropPluginEvents(this.getFieldElement());
        }
    },

/**
     * Remove events from the field value if it is a collection
     */
    unbindData: function() {
        var value = this.model.get(this.name);
        if (value instanceof Backbone.Collection) {
            value.off(null, null, this);
        }

this._super('unbindData');
    },

/**
     * Render field with select2 widget
     *
     * @private
     */
    _render: function() {
        var $controlsEl;
        var $recipientsField;

if (this.$el) {
            $controlsEl = this.$el.closest('.controls');
            if ($controlsEl.length) {
                $controlsEl.addClass('controls-one btn-fit');
            }
        }
        this._super('_render');

$recipientsField = this.getFieldElement();

if ($recipientsField.length > 0) {
            $recipientsField.select2({
                allowClear: true,
                multiple: true,
                width: 'off',
                containerCssClass: 'select2-choices-pills-close',
                containerCss: {'width': '100%'},
                minimumInputLength: 1,
                query: _.bind(function(query) {
                    this.loadOptions(query);
                }, this),
                createSearchChoice: _.bind(this.createOption, this),
                formatSelection: _.bind(this.formatSelection, this),
                formatResult: _.bind(this.formatResult, this),
                formatSearching: _.bind(this.formatSearching, this),
                formatInputTooShort: _.bind(this.formatInputTooShort, this),
                selectOnBlur: true
            });

if (!!this.def.disabled) {
                $recipientsField.select2('disable');
            }

if (!this.def.readonly) {
                this.setDragDropPluginEvents(this.getFieldElement());
            }
        }
    },

/**
     * Fetches additional recipients from the server.
     *
     * See [Select2 Documentation of `query` parameter](http://ivaynberg.github.io/select2/#doc-query).
     *
     * @param {Object} query Possible attributes can be found in select2's
     *   documentation.
     */
    loadOptions: _.debounce(function(query) {
        var self = this,
            data = {
                results: [],
                // only show one page of results
                // if more results are needed, then the address book should be used
                more: false
            },
            options = {},
            callbacks = {},
            url;

// add the search term to the URL params
        options.q = query.term;
        // the first 10 results should be enough
        // if more results are needed, then the address book should be used
        options.max_num = 10;
        // build the URL for fetching recipients that match the search term
        url = app.api.buildURL('Mail', 'recipients/find', null, options);
        // create the callbacks
        callbacks.success = function(result) {
            // the api returns objects formatted such that sidecar can convert them to beans
            // we need the records to be in a standard object format (@see RecipientsField::format) and the records
            // need to be converted into beans before we can format them
            var records = app.data.createMixedBeanCollection(result.records);
            // format and add the recipients that were found via the select2 callback
            data.results = self.format(records);
        };
        callbacks.error = function() {
            // don't add any recipients via the select2 callback
            data.results = [];
        };
        callbacks.complete = function() {
            // execute the select2 callback to add any new recipients
            query.callback(data);
        };
        app.api.call('read', url, null, callbacks);
    }, 300),

/**
     * Create additional select2 options when loadOptions returns no matches for the search term.
     *
     * See [Select2 Documentation](http://ivaynberg.github.io/select2/#documentation).
     *
     * @param {String} term
     * @param {Array} data The options in the select2 drop-down after the query callback has been executed.
     * @return {Object}
     */
    createOption: function(term, data) {
        if (data.length === 0) {
            return {id: term, email: term};
        }
    },

/**
     * Formats a recipient object for displaying selected recipients.
     *
     * See [Select2 Documentation](http://ivaynberg.github.io/select2/#documentation).
     *
     * @param {Object} recipient
     * @return {String}
     */
    formatSelection: function(recipient) {
        var value = recipient.name || recipient.email,
            template = app.template.getField(this.type, 'select2-selection', this.module);
        if (template) {
            return template({
                id: recipient.id,
                name: value,
                email: recipient.email,
                invalid: recipient._invalid
            });
        }
        return value;
    },

/**
     * Formats a recipient object for displaying items in the recipient options list.
     *
     * See [Select2 Documentation](http://ivaynberg.github.io/select2/#documentation).
     *
     * @param {Object} recipient
     * @return {String}
     */
    formatResult: function(recipient) {
        var format,
            email = Handlebars.Utils.escapeExpression(recipient.email);

if (recipient.name) {
            format = '"' + Handlebars.Utils.escapeExpression(recipient.name) + '" &lt;' + email + '&gt;';
        } else {
            format = email;
        }

return format;
    },

/**
     * Returns the localized message indicating that a search is in progress
     *
     * See [Select2 Documentation](http://ivaynberg.github.io/select2/#documentation).
     *
     * @return {string}
     */
    formatSearching: function() {
        return app.lang.get('LBL_LOADING', this.module);
    },

/**
     * Suppresses the message indicating the number of characters remaining before a search will trigger
     *
     * See [Select2 Documentation](http://ivaynberg.github.io/select2/#documentation).
     *
     * @param {string} term Search string entered by user.
     * @param {number} min Minimum required term length.
     * @return {string}
     */
    formatInputTooShort: function(term, min) {
        return '';
    },

/**
     * Formats a set of recipients into an array of objects that select2 understands.
     *
     * See {@link #_formatRecipient} for the acceptable/expected attributes to
     * be found on each recipient.
     *
     * @param {Mixed} data A Backbone collection, a single Backbone model or standard JavaScript object, or an array of
     *   Backbone models or standard JavaScript objects.
     * @return {Array}
     */
    format: function(data) {
        var formattedRecipients = [];
        // the lowest common denominator of potential inputs is an array of objects
        // force the parameter to be an array of either objects or Backbone models so that we're always dealing with
        // one data-structure type
        if (data instanceof Backbone.Collection) {
            // get the raw array of models
            data = data.models;
        } else if (data instanceof Backbone.Model || (_.isObject(data) && !_.isArray(data))) {
            // wrap the single model in an array so the code below behaves the same whether it's a model or a collection
            data = [data];
        }
        if (_.isArray(data)) {
            _.each(data, function(recipient) {
                var formattedRecipient;
                if (!(recipient instanceof Backbone.Model)) {
                    // force the object to be a Backbone.Model to allow for certain assumptions to be made
                    // there is no harm in this because the recipient will not be added to the return value if no email
                    // address is found on the model
                    recipient = new Backbone.Model(recipient);
                }
                formattedRecipient = this._formatRecipient(recipient);
                // only add the recipient if there is an email address
                if (!_.isEmpty(formattedRecipient.email)) {
                    formattedRecipients.push(formattedRecipient);
                }
            }, this);
        }
        return formattedRecipients;
    },

/**
     * Determine whether or not the recipient pills should be locked.
     * @return {boolean}
     */
    recipientsLocked: function() {
        return this.def.readonly || false;
    },

/**
     * Synchronize the recipient field value with the model and setup tooltips for email pills.
     */
    bindDomChange: function() {
        var self = this;
        this.getFieldElement()
            .on('change', function(event) {
                var value = $(this).select2('data');
                if (event.removed) {
                    value = _.filter(value, function(d) {
                        return d.id !== event.removed.id;
                    });
                }
                self.model.get(self.name).reset(value);
            })
            .on('select2-selecting', _.bind(this._handleEventOnSelected, this));
    },

/**
     * Event handler for the Select2 "select2-selecting" event.
     *
     * @param {Event} event
     * @return {boolean}
     * @private
     */
    _handleEventOnSelected: function(event) {
        // only allow the user to select an option if it is determined to be a valid email address
        // returning true will select the option; false will prevent the option from being selected
        var isValidChoice = false;

// since this event is fired twice, we only want to perform validation on the first event
        // event.object is not available on the second event
        if (event.object) {
            // the id and email address will not match when the email address came from the database and
            // we are assuming that email addresses stored in the database have already been validated
            if (event.object.id == event.object.email) {
                // this option must be a new email address that the application does not recognize
                // so mark it as valid and kick off an async validation
                isValidChoice = true;
                this._validateEmailAddress(event.object);
            } else {
                // the application should recognize the email address, so no need to validate it again
                // just assume it's a valid choice and we'll deal with the consequences later (server-side)
                isValidChoice = true;
            }
        }

return isValidChoice;
    },

/**
     * Destroy all select2 and tooltip plugins
     */
    unbindDom: function() {
        this.getFieldElement().select2('destroy');
        this._super('unbindDom');
    },

/**
     * When in edit mode, the field includes an icon button for opening an address book. Clicking the button will
     * trigger an event to open the address book, which calls this method to do the dirty work. The selected recipients
     * are added to this field upon closing the address book.
     *
     * @private
     */
    _showAddressBook: function() {
        /**
         * Callback to add recipients, from a closing drawer, to the target Recipients field.
         * @param {undefined|Backbone.Collection} recipients
         */
        var addRecipients = _.bind(function(recipients) {
            if (recipients && recipients.length > 0) {
                this.model.get(this.name).add(recipients.models);
            }
        }, this);
        app.drawer.open(
            {
                layout: 'compose-addressbook',
                context: {
                    module: 'Emails',
                    mixed: true
                }
            },
            function(recipients) {
                addRecipients(recipients);
            }
        );
    },

/**
     * update ul.select2-choices data attribute which prevents underrun of pills by
     * using a css definition for :before {content:''} set to float right
     *
     * @param {string} content
     */
    setContentBefore: function(content) {
        this.$('.select2-choices').attr('data-content-before', content);
    },

/**
     * Gets the recipients DOM field
     *
     * @return {Object} DOM Element
     */
    getFieldElement: function() {
        return this.$(this.fieldTag);
    },

/**
     * Format a recipient from a Backbone.Model to a standard JavaScript object with id, module, email, and name
     * attributes. Only id and email are required for the recipient to be considered valid
     * {@link #format}.
     *
     * All attributes are optional. However, if the email attribute is not present, then a primary email address should
     * exist on the bean. Without an email address that can be resolved, the recipient is considered to be invalid. The
     * bean attribute must be a Backbone.Model and it is likely to be a Bean. Data found in the bean is considered to be
     * secondary to the attributes found on its parent model. The bean is a mechanism for collecting additional
     * information about the recipient that may not have been explicitly set when the recipient was passed in.
     * @param {Backbone.Model} recipient
     * @return {Object}
     * @private
     */
    _formatRecipient: function(recipient) {
        var formattedRecipient = {};
        if (recipient instanceof Backbone.Model) {
            var bean = recipient.get('bean');
            // if there is a bean attribute, then more data can be extracted about the recipient to fill in any holes if
            // attributes are missing amongst the primary attributes
            // so follow the trail using recursion
            if (bean) {
                formattedRecipient = this._formatRecipient(bean);
            }
            // prioritize any values found on recipient over those already extracted from bean
            formattedRecipient = {
                id: recipient.get('id') || formattedRecipient.id || recipient.get('email'),
                module: recipient.get('module') || recipient.module || recipient.get('_module') || formattedRecipient.module,
                email: recipient.get('email') || formattedRecipient.email,
                locked: this.recipientsLocked(),
                name: recipient.get('name') || recipient.get('full_name') || formattedRecipient.name,
                _invalid: recipient.get('_invalid')
            };
            // don't bother with the recipient unless an id is present
            if (!_.isEmpty(formattedRecipient.id)) {
                // extract the primary email address for the recipient
                if (_.isArray(formattedRecipient.email)) {
                    var primaryEmailAddress = _.findWhere(formattedRecipient.email, {primary_address: true});

if (!_.isUndefined(primaryEmailAddress) && !_.isEmpty(primaryEmailAddress.email_address)) {
                        formattedRecipient.email = primaryEmailAddress.email_address;
                    }
                }
                // drop any values that are empty or non-compliant
                _.each(formattedRecipient, function(val, key) {
                    if ((_.isEmpty(formattedRecipient[key]) || !_.isString(formattedRecipient[key])) && !_.isBoolean(formattedRecipient[key])) {
                        delete formattedRecipient[key];
                    }
                });
            } else {
                // drop all values if an id isn't present
                formattedRecipient = {};
            }
        }
        return formattedRecipient;
    },

/**
     * Validates an email address on the server asynchronously.
     *
     * Marks the recipient as invalid if it is not a valid email address.
     *
     * @param {Object} recipient
     * @param {string} recipient.id
     * @param {string} recipient.email
     * @private
     */
    _validateEmailAddress: function(recipient) {
        var callbacks = {};
        var url = app.api.buildURL('Mail', 'address/validate');

callbacks.success = _.bind(function(result) {
            if (!result[recipient.email] && !this.disposed) {
                this._markRecipientInvalid(recipient.id);
            }
        }, this);
        callbacks.error = _.bind(function() {
            if (!this.disposed) {
                this._markRecipientInvalid(recipient.id);
            }
        }, this);

app.api.call('create', url, [recipient.email], callbacks);
    },

/**
     * Mark the given recipient as invalid in the collection and update select2.
     *
     * @param {string} recipientId
     * @private
     */
    _markRecipientInvalid: function(recipientId) {
        var recipients = this.model.get(this.name);
        var recipient = recipients.get(recipientId);
        recipient.set('_invalid', true);
        this._updateTheDom(this.format(recipients));
    },

/**
     * Decorate any invalid recipients in this field.
     * @private
     */
    _decorateInvalidRecipients: function() {
        var self = this;
        var $invalidRecipients = this.$('.select2-search-choice [data-invalid="true"]');
        $invalidRecipients.each(function() {
            var $choice = $(this).closest('.select2-search-choice');
            $choice.addClass('select2-choice-danger');
            $(this).attr('data-title', app.lang.get('ERR_INVALID_EMAIL_ADDRESS', self.module));
        });
    }
}) },
"htmleditable_tinymce": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Emails.Htmleditable_tinymceField
 * @alias SUGAR.App.view.fields.BaseEmailsHtmleditable_tinymceField
 * @extends View.Fields.Base.Htmleditable_tinymceField
 */
({
	// Htmleditable_tinymce FieldTemplate (base)

extendsFrom: 'Htmleditable_tinymceField',

/**
     * Force the field to display the correct view even if there is no data to
     * show.
     *
     * @property {boolean}
     */
    showNoData: false,

/**
     * Constant for inserting content above the existing email body.
     *
     * @property {string}
     */
    ABOVE_CONTENT: 'above',

/**
     * Constant for inserting content below the existing email body.
     *
     * @property {string}
     */
    BELOW_CONTENT: 'below',

/**
     * Constant for inserting content into the email body at the current cursor
     * location.
     *
     * @property {string}
     */
    CURSOR_LOCATION: 'cursor',

/**
     * The tinyMCE button API object for the signature dropdown.
     *
     * @private
     * @property {Object|null}
     */
    _signatureBtnApi: null,

/**
     * List of menu items for fetched signatures
     *
     * @private
     * @property {Array}
     */
    _signatureSubmenu: [],

/**
     * The number of signatures found from the API response.
     *
     * @private
     * @property {number}
     */
    _numSignatures: 0,

/**
     * Track the editor focus/blur state.
     *
     * @private
     * @property {boolean}
     */
    _editorFocused: false,

/**
     * @inheritdoc
     *
     * Stores the user's default signature on the context using the attribute
     * name `current_signature`. This attribute is updated anytime a new
     * signature is selected.
     *
     * Stores the initial signature location for inserting the default
     * signature. If the context already has `signature_location` attribute,
     * then that value is used. Otherwise, this attribute is defaulted to
     * insert the signature below any content. This attribute is updated
     * anytime a signature is inserted in a different location.
     *
     * The default signature is inserted in the initial location if the email
     * is new. The signature is not inserted if the email is an existing draft
     * that is being edited. If the initial location is the cursor, then the
     * signature is inserted after the editor is fully loaded and the cursor
     * has been placed.
     *
     * For new replies, the cursor is placed above the reply content, once the
     * editor has been loaded.
     */
    initialize: function(options) {
        var signature;
        var location;
        // We insert an empty <p> node in the tinyMCE editor and use that to
        // focus the cursor to the bottom of the tinyMCE editor. This is
        // because if the last element in the editor has content
        // (i.e. <p>Sincercely, John Doe</p>) and we select that element, the
        // cursor would be placed at the beginning of the content
        // (in the example, the cursor would be before the "S" in Sincerely).
        var emptyNode;

this._super('initialize', [options]);

// Get the default signature and store it on the context.
        signature = app.user.getPreference('signature_default');

if (!(signature instanceof app.Bean)) {
            signature = app.data.createBean('UserSignatures', signature);
        }

this.context.set('current_signature', signature);

// Determine the initial signature location for inserting the default.
        location = this.context.get('signature_location');

if (_.isEmpty(location)) {
            // Default the location.
            location = this.BELOW_CONTENT;
            this.context.set('signature_location', location);
        }

// Don't do the following if updating an existing draft.
        if (this.model.isNew()) {
            // Insert the default signature.
            if (location === this.CURSOR_LOCATION) {
                // Need to wait for the editor before inserting.
                this.listenToOnce(this.context, 'tinymce:oninit', function() {
                    this._insertSignature(signature, location);
                });
            } else {
                this._insertSignature(signature, location);
            }

// Focus the editor and place the cursor at the desired location.
            if (!_.isEmpty(this.context.get('cursor_location'))) {
                this.listenToOnce(this.context, 'tinymce:oninit', function() {
                    if (this._htmleditor) {
                        this._htmleditor.focus();

// Move the cursor to the bottom of the editor by
                        // inserting an empty node and selecting it.
                        if (this.context.get('cursor_location') == this.BELOW_CONTENT) {
                            emptyNode = this._insertNodeInEditor();

if (emptyNode) {
                                this._htmleditor.selection.setCursorLocation(emptyNode);
                                this._htmleditor.selection.collapse(true);
                            }
                        }
                    }
                });
            }
        }
    },

/**
     * Suppress calling the sidecar _render method in detail view
     *
     * @inheritdoc
     */
    _render: function() {
        if (this._isEditView()) {
            this._super('_render');
            this.$el.toggleClass('detail', false).toggleClass('edit', true);
        } else {
            this.destroyTinyMCEEditor();

// Hide the field for now. Once the field loads its contents completely, we will show it. This helps
            // to prevent a momentary white background/flash in the iframe before it finishes loading in dark mode
            this.hide();

this._renderView();
            this.$el.toggleClass('detail', true).toggleClass('edit', false);
        }
        return this;
    },

/**
     * Replicate the sidecar render logic for detail view except for
     * manually appending an iframe instead of invoking the template
     *
     * @inheritdoc
     */
    _renderView: function() {
        var self = this;
        var iFrame;

// sets this.tplName and this.action
        this._loadTemplate();

if (this.model instanceof Backbone.Model) {
            this.value = this.getFormattedValue();
        }

this.dir = _.result(this, 'direction');

if (app.lang.direction === this.dir) {
            delete this.dir;
        }

this.unbindDom();

// begin custom rendering
        if (this.$el.find('iframe').length === 0) {
            iFrame = $('<iframe>', {
                src: '',
                class: 'htmleditable w-full' + (this.def.span ? ' span' + this.def.span : ''),
                frameborder: 0,
                name: this.name
            });
            // Perform it on load for Firefox.
            iFrame.appendTo(this.$el).on('load', function() {
                self._setIframeBaseTarget(iFrame, '_blank');
            });
            this._setIframeBaseTarget(iFrame, '_blank');
        }

this.setViewContent(this.value);
        // end custom rendering

if (this.def && this.def.css_class) {
            this.getFieldElement().addClass(this.def.css_class);
        }

this.$(this.fieldTag).attr('dir', this.dir);
        this.bindDomChange();
    },

/**
     * @inheritdoc
     *
     * Resize the field's container based on the height of the iframe content
     * for preview.
     */
    _setViewContentInternal: function(editable, value, styleSrc = 'styleguide/assets/css/iframe-sugar.css') {
        this._super('_setViewContentInternal', [editable, value, styleSrc]);
        // Only set this field height if it is in the preview or detail pane
        if (!_.contains(['preview', 'detail'], this.tplName)) {
            return;
        }
        if (!this._iframeHasBody(editable)) {
            return;
        }
        var iframeWaitingTime = 50;
        _.debounce(_.bind(function() {
            if (this.disposed) {
                return;
            }
            // Pad this to the final height due to the iframe margins/padding
            var padding = (this.tplName === 'detail' || this.tplName === 'preview') ? 0 : 25;
            var contentHeight = 0;
            contentHeight = this._getContentHeight() + padding;
            // Only resize the editor when the content is fully loaded
            if (contentHeight > padding) {
                // Set the maximum height to 400px
                if (contentHeight > 400) {
                    contentHeight = 400;
                }
                editable.css('height', contentHeight);
                if (this.view) {
                    this.view.trigger('tinymce:resize');
                }
            }
        }, this), iframeWaitingTime)();
    },

/**
     * Set iframe base target value
     *
     * @param {jQuery} iFrame The iframe element that the target will be added to.
     * @param {string} targetValue e.g. _self, _blank, _parent, _top or frameName
     * @private
     */
    _setIframeBaseTarget: function(iFrame, targetValue) {
        var target = $('<base>', {
            target: targetValue
        });

target.appendTo(iFrame.contents().find('head'));
    },

/**
     * @inheritdoc
     *
     * Adds buttons for uploading a local file and selecting a Sugar Document
     * to attach to the email.
     *
     * Adds a button for selecting and inserting a signature at the cursor.
     *
     * Adds a button for selecting and applying a template.
     *
     * @fires email_attachments:file on the view when the user elects to attach
     * a local file.
     */
    addCustomButtons: function(editor) {
        var attachmentButtons = [];

// Attachments can only be added if the user has permission to create
        // Notes records. Only add the attachment button(s) if the user is
        // allowed.
        if (app.acl.hasAccess('create', 'Notes')) {
            attachmentButtons.push({
                text: app.lang.get('LBL_ATTACH_FROM_LOCAL', this.module),
                type: 'menuitem',
                onAction: (event) => {
                    // Track click on the file attachment button.
                    app.analytics.trackEvent('click', 'tinymce_email_attachment_file_button', event);
                    this.view.trigger('email_attachments:file');
                },
            });

// The user can only select a document to attach if he/she has
            // permission to view Documents records in the selection list.
            // Don't add the Documents button if the user can't view and select
            // documents.
            if (app.acl.hasAccess('view', 'Documents')) {
                attachmentButtons.push({
                    text: app.lang.get('LBL_ATTACH_SUGAR_DOC', this.module),
                    type: 'menuitem',
                    onAction: (event) => {
                        // Track click on the document attachment button.
                        app.analytics.trackEvent('click', 'tinymce_email_attachment_doc_button', event);
                        this._selectDocument();
                    },
                });
            }

editor.ui.registry.addMenuButton('sugarattachment', {
                tooltip: app.lang.get('LBL_ATTACHMENT', this.module),
                icon: 'plus',
                onAction: (event) => {
                    // Track click on the attachment button.
                    app.analytics.trackEvent('click', 'tinymce_email_attachment_button', event);
                },
                fetch: (callback) => {
                    callback(attachmentButtons);
                },
            });
        }

editor.ui.registry.addMenuButton('sugarsignature', {
            tooltip: app.lang.get('LBL_SIGNATURE', this.module),
            icon: 'edit-block',
            // disable the signature button until they have been loaded
            onSetup: (btnApi) => {
                btnApi.setEnabled(false);
                this._signatureBtnApi = btnApi;
                // load the users signatures
                this._getSignatures();
            },
            onAction: (event) => {
                // Track click on the signature button.
                app.analytics.trackEvent('click', 'tinymce_email_signature_button', event);
            },
            fetch: (callback) => {
                callback(this._signatureSubmenu);
            },
        });

if (app.acl.hasAccess('view', 'EmailTemplates')) {
            editor.ui.registry.addButton('sugartemplate', {
                tooltip: app.lang.get('LBL_TEMPLATE', this.module),
                icon: 'document-properties',
                onAction: (event) => {
                    // Track click on the template button.
                    app.analytics.trackEvent('click', 'tinymce_email_template_button', event);
                    this._selectEmailTemplate();
                },
            });
        }

// Enable the signature button when the editor is focused and the user
        // has signatures that can be inserted.
        editor.on('focus', _.bind(function(e) {
            this._editorFocused = true;
            this.view.trigger('tinymce:focus');
            // the user has at least 1 signature
            if (this._numSignatures > 0) {
                // enable the signature button
                this._signatureBtnApi.setEnabled(true);
            }
        }, this));

// Disable the signature button when the editor is blurred and the user
        // has signatures. Signatures are inserted at the cursor location. If
        // the button is not disabled when the editor is unfocused, then issues
        // would arise with the user clicking a signature to insert at the
        // cursor without a cursor being present.
        editor.on('blur', _.bind(function(e) {
            this._editorFocused = false;
            this.view.trigger('tinymce:blur');
            // the user has at least 1 signature
            if (this._numSignatures > 0) {
                // disable the signature button
                this._signatureBtnApi.setEnabled(false);
            }
        }, this));
    },

/**
     * Inserts the content into the TinyMCE editor at the specified location.
     *
     * @private
     * @param {string} content
     * @param {string} [location="cursor"] Whether to insert the new content
     *   above existing content, below existing content, or at the cursor
     *   location. Defaults to being inserted at the cursor position.
     * @return {string} The updated content.
     */
    _insertInEditor: function(content, location) {
        var emailBody = this.model.get(this.name) || '';

if (_.isEmpty(content)) {
            return emailBody;
        }

// Default to the cursor location.
        location = location || this.CURSOR_LOCATION;

// Add empty divs so user can place the cursor on the line before or
        // after.
        content = '<div></div>' + content + '<div></div>';

if (location === this.CURSOR_LOCATION) {
            if (_.isNull(this._htmleditor)) {
                // Unable to insert content at the cursor without an editor.
                return emailBody;
            }

this._htmleditor.insertContent(content);

// Get the HTML content from the editor.
            emailBody = this._htmleditor.getContent();
        } else if (location === this.BELOW_CONTENT) {
            emailBody += content;
        } else if (location === this.ABOVE_CONTENT) {
            emailBody = content + emailBody;
        }

// Update the model with the new content.
        this.model.set(this.name, emailBody);

return emailBody;
    },

/**
     * Inserts a unique element into the TinyMCE editor to the end of the
     * <body>.
     *
     * @private
     * @return {HTMLElement|boolean} The inserted element or false if an
     * element can't be inserted.
     */
    _insertNodeInEditor: function() {
        var body;
        var uniqueId;

if (this._htmleditor) {
            body = this._htmleditor.getBody();
            uniqueId = this._htmleditor.dom.uniqueId();
            $('<p id="' + uniqueId + '"><br /></p>').appendTo(body);

return this._htmleditor.dom.select('p#' + uniqueId)[0];
        }

// There is no editor to insert the element into.
        return false;
    },

/**
     * Fetches the signatures for the current user.
     *
     * @private
     */
    _getSignatures: function() {
        var signatures = app.data.createBeanCollection('UserSignatures');

signatures.filterDef = [{
            user_id: {$equals: app.user.get('id')}
        }];
        signatures.fetch({
            max_num: -1, // Get as many as we can.
            success: _.bind(this._getSignaturesSuccess, this),
            error: function() {
                app.alert.show('server-error', {
                    level: 'error',
                    messages: 'ERR_GENERIC_SERVER_ERROR'
                });
            }
        });
    },

/**
     * Add each signature as buttons under the signature button.
     *
     * @private
     * @param {Data.BeanCollection} signatures
     */
    _getSignaturesSuccess: function(signatures) {
        this._signatureSubmenu = [];

if (this.disposed === true) {
            return;
        }

if (!_.isUndefined(signatures) && !_.isUndefined(signatures.models)) {
            signatures = signatures.models;
        } else {
            app.alert.show('server-error', {
                level: 'error',
                messages: 'ERR_GENERIC_SERVER_ERROR'
            });

return;
        }

if (!_.isNull(this._signatureBtnApi)) {
            // write the signature names to the control dropdown
            _.each(signatures, _.bind(function(signature) {
                this._signatureSubmenu.push({
                    text: signature.get('name'),
                    type: 'menuitem',
                    onAction: (event) => {
                        // Track click on a signature.
                        app.analytics.trackEvent('click', 'email_signature', event);
                        this._insertSignature(signature, this.CURSOR_LOCATION);
                    },
                });
            }, this));

// Set the number of signatures the user has
            this._numSignatures = signatures.length;

// If the editor is focused before the signatures are returned, enable the signature button
            if (this._editorFocused) {
                this._signatureBtnApi.setEnabled(true);
            }
        }
    },

/**
     * Inserts the signature into the editor.
     *
     * @private
     * @param {Data.Bean} signature
     * @param {string} [location="cursor"] Whether to insert the new content
     * above existing content, below existing content, or at the cursor
     * location. Defaults to being inserted at the cursor position.
     */
    _insertSignature: function(signature, location) {
        var htmlBodyObj;
        var emailBody;
        var signatureHtml;
        var decodedSignature;
        var signatureContent;

function decodeBrackets(str) {
            str = str.replace(/&lt;/gi, '<');
            str = str.replace(/&gt;/gi, '>');

return str;
        }

if (this.disposed === true) {
            return;
        }

if (!(signature instanceof app.Bean)) {
            return;
        }

signatureHtml = signature.get('signature_html');

if (_.isEmpty(signatureHtml)) {
            return;
        }

decodedSignature = decodeBrackets(signatureHtml);
        signatureContent = '<div class="signature keep">' + decodedSignature + '</div>';

emailBody = this._insertInEditor(signatureContent, location);
        htmlBodyObj = $('<div>' + this.sanitizeContent(emailBody) + '</div>');

// Mark each signature to either keep or remove.
        $('div.signature', htmlBodyObj).each(function() {
            if (!$(this).hasClass('keep')) {
                // Mark for removal.
                $(this).addClass('remove');
            } else {
                // If the parent is also a signature, move the node out of the
                // parent so it isn't removed.
                if ($(this).parent().hasClass('signature')) {
                    // Move the signature outside of the nested signature.
                    $(this).parent().before(this);
                }

// Remove the "keep" class so if another signature is added it
                // will remove this one.
                $(this).removeClass('keep');
            }
        });

// After each signature is marked, perform the removal.
        htmlBodyObj.find('div.signature.remove').remove();

emailBody = htmlBodyObj.html();
        this.model.set(this.name, emailBody);

this.context.set('current_signature', signature);
        this.context.set('signature_location', location || this.CURSOR_LOCATION);
    },

/**
     * Allows the user to select a template to apply.
     *
     * @private
     */
    _selectEmailTemplate: function() {
        var def = {
            layout: 'selection-list',
            context: {
                module: 'EmailTemplates',
                fields: [
                    'subject',
                    'body',
                    'body_html',
                    'text_only'
                ]
            }
        };

app.drawer.open(def, _.bind(this._onEmailTemplateDrawerClose, this));
    },

/**
     * Verifies that the user has access to the email template before applying
     * it.
     *
     * @private
     * @param {Data.Bean} model
     */
    _onEmailTemplateDrawerClose: function(model) {
        var emailTemplate;

if (this.disposed === true) {
            return;
        }

// This is an edge case where user has List but not View permission.
        // Search & Select will return only id and name if View permission is
        // not permitted for this record. Display appropriate error.
        if (model && _.isUndefined(model.subject)) {
            app.alert.show('no_access_error', {
                level: 'error',
                messages: app.lang.get('ERR_NO_ACCESS', this.module, {name: model.value})
            });
        } else if (model) {
            // `value` is not a real attribute.
            emailTemplate = app.data.createBean('EmailTemplates', _.omit(model, 'value'));
            this._confirmTemplate(emailTemplate);
        }
    },

/**
     * Confirms that the user wishes to replace all content in the editor. The
     * template is applied if there is no existing content or if the user
     * confirms "yes".
     *
     * @private
     * @param {Data.Bean} template
     */
    _confirmTemplate: function(template) {
        var subject = this.model.get('name') || '';
        var text = this.model.get('description') || '';
        var html = this.model.get(this.name) || '';
        var fullContent = subject + text + html;

if (_.isEmpty(fullContent)) {
            this._applyTemplate(template);
        } else {
            app.alert.show('delete_confirmation', {
                level: 'confirmation',
                messages: app.lang.get('LBL_EMAILTEMPLATE_MESSAGE_SHOW_MSG', this.module),
                onConfirm: _.bind(function(event) {
                    // Track click on confirmation button.
                    app.analytics.trackEvent('click', 'email_template_confirm', event);
                    this._applyTemplate(template);
                }, this),
                onCancel: function(event) {
                    // Track click on cancel button.
                    app.analytics.trackEvent('click', 'email_template_cancel', event);
                }
            });
        }
    },

/**
     * Inserts the template into the editor.
     *
     * The template's subject does not overwrite the existing subject if:
     *
     * 1. The email is a forward or reply.
     * 2. The template does not have a subject.
     *
     * @private
     * @fires email_attachments:template on the view with the selected template
     * as a parameter. {@link View.Fields.Base.Emails.EmailAttachmentsField}
     * adds the template's attachments to the email.
     * @param {Data.Bean} template
     */
    _applyTemplate: function(template) {
        var body;
        var replyContent;
        var forwardContent;
        var subject;
        var signature = this.context.get('current_signature');

/**
         * Check the email body and pull out any forward/reply content from a
         * draft email.
         *
         * @param {string} body The full content to search.
         * @return {string} The forward/reply content.
         */
        function getForwardReplyContent(body, id) {
            var content = '';
            var $content;

if (body) {
                $content = $('<div>' + body + '</div>').find('div#' + id);

if ($content.length > 0) {
                    content = $content[0].outerHTML;
                }
            }

return content;
        }

if (this.disposed === true) {
            return;
        }

// Track applying an email template.
        app.analytics.trackEvent('email_template', 'apply', template);

replyContent = getForwardReplyContent(this.model.get(this.name), 'replycontent');
        forwardContent = getForwardReplyContent(this.model.get(this.name), 'forwardcontent');
        subject = template.get('subject');

// Only use the subject if it's not a forward or reply.
        if (subject && !(replyContent || forwardContent)) {
            this.model.set('name', subject);
        }

//TODO: May need to move over replaces special characters.
        body = template.get('text_only') ? template.get('body') : template.get('body_html');
        this.model.set(this.name, body);

this.view.trigger('email_attachments:template', template);

// The HTML signature is used even when the template is text-only.
        if (signature) {
            this._insertSignature(signature, this.BELOW_CONTENT);
        }

// Append the reply content to the end of the email.
        if (replyContent) {
            this._insertInEditor(replyContent, this.BELOW_CONTENT);
        }

// Append the forward content to the end of the email.
        if (forwardContent) {
            this._insertInEditor(forwardContent, this.BELOW_CONTENT);
        }
    },

/**
     * Allows the user to select a document to attach.
     *
     * @private
     * @fires email_attachments:document on the view with the selected document
     * as a parameter. {@link View.Fields.Base.EmailAttachmentsField} attaches
     * the document to the email.
     */
    _selectDocument: function() {
        var def = {
            layout: 'selection-list',
            context: {
                module: 'Documents'
            }
        };

app.drawer.open(def, _.bind(function(model) {
            var document;

if (model) {
                // `value` is not a real attribute.
                document = app.data.createBean('Documents', _.omit(model, 'value'));
                this.view.trigger('email_attachments:document', document);
            }
        }, this));
    }
}) },
"email-recipients": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Emails.EmailRecipientsField
 * @alias SUGAR.App.view.fields.BaseEmailsEmailRecipientsField
 * @extends View.Fields.Base.BaseField
 */
({
	// Email-recipients FieldTemplate (base)

/**
     * @inheritdoc
     *
     * This field doesn't support `showNoData`.
     */
    showNoData: false,

/**
     * The selector for accessing the Select2 field when in edit mode. The
     * Select2 field is where the recipients are displayed.
     *
     * @property {string}
     */
    fieldTag: 'input.select2',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        var plugins = [
            'CollectionFieldLoadAll',
            'EmailParticipants',
            'DragdropSelect2',
            'ListEditable'
        ];

this.plugins = _.union(this.plugins || [], plugins);
        this.events = _.extend({}, this.events, {
            'click .btn': '_showAddressBook'
        });
        this._super('initialize', [options]);

// Specify the error label for when any recipient's email address is
        // invalid.
        app.error.errorName2Keys[this.type] = app.lang.get('ERR_INVALID_RECIPIENTS', this.module);
    },

if (_.isEmpty($el.data('select2'))) {
                    this.render();
                } else {
                    $el.select2('data', this.getFormattedValue());
                    this._decorateRecipients();
                    this._enableDragDrop();
                }
            }, this));
        }
    },

/**
     * @inheritdoc
     */
    bindDomChange: function() {
        var $el = this.$(this.fieldTag);

$el.on('select2-selecting', _.bind(function(event) {
            // Don't add the choice if it duplicates an existing recipient.
            var duplicate = this.model.get(this.name).find(function(model) {
                if (event.choice.get('parent_id')) {
                    return event.choice.get('parent_type') === model.get('parent_type') &&
                        event.choice.get('parent_id') === model.get('parent_id');
                }

return event.choice.get('email_address_id') === model.get('email_address_id') ||
                    event.choice.get('email_address') === model.get('email_address');
            });

if (this.disposed || duplicate) {
                event.preventDefault();
            }
        }, this));

$el.on('change', _.bind(function(event) {
            var collection;

if (this.model && !this.disposed) {
                collection = this.model.get(this.name);

if (!_.isEmpty(event.added)) {
                    collection.add(event.added);
                }

if (!_.isEmpty(event.removed)) {
                    collection.remove(event.removed);
                }
            }
        }, this));
    },

/**
     * @inheritdoc
     *
     * Destroys the Select2 element.
     */
    unbindDom: function() {
        this.$(this.fieldTag).select2('destroy');
        this._super('unbindDom');
    },

/**
     * @inheritdoc
     */
    _render: function() {
        var $el;
        var options;

this._super('_render');

$el = this.$(this.fieldTag);

if ($el.length > 0) {
            options = this.getSelect2Options();
            options = _.extend(options, {
                allowClear: true,
                multiple: true,
                containerCssClass: 'select2-choices-pills-close',

/**
                 * Constructs a representation for a selected recipient to be
                 * displayed in the field.
                 *
                 * See [Select2 Documentation](http://ivaynberg.github.io/select2/#documentation).
                 *
                 * @param {Data.Bean} recipient
                 * @return {string}
                 * @private
                 */
                formatSelection: _.bind(function(recipient) {
                    var template = app.template.getField(this.type, 'select2-selection', this.module);
                    var name = recipient.get('parent_name') || '';
                    var email = recipient.get('email_address') || '';

// The name was erased, so let's use the label.
                    if (_.isEmpty(name) && recipient.nameIsErased) {
                        name = app.lang.get('LBL_VALUE_ERASED', recipient.module);
                    }

// The email was erased, so let's use the label.
                    if (_.isEmpty(email) && recipient.emailIsErased) {
                        email = app.lang.get('LBL_VALUE_ERASED', recipient.module);
                    }

return template({
                        cid: recipient.cid,
                        name: name || email,
                        email_address: email,
                        invalid: recipient.invalid,
                        opt_out: !!recipient.get('opt_out'),
                        name_is_erased: recipient.nameIsErased,
                        email_is_erased: recipient.emailIsErased
                    });
                }, this),

/**
                 * Constructs a representation for the recipient to be
                 * displayed in the dropdown options after a query.
                 *
                 * See [Select2 Documentation](http://ivaynberg.github.io/select2/#documentation).
                 *
                 * @param {Data.Bean} recipient
                 * @return {string}
                 */
                formatResult: _.bind(function(recipient) {
                    var template = app.template.getField(this.type, 'select2-result', this.module);

return template({
                        value: recipient.toHeaderString({quote_name: true}),
                        module: recipient.get('parent_type')
                    });
                }, this),

if (this.isDisabled()) {
                $el.select2('disable');
            }

this._decorateRecipients();
            this._enableDragDrop();
        }
    },

/**
     * @inheritdoc
     * @return {Array}
     */
    format: function(value) {
        // Reset the tooltip.
        this.tooltip = '';

if (value instanceof app.BeanCollection) {
            value = value.map(this.prepareModel, this);

// Must wrap the callback in a function or else the collection's
            // index will be passed, causing the second parameter of
            // EmailParticipantsPlugin#formatForHeader to unintentionally
            // receive a value.
            this.tooltip = _.map(value, function(model) {
                return model.toHeaderString();
            }, this).join(', ');
        }

return value;
    },

/**
     * Returns the filter definition for the value of this field.
     *
     * @return {Array}
     */
    delegateBuildFilterDefinition: function() {
        var collection;

if (!this.model) {
            return [];
        }

collection = this.model.get(this.name);

if (!collection) {
            return [];
        }

// Return all of the models in the collection in their current state so
        // that the _link and parent_name/email_address attributes are stored
        // in the saved filter definition. This guarantees that the pills will
        // be displayed correctly when a saved or cached filter is loaded.
        return collection.map(function(model) {
            return model.attributes;
        });
    },

/**
     * Decorates recipients that need it.
     *
     * @private
     */
    _decorateRecipients: function() {
        this._decorateOptedOutRecipients();
        this._decorateInvalidRecipients();
    },

/**
     * Decorate any invalid recipients.
     *
     * @private
     */
    _decorateInvalidRecipients: function() {
        var self = this;
        var $invalidRecipients = this.$('.select2-search-choice [data-invalid="true"]');

if (this.def.decorate_invalid === false) {
            return;
        }

$invalidRecipients.each(function() {
            var $choice = $(this).closest('.select2-search-choice');
            $choice.addClass('select2-choice-danger');

// Don't change the tooltip if the email address has been erased.
            if (!$(this).data('email-is-erased')) {
                $(this).attr('data-title', app.lang.get('ERR_INVALID_EMAIL_ADDRESS', self.module));
            }
        });
    },

/**
     * Decorate any opted out email addresses.
     *
     * Email addresses that are opted out and invalid are not decorated by this
     * method. This preserves the invalid recipient decoration, since users
     * will need that decoration to correct their email before saving or
     * sending.
     *
     * @private
     */
    _decorateOptedOutRecipients: function() {
        var self = this;
        var $optedOutRecipients = this.$('.select2-search-choice [data-optout="true"]:not([data-invalid="true"])');

if (this.def.decorate_opt_out === false) {
            return;
        }

$optedOutRecipients.each(function() {
            var $choice = $(this).closest('.select2-search-choice');
            $choice.addClass('select2-choice-optout');
            $(this).attr('data-title', app.lang.get('LBL_EMAIL_ADDRESS_OPTED_OUT', self.module, {
                email_address: $choice.data('select2Data').get('email_address')
            }));
        });
    },

/**
     * Enable the user to drag and drop recipients between recipient fields.
     *
     * @private
     */
    _enableDragDrop: function() {
        var $el = this.$(this.fieldTag);

if (!this.def.readonly) {
            this.setDragDropPluginEvents($el);
        }
    },

/**
     * When in edit mode, the field includes an icon button for opening an
     * address book. Clicking the button will trigger an event to open the
     * address book, which calls this method does. The selected recipients are
     * added to this field upon closing the address book.
     *
     * @private
     */
    _showAddressBook: function() {
        app.drawer.open(
            {
                layout: 'compose-addressbook',
                context: {
                    module: 'Emails',
                    mixed: true
                }
            },
            _.bind(function(recipients) {
                if (recipients && recipients.length > 0) {
                    // Set the correct link for the field where these
                    // recipients are being added.
                    var eps = recipients.map(function(recipient) {
                        recipient.set('_link', this.getLinkName());

return recipient;
                    }, this);

this.model.get(this.name).add(eps);
                }

this.view.trigger('address-book-state', 'closed');
            }, this)
        );

this.view.trigger('address-book-state', 'open');
    },

/**
     * Moves the recipients to the target collection.
     *
     * @param {Data.BeanCollection} source The collection from which the
     *   recipients are removed.
     * @param {Data.BeanCollection} target The collection to which the
     *   items are added.
     * @param {Array} draggedItems The recipients that are to be removed from
     *   the source collection.
     * @param {Array} droppedItems The recipients that are to be added to
     *   the target collection.
     */
    dropDraggedItems: function(source, target, draggedItems, droppedItems) {
        source.remove(draggedItems);

_.each(droppedItems, function(item) {
            // The `id` must be unset because we're effectively creating
            // a brand new model to be linked.
            item.unset('id');
            item.set('_link', this.getLinkName());
        }, this);

target.add(droppedItems);
    }
}) },
"emailaction-paneltop": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Emails.EmailactionPaneltopField
 * @alias SUGAR.App.view.fields.BaseEmailsEmailactionPaneltopField
 * @extends View.Fields.Base.EmailactionField
 */
({
	// Emailaction-paneltop FieldTemplate (base)

extendsFrom: 'EmailactionField',

/**
     * @inheritdoc
     * Set type to emailaction to get the template
     */
    initialize: function(options) {
        this._super("initialize", [options]);
        this.type = 'emailaction';
        this.on('emailclient:close', this.handleEmailClientClose, this);
    },

/**
     * When email compose is done, refresh the data in the Emails subpanel
     */
    handleEmailClientClose: function() {
        var context = this.context.parent || this.context;
        var links = app.utils.getLinksBetweenModules(context.get('module'), this.module);

_.each(links, function(link) {
            context.trigger('panel-top:refresh', link.name);
        });
        app.events.trigger('link:added', this.context.get('parentModel'));
    },

/**
     * No additional options are needed from the element in order to launch the
     * email client.
     *
     * @param {jQuery} [$link] The element from which to get options.
     * @return {Object}
     * @private
     * @deprecated Use
     * View.Fields.Base.Emails.EmailactionPaneltopField#emailOptionTo and
     * View.Fields.Base.Emails.EmailactionPaneltopField#emailOptionRelated
     * instead.
     */
    _retrieveEmailOptionsFromLink: function($link) {
        app.logger.warn('View.Fields.Base.Emails.EmailactionPaneltopField#_retrieveEmailOptionsFromLink is ' +
            'deprecated. Use View.Fields.Base.Emails.EmailactionPaneltopField#emailOptionTo and ' +
            'View.Fields.Base.Emails.EmailactionPaneltopField#emailOptionRelated instead.');
        return {};
    },

/**
     * Returns the recipients to use in the To field of the email. If
     * `this.def.set_recipient_to_parent` is true, then the model is added to
     * the email's To field.
     *
     * @see EmailClientLaunch plugin.
     * @param {Data.Bean} model Use this model when identifying the recipients.
     * @return {undefined|Array}
     */
    emailOptionTo: function(model) {
        if (this.def.set_recipient_to_parent) {
            return [{
                bean: model
            }];
        }
    },

/**
     * Returns the bean to use as the email's related record. If
     * `this.def.set_related_to_parent` is true, then the model is used.
     *
     * @see EmailClientLaunch plugin.
     * @param {Data.Bean} model This model's parent is used as the email's
     * related record.
     * @return {undefined|Data.Bean}
     */
    emailOptionRelated: function(model) {
        if (this.def.set_related_to_parent) {
            return model;
        }
    }
}) }
}}
,
"views": {
"base": {
"recordlist": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Emails.RecordlistView
 * @alias SUGAR.App.view.views.BaseEmailsRecordlistView
 * @extends View.Views.Base.RecordlistView
 */
({
	// Recordlist View (base)

extendsFrom: 'RecordlistView',

/**
     * @inheritdoc
     * When record name is empty, return (no subject)
     */
    _getNameForMessage: function(model) {
        var name = this._super('_getNameForMessage', [model]);

if (_.isEmpty(name)) {
            return app.lang.get('LBL_NO_SUBJECT', this.module);
        }

return name;
    }
}) },
"archive-email": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Emails.ArchiveEmailView
 * @alias SUGAR.App.view.views.BaseEmailsArchiveEmailView
 * @extends View.Views.Base.Emails.ComposeView
 * @deprecated Use {@link View.Views.Base.Emails.CreateView} instead.
 */
({
	// Archive-email View (base)

extendsFrom: 'EmailsComposeView',

/**
     * @inheritdoc
     *
     * Add click event handler to archive an email.
     */
    initialize: function(options) {
        app.logger.warn(
            'View.Views.Base.Emails.ArchiveEmailView is deprecated. Use View.Views.Base.Emails.CreateView instead.'
        );

this.events = _.extend({}, this.events, {
            'click [name=archive_button]': 'archive'
        });
        this._super('initialize', [options]);

if (!this.model.has('assigned_user_id')) {
            this.model.set('assigned_user_id', app.user.id);
            this.model.set('assigned_user_name', app.user.get('full_name'));
        }
    },

/**
     * Set headerpane title.
     * @private
     */
    _render: function() {
        var $controls;

this._super('_render');

$controls = this.$('.control-group:not(.hide) .control-label');
        if ($controls.length) {
            $controls.last().addClass('end-fieldgroup');
        }

this.setTitle(app.lang.get('LBL_ARCHIVE_EMAIL', this.module));
    },

/**
     * Archive email if validation passes.
     */
    archive: function(event) {
        this.setMainButtonsDisabled(true);
        this.model.doValidate(this.getFieldsToValidate(), _.bind(function(isValid) {
            if (isValid) {
                this.archiveEmail();
            } else {
                this.setMainButtonsDisabled(false);
            }
        }, this));
    },

/**
     * Get fields that needs to be validated.
     * @return {Object}
     */
    getFieldsToValidate: function() {
        var fields = {};
        _.each(this.fields, function(field) {
            fields[field.name] = field.def;
        });
        return fields;
    },

/**
     * Call archive api.
     */
    archiveEmail: function() {
        var archiveUrl = app.api.buildURL('Mail/archive');
        var alertKey = 'mail_archive';
        var archiveEmailModel = this.initializeSendEmailModel();

app.alert.show(alertKey, {level: 'process', title: app.lang.get('LBL_EMAIL_ARCHIVING', this.module)});

app.api.call('create', archiveUrl, archiveEmailModel, {
            success: _.bind(function() {
                app.alert.dismiss(alertKey);
                app.alert.show(alertKey, {
                    autoClose: true,
                    level: 'success',
                    messages: app.lang.get('LBL_EMAIL_ARCHIVED', this.module)
                });
                app.drawer.close(this.model);
            }, this),
            error: function(error) {
                var msg = {level: 'error'};
                if (error && _.isString(error.message)) {
                    msg.messages = error.message;
                }
                app.alert.dismiss(alertKey);
                app.alert.show(alertKey, msg);
            },
            complete: _.bind(function() {
                if (!this.disposed) {
                    this.setMainButtonsDisabled(false);
                }
            }, this)
        });
    },

/**
     * @inheritdoc
     */
    initializeSendEmailModel: function() {
        var model = this._super('initializeSendEmailModel');
        model.set({
            'date_sent': this.model.get('date_sent'),
            'from_address': this.model.get('from_address'),
            'status': 'archive',
            'state': 'Archived'
        });
        return model;
    },

/**
     * Disable/enable archive button.
     * @param {boolean} disabled
     */
    setMainButtonsDisabled: function(disabled) {
        this.getField('archive_button').setDisabled(disabled);
    },

/**
     * No need to warn of configuration status for archive email because no
     * email is being sent.
     */
    notifyConfigurationStatus: $.noop
}) },
"compose-email": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Emails.ComposeEmailView
 * @alias SUGAR.App.view.views.BaseEmailsComposeEmailView
 * @extends View.Views.Base.Emails.CreateView
 */
({
	// Compose-email View (base)

extendsFrom: 'EmailsCreateView',

/**
     * Constant representing the state of an email when it is a draft.
     *
     * @property {string}
     */
    STATE_DRAFT: 'Draft',

/**
     * Constant representing the state of an email when it is ready to be sent.
     *
     * @property {string}
     */
    STATE_READY: 'Ready',

/**
     * The name of the send button.
     *
     * @property {string}
     */
    sendButtonName: 'send_button',

/**
     * Used for determining if an email's content contains variables.
     *
     * @property {RegExp}
     */
    _hasVariablesRegex: /\$[a-zA-Z]+_[a-zA-Z0-9_]+/,

/**
     * False when the email client reports a configuration issue.
     *
     * @property {boolean}
     */
    _userHasConfiguration: true,

/**
     * The label to be used as the title of the page.
     *
     * @property {string}
     */
    _titleLabel: 'LBL_COMPOSE_MODULE_NAME_SINGULAR',

/**
     * @inheritdoc
     *
     * Disables the send button if email has not been configured.
     */
    initialize: function(options) {
        var loadingRequests = 0;

this._super('initialize', [options]);

if (this.model.isNew()) {
            this.model.set('state', this.STATE_DRAFT);
        }

this.on('email_not_configured', function() {
            var sendButton = this.getField('send_button');

if (sendButton) {
                sendButton.setDisabled(true);
            }

this._userHasConfiguration = false;
        }, this);

this.on('loading_collection_field', function() {
            loadingRequests++;
            this.toggleButtons(false);
        }, this);

this.on('loaded_collection_field', function() {
            loadingRequests--;

if (loadingRequests === 0) {
                this.toggleButtons(true);
            }
        }, this);
    },

/**
     * @inheritdoc
     *
     * Renders the recipients fieldset anytime there are changes to the `to`,
     * `cc`, or `bcc` fields.
     *
     * Disables the send button if the attachments exceed the
     * max_aggregate_email_attachments_bytes configuration. Enables the send
     * button if the attachments are under the
     * max_aggregate_email_attachments_bytes configuration configuration.
     */
    bindDataChange: function() {
        var self = this;
        var renderRecipientsField = _.debounce(function() {
            var field = self.getField('recipients');

if (field) {
                field.render();
            }
        }, 200);

if (this.model) {
            this.listenTo(
                this.model,
                'change:to_collection change:cc_collection change:bcc_collection',
                renderRecipientsField
            );
            this.listenTo(this.model, 'attachments_collection:over_max_total_bytes', function() {
                var sendButton = this.getField(this.sendButtonName);

if (sendButton) {
                    sendButton.setDisabled(true);
                }
            });
            this.listenTo(this.model, 'attachments_collection:under_max_total_bytes', function() {
                var sendButton = this.getField(this.sendButtonName);

if (sendButton) {
                    sendButton.setDisabled(!this._userHasConfiguration);
                }
            });
        }

this._super('bindDataChange');
    },

/**
     * @inheritdoc
     *
     * Registers a handler to send the email when the send button is clicked.
     */
    delegateButtonEvents: function() {
        this._super('delegateButtonEvents');
        this.listenTo(this.context, 'button:' + this.sendButtonName + ':click', function() {
            this.send();
        });
    },

/**
     * @inheritdoc
     *
     * The send button cannot be enabled if email is not configured for the
     * user.
     */
    toggleButtons: function(enable) {
        this._super('toggleButtons', [enable]);

if (enable && this.buttons[this.sendButtonName] && !this._userHasConfiguration) {
            this.buttons[this.sendButtonName].setDisabled(true);
        }
    },

/**
     * @inheritdoc
     *
     * Implements the Compose:Send shortcut to send the email.
     */
    registerShortcuts: function() {
        this._super('registerShortcuts');

app.shortcuts.register({
            id: 'Compose:Send',
            keys: ['mod+shift+s'],
            component: this,
            description: 'LBL_SHORTCUT_EMAIL_SEND',
            callOnFocus: true,
            handler: function() {
                var $sendButton = this.$('a[name=' + this.sendButtonName + ']');

if ($sendButton.is(':visible') && !$sendButton.hasClass('disabled')) {
                    $sendButton.get(0).click();
                }
            }
        });
    },

/**
     * @inheritdoc
     *
     * `BaseEmailsCreateView` is used when creating new emails and editing
     * existing drafts. The model is not new when editing drafts. In those
     * cases, {@link BaseEmailsRecordView#hasUnsavedChanges} is called to use
     * logic that checks for unsaved changes for existing records instead of
     * new records.
     */
    hasUnsavedChanges: function() {
        if (this.model.isNew()) {
            return this._super('hasUnsavedChanges');
        }

return app.view.views.BaseEmailsRecordView.prototype.hasUnsavedChanges.call(this);
    },

/**
     * Sends the email.
     *
     * Warns the user if the subject and/or body are empty. The user may still
     * send the email after confirming.
     *
     * Alerts the user if the email does not have any recipients.
     */
    send: function() {
        var confirmationMessages = [];
        var subject = this.model.get('name') || '';
        var text = this.model.get('description') || '';
        var html = this.model.get('description_html') || '';
        var fullContent = subject + ' ' + text + ' ' + html;
        var isSubjectEmpty = _.isEmpty(subject.trim());
        // When fetching tinyMCE content, convert to jQuery Object
        // and return only if text is not empty. By wrapping the value
        // in <div> tags we remove the error if the value contains
        // no HTML markup
        var isContentEmpty = _.isEmpty($('<div>' + html + '</div>').text().trim());

var sendEmail = _.bind(function() {
            this.model.set('state', this.STATE_READY);
            this.save();
        }, this);

this.disableButtons();

if (this.model.get('to_collection').length === 0 &&
            this.model.get('cc_collection').length === 0 &&
            this.model.get('bcc_collection').length === 0
        ) {
            this.model.trigger('error:validation:to_collection');
            app.alert.show('send_error', {
                level: 'error',
                messages: 'LBL_EMAIL_COMPOSE_ERR_NO_RECIPIENTS'
            });
            this.enableButtons();
        } else {
            // to/cc/bcc filled out, check other fields
            if (isSubjectEmpty && isContentEmpty) {
                confirmationMessages.push(app.lang.get('LBL_NO_SUBJECT_NO_BODY_SEND_ANYWAYS', this.module));
            } else if (isSubjectEmpty) {
                confirmationMessages.push(app.lang.get('LBL_SEND_ANYWAYS', this.module));
            } else if (isContentEmpty) {
                confirmationMessages.push(app.lang.get('LBL_NO_BODY_SEND_ANYWAYS', this.module));
            }

if (_.isEmptyValue(this.model.get('parent_id')) && this._hasVariablesRegex.test(fullContent)) {
                confirmationMessages.push(app.lang.get('LBL_NO_RELATED_TO_WITH_TEMPLATE_SEND_ANYWAYS', this.module));
            }

if (confirmationMessages.length > 0) {
                app.alert.show('send_confirmation', {
                    level: 'confirmation',
                    messages: confirmationMessages.join('<br />'),
                    onConfirm: sendEmail,
                    onCancel: _.bind(this.enableButtons, this)
                });
            } else {
                // All checks pass, send the email
                sendEmail();
            }
        }
    },

/**
     * @inheritdoc
     *
     * Builds the appropriate success message based on the state of the email.
     */
    buildSuccessMessage: function() {
        var successLabel = this.model.get('state') === this.STATE_DRAFT ? 'LBL_DRAFT_SAVED' : 'LBL_EMAIL_SENT';

return app.lang.get(successLabel, this.module);
    }
}) },
"compose-addressbook-recipientscontainer": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Emails.ComposeAddressbookRecipientscontainerView
 * @alias SUGAR.App.view.views.BaseEmailsComposeAddressbookRecipientscontainerView
 * @extends View.Views.Base.RecordView
 */
({
	// Compose-addressbook-recipientscontainer View (base)

extendsFrom: 'RecordView',
    enableHeaderButtons: false,
    enableHeaderPane: false,
    events: {},

/**
     * Override to remove unwanted functionality.
     *
     * @param prefill
     */
    setupDuplicateFields: function(prefill) {},

/**
     * Override to remove unwanted functionality.
     */
    delegateButtonEvents: function() {},

/**
     * Override to remove unwanted functionality.
     */
    _initButtons: function() {
        this.buttons = {};
    },

/**
     * Override to remove unwanted functionality.
     */
    showPreviousNextBtnGroup: function() {},

/**
     * Override to remove unwanted functionality.
     */
    bindDataChange: function() {},

/**
     * Override to remove unwanted functionality.
     *
     * @param isEdit
     */
    toggleHeaderLabels: function(isEdit) {},

/**
     * Override to remove unwanted functionality.
     *
     * @param field
     */
    toggleLabelByField: function(field) {},

/**
     * Override to remove unwanted functionality.
     *
     * @param e
     * @param field
     */
    handleKeyDown: function(e, field) {},

/**
     * Override to remove unwanted functionality.
     *
     * @param state
     */
    setButtonStates: function(state) {},

/**
     * Override to remove unwanted functionality.
     *
     * @param title
     */
    setTitle: function(title) {}
}) },
"record": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Emails.RecordView
 * @alias SUGAR.App.view.views.BaseEmailsRecordView
 * @extends View.Views.Base.RecordView
 */
({
	// Record View (base)

extendsFrom: 'RecordView',

/**
     * Constant representing the state of an email when it is a draft.
     *
     * @property {string}
     */
    STATE_DRAFT: 'Draft',

/**
     * @inheritdoc
     *
     * Alerts the user if the email is a draft, so that user can switch to
     * composing the email instead of simply viewing it.
     */
    initialize: function(options) {
        var loadingRequests = 0;

this._super('initialize', [options]);

this._alertUserDraftState();

this.on('loading_collection_field', function() {
            loadingRequests++;
            this.toggleButtons(false);
        }, this);

this.on('loaded_collection_field', function() {
            loadingRequests--;

if (loadingRequests === 0) {
                this.toggleButtons(true);
            }
        }, this);
    },

/**
     * @inheritdoc
     *
     * Alerts the user if the email becomes a draft -- most likely due to
     * asynchronous data patching -- so that user can switch to composing the
     * email instead of simply viewing it.
     *
     * Renders the recipients fieldset anytime there are changes to the From,
     * To, CC, or BCC fields.
     */
    bindDataChange: function() {
        var self = this;

/**
         * Render the specified recipients field.
         *
         * @param {string} fieldName
         */
        function renderRecipientsField(fieldName) {
            var field = self.getField(fieldName);

if (field) {
                field.render();
            }
        }

if (this.model) {
            this.listenTo(this.model, 'change:state', function() {
                this._alertUserDraftState();
                this.setButtonStates(this.getCurrentButtonState());
            });

this.listenTo(this.model, 'change:from_collection', function() {
                renderRecipientsField('from_collection');
            });
            this.listenTo(this.model, 'change:to_collection', function() {
                renderRecipientsField('to_collection');
            });
            this.listenTo(this.model, 'change:cc_collection', function() {
                renderRecipientsField('cc_collection');
            });
            this.listenTo(this.model, 'change:bcc_collection', function() {
                renderRecipientsField('bcc_collection');
            });
        }

this._super('bindDataChange');
    },

/**
     * @inheritdoc
     *
     * Adds the view parameter. It must be added to `options.params` because
     * the `options.view` is only added as a parameter if the request method is
     * "read".
     */
    getCustomSaveOptions: function(options) {
        options = options || {};
        options.params = options.params || {};
        options.params.view = this.name;

return options;
    },

/**
     * @inheritdoc
     *
     * Switches to the email compose route if the email is a draft.
     */
    editClicked: function() {
        if (this._isEditableDraft()) {
            this._navigateToEmailCompose();
        } else {
            this._super('editClicked');
        }
    },

/**
     * @inheritdoc
     *
     * Hides the Forward, Reply, and Reply All buttons if the email is a draft.
     */
    setButtonStates: function(state) {
        var buttons;
        var buttonsToHideOnDrafts;

/**
         * Some buttons contain other buttons, like ActiondropdownField. This
         * function recursively finds all buttons starting at the root.
         *
         * @param {Array} allButtons The set of buttons that have been found so
         * far. Begin with an empty array to prime the set.
         * @param {Object|Array} root A collection of button fields.
         * @return {Array}
         */
        function getAllButtons(allButtons, root) {
            var nestedButtons = _.flatten(_.compact(_.pluck(root, 'fields')));

if (nestedButtons.length > 0) {
                allButtons = allButtons.concat(nestedButtons);
                allButtons = getAllButtons(allButtons, nestedButtons);
            }

return allButtons;
        }

this._super('setButtonStates', [state]);

if (this.model.get('state') === this.STATE_DRAFT) {
            buttons = getAllButtons([], this.buttons);
            buttonsToHideOnDrafts = _.filter(buttons, function(field) {
                return _.contains(['reply_button', 'reply_all_button', 'forward_button'], field.name);
            });

_.each(buttonsToHideOnDrafts, function(field) {
                field.hide();
            });
        }
    },

/**
     * Alerts the user if a draft was opened in the record view, so the user
     * can switch to composing the email instead of simply viewing it.
     *
     * @private
     */
    _alertUserDraftState: function() {
        app.alert.dismiss('email-draft-alert');

if (this._isEditableDraft()) {
            app.alert.show('email-draft-alert', {
                level: 'warning',
                autoClose: false,
                messages: app.lang.get('LBL_OPEN_DRAFT_ALERT', this.module, {subject: this.model.get('name')}),
                onLinkClick: _.bind(function(event) {
                    app.alert.dismiss('email-draft-alert');
                    this._navigateToEmailCompose();
                }, this)
            });
        }
    },

/**
     * @inheritdoc
     *
     * @return {string} Returns (no subject) when the record name is empty.
     */
    _getNameForMessage: function(model) {
        var name = this._super('_getNameForMessage', [model]);

if (_.isEmpty(name)) {
            return app.lang.get('LBL_NO_SUBJECT', this.module);
        }

return name;
    },

/**
     * Determines the email is a draft and the user can edit it.
     *
     * @return {boolean}
     * @private
     */
    _isEditableDraft: function() {
        return this.model.get('state') === this.STATE_DRAFT && app.acl.hasAccessToModel('edit', this.model);
    },

/**
     * Switches to the email compose route for the email. This method should
     * only be used if the email is a draft.
     *
     * @private
     */
    _navigateToEmailCompose: function() {
        var route;

if (this._isEditableDraft()) {
            route = '#' + app.router.buildRoute(this.model.module, this.model.get('id'), 'compose');
            app.router.navigate(route, {trigger: true});
        }
    }
}) },
"compose-addressbook-filter": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Emails.ComposeAddressbookFilterView
 * @alias SUGAR.App.view.views.BaseEmailsComposeAddressbookFilterView
 * @extends View.View
 */
({
	// Compose-addressbook-filter View (base)

/**
     * Builds the list of allowed modules to provide the data to the select2 field.
     */
    buildModuleFilterList: function() {
        var allowedModules = this.collection.allowed_modules;

this._moduleFilterList = [
            {id: this._allModulesId, text: app.lang.get('LBL_MODULE_ALL')}
        ];

_.each(allowedModules, function(module) {
            this._moduleFilterList.push({
                id: module,
                text: app.lang.getModuleName(module, {plural: true})
            });
        }, this);
    },

/**
     * Converts the input field to a select2 field and initializes the selected module.
     */
    buildFilter: function() {
        var $filter = this.getFilterField();
        if ($filter.length > 0) {
            $filter.select2({
                data: this._moduleFilterList,
                allowClear: false,
                multiple: false,
                minimumResultsForSearch: -1,
                formatSelection: _.bind(this.formatModuleSelection, this),
                formatResult: _.bind(this.formatModuleChoice, this),
                dropdownCss: {width: 'auto'},
                dropdownCssClass: 'search-filter-dropdown',
                initSelection: _.bind(this.initSelection, this),
                escapeMarkup: function(m) { return m; },
                width: 'off'
            });
            $filter.off('change');
            $filter.on('change', _.bind(this.handleModuleSelection, this));
            this._selectedModule = this._selectedModule || this._allModulesId;
            $filter.select2('val', this._selectedModule);
        }
    },

/**
     * Gets the filter DOM field.
     *
     * @return {jQuery} DOM Element
     */
    getFilterField: function() {
        return this.$('input.select2');
    },

/**
     * Gets the module filter DOM field.
     *
     * @return {jQuery} DOM Element
     */
    getModuleFilter: function() {
        return this.$('span.choice-filter-label');
    },

/**
     * Destroy the select2 plugin.
     */
    unbind: function() {
        $filter = this.getFilterField();
        if ($filter.length > 0) {
            $filter.off();
            $filter.select2('destroy');
        }
        this._super('unbind');
    },

/**
     * Performs a search once the user has entered a term.
     */
    throttledSearch: _.debounce(function(evt) {
        var newSearch = this.$(evt.currentTarget).val();
        if (this._currentSearch !== newSearch) {
            this._currentSearch = newSearch;
            this.applyFilter();
        }
    }, 400),

/**
     * Initialize the module selection with the value for all modules.
     *
     * @param {jQuery} el
     * @param {Function} callback
     */
    initSelection: function(el, callback) {
        if (el.is(this.getFilterField())) {
            var module = _.findWhere(this._moduleFilterList, {id: el.val()});
            callback({id: module.id, text: module.text});
        }
    },

/**
     * Format the selected module to display its name.
     *
     * @param {Object} item
     * @return {String}
     */
    formatModuleSelection: function(item) {
        // update the text for the selected module
        this.getModuleFilter().text(item.text);
        return '<span class="select2-choice-type">' +
            app.lang.get('LBL_MODULE') +
            '<i class="sicon sicon-chevron-down"></i></span>';
    },

/**
     * Format the choices in the module select box.
     *
     * @param {Object} option
     * @return {String}
     */
    formatModuleChoice: function(option) {
        return '<div><span class="select2-match"></span>' + option.text + '</div>';
    },

/**
     * Handler for when the module filter dropdown value changes, either via a click or manually calling jQuery's
     * .trigger("change") event.
     *
     * @param {Object} evt jQuery Change Event Object
     * @param {string} overrideVal (optional) ID passed in when manually changing the filter dropdown value
     */
    handleModuleSelection: function(evt, overrideVal) {
        var module = overrideVal || evt.val || this._selectedModule || this._allModulesId;
        // only perform a search if the module is in the approved list
        if (!_.isEmpty(_.findWhere(this._moduleFilterList, {id: module}))) {
            this._selectedModule = module;
            this.getFilterField().select2('val', this._selectedModule);
            this.getModuleFilter().css('cursor', 'pointer');
            this.applyFilter();
        }
    },

/**
     * Triggers an event that makes a call to search the address book and filter the data set.
     */
    applyFilter: function() {
        var searchAllModules = (this._selectedModule === this._allModulesId),
            // pass an empty array when all modules are being searched
            module = searchAllModules ? [] : [this._selectedModule],
            // determine if the filter is dirty so the "clearQuickSearchIcon" can be added/removed appropriately
            isDirty = !_.isEmpty(this._currentSearch);
        this._toggleClearQuickSearchIcon(isDirty);
        this.context.trigger('compose:addressbook:search', module, this._currentSearch);
    },

/**
     * Append or remove an icon to the quicksearch input so the user can clear the search easily.
     * @param {Boolean} addIt TRUE if you want to add it, FALSE to remove
     */
    _toggleClearQuickSearchIcon: function(addIt) {
        if (addIt && !this.$('.add-on.sicon-close')[0]) {
            this.$('.filter-view.search').append('<i class="add-on sicon sicon-close"></i>');
        } else if (!addIt) {
            this.$('.add-on.sicon-close').remove();
        }
    },

/**
     * Clear input
     */
    clearInput: function() {
        var $filter = this.getFilterField();
        this._currentSearch = '';
        this._selectedModule = this._allModulesId;
        this.$('.search-name').val(this._currentSearch);
        if ($filter.length > 0) {
            $filter.select2('val', this._selectedModule);
        }
        this.applyFilter();
    }
}) },
"activity-card-content": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Emails.ActivityCardContentView
 * @alias SUGAR.App.view.views.BaseEmailsActivityCardContentView
 * @extends View.Views.Base.ActivityCardContentView
 */
({
	// Activity-card-content View (base)

extendsFrom: 'ActivityCardContentView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);
        this.initAttachmentDetails('attachments_collection');
        this.listenTo(this, 'tinymce:resize', this.toggleShowMore);
    },

/**
     * Initializes hbs date variables with date_modified
     */
    initDateDetails: function() {
        if (!this.activity) {
            return;
        }
        const state = this.activity.get('state');
        const activityCard = this.getActivityCardLayout();
        let detailDate = app.date(activityCard.getCreatedDate(state));
        let dateModified = app.date(this.activity.get('date_modified'));

if (detailDate.isValid() && dateModified.isValid()) {
            detailDate = detailDate.formatUser();
            dateModified = dateModified.formatUser();

if (detailDate !== dateModified) {
                this.dateModified = dateModified;
            }
        }
    },
}) },
"compose-addressbook-list-bottom": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Emails.ComposeAddressbookListBottomView
 * @alias SUGAR.App.view.views.BaseEmailsComposeAddressbookListBottomView
 * @extends View.Views.Base.ListBottomView
 */
({
	// Compose-addressbook-list-bottom View (base)

extendsFrom: 'ListBottomView',

/**
     * Assign proper label for 'show more' link.
     * Label should be "More recipients...".
     */
    setShowMoreLabel: function() {
        this.showMoreLabel = app.lang.get('LBL_SHOW_MORE_RECIPIENTS', this.module);
    }
}) },
"compose-addressbook-headerpane": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Emails.ComposeAddressbookHeaderpaneView
 * @alias SUGAR.App.view.views.BaseEmailsComposeAddressbookHeaderpaneView
 * @extends View.Views.Base.HeaderpaneView
 */
({
	// Compose-addressbook-headerpane View (base)

extendsFrom: 'HeaderpaneView',

events: {
        'click [name=done_button]': '_done',
        'click [name=cancel_button]': '_cancel'
    },

/**
      * The user clicked the Done button so trigger an event to add selected recipients from the address book to the
      * target field and then close the drawer.
      *
      * @private
      */
     _done: function() {
         var recipients = this.model.get('to_collection');

if (recipients) {
             app.drawer.close(recipients);
         } else {
             this._cancel();
         }
     },

/**
     * Close the drawer.
     *
     * @private
     */
    _cancel: function() {
        app.drawer.close();
    }
}) },
"compose": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Emails.ComposeView
 * @alias SUGAR.App.view.views.BaseEmailsComposeView
 * @extends View.Views.Base.RecordView
 * @deprecated Use {@link View.Views.Base.Emails.ComposeEmailView} instead.
 */
({
	// Compose View (base)

extendsFrom: 'RecordView',

_lastSelectedSignature: null,
    ATTACH_TYPE_SUGAR_DOCUMENT: 'document',
    ATTACH_TYPE_TEMPLATE: 'template',
    MIN_EDITOR_HEIGHT: 300,
    EDITOR_RESIZE_PADDING: 5,
    ATTACHMENT_FIELD_HEIGHT: 44,
    FIELD_PANEL_BODY_SELECTOR: '.row-fluid.panel_body',

sendButtonName: 'send_button',
    cancelButtonName: 'cancel_button',
    saveAsDraftButtonName: 'draft_button',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        app.logger.warn('View.Views.Base.Emails.ComposeView is deprecated. Use ' +
            'View.Views.Base.Emails.ComposeEmailView instead.');

this._super('initialize', [options]);
        this.events = _.extend({}, this.events, {
            'click [data-toggle-field]': '_handleSenderOptionClick'
        });
        this.context.on('email_attachments:file', this.launchFilePicker, this);
        this.context.on('email_attachments:document', this.documentDrawerCallback, this);
        this.context.on('attachments:updated', this.toggleAttachmentVisibility, this);
        this.context.on('tinymce:oninit', this.handleTinyMceInit, this);
        this.on('more-less:toggled', this.handleMoreLessToggled, this);
        app.drawer.on('drawer:resize', this.resizeEditor, this);

this._lastSelectedSignature = app.user.getPreference('signature_default');
    },

/**
     * @inheritdoc
     */
    delegateButtonEvents: function() {
        this.context.on('button:' + this.sendButtonName + ':click', this.send, this);
        this.context.on('button:' + this.saveAsDraftButtonName + ':click', this.saveAsDraft, this);
        this.context.on('button:' + this.cancelButtonName + ':click', this.cancel, this);
    },

/**
     * @inheritdoc
     */
    _render: function() {
        var prepopulateValues;
        var $controls;

this._super('_render');

$controls = this.$('.control-group:not(.hide) .control-label');
        if ($controls.length) {
            $controls.first().addClass('begin-fieldgroup');
            $controls.last().addClass('end-fieldgroup');
        }

this.setTitle(app.lang.get('LBL_COMPOSEEMAIL', this.module));

prepopulateValues = this.context.get('prepopulate');
        if (!_.isEmpty(prepopulateValues)) {
            this.prepopulate(prepopulateValues);
        }
        this.addSenderOptions();

this.notifyConfigurationStatus();
    },

/**
     * Notifies the user of configuration issues and disables send button
     */
    notifyConfigurationStatus: function() {
        var sendButton,
            emailClientPrefence = app.user.getPreference('email_client_preference');

if (_.isObject(emailClientPrefence) && _.isObject(emailClientPrefence.error)) {
            app.alert.show('email-client-status', {
                level: 'warning',
                messages: app.lang.get(emailClientPrefence.error.message, this.module),
                autoClose: false,
                onLinkClick: function() {
                    app.alert.dismiss('email-client-status');
                }
            });

sendButton = this.getField('send_button');
            if (sendButton) {
                sendButton.setDisabled(true);
            }
        }
    },

/**
     * Prepopulate fields on the email compose screen that are passed in on the context when opening this view
     * TODO: Refactor once we have custom module specific models
     * @param {Object} values
     */
    prepopulate: function(values) {
        var self = this;
        _.defer(function() {
            _.each(values, function(value, fieldName) {
                switch (fieldName) {
                    case 'related':
                        self._populateForModules(value);
                        self.populateRelated(value);
                        break;
                    default:
                        self.model.set(fieldName, value);
                }
            });
        });
    },

/**
     * Populates email compose with module specific data.
     * TODO: Refactor once we have custom module specific models
     * @param {Data.Bean} relatedModel
     */
    _populateForModules: function(relatedModel) {
        if (relatedModel.module === 'Cases') {
            this._populateForCases(relatedModel);
        }
    },

/**
     * Populates email compose with cases specific data.
     * TODO: Refactor once we have custom module specific models
     * @param {Data.Bean} relatedModel
     */
    _populateForCases: function(relatedModel) {
        var config = app.metadata.getConfig(),
            keyMacro = '%1',
            caseMacro = config.inboundEmailCaseSubjectMacro,
            subject = caseMacro + ' ' + relatedModel.get('name');

subject = subject.replace(keyMacro, relatedModel.get('case_number'));
        this.model.set('name', subject);
        if (!this.isFieldPopulated('to_addresses')) {
            // no addresses, attempt to populate from contacts relationship
            var contacts = relatedModel.getRelatedCollection('contacts');

contacts.fetch({
                relate: true,
                success: _.bind(function(data) {
                    var toAddresses = _.map(data.models, function(model) {
                        return {bean: model};
                    }, this);

this.model.set('to_addresses', toAddresses);
                }, this),
                fields: ['id', 'full_name', 'email']
            });
        }
    },

/**
     * Populate the parent_name (type: parent) with the related record passed in
     *
     * @param {Data.Bean} relatedModel
     */
    populateRelated: function(relatedModel) {
        var setParent = _.bind(function(model) {
            var parentNameField = this.getField('parent_name');
            if (model.module && parentNameField.isAvailableParentType(model.module)) {
                model.value = model.get('name');
                parentNameField.setValue(model);
            }
        }, this);

if (!_.isEmpty(relatedModel.get('id')) && !_.isEmpty(relatedModel.get('name'))) {
            setParent(relatedModel);
        } else if (!_.isEmpty(relatedModel.get('id'))) {
            relatedModel.fetch({
                showAlerts: false,
                success: _.bind(function(relatedModel) {
                    setParent(relatedModel);
                }, this),
                fields: ['name']
            });
        }
    },

/**
     * Enable/disable the page action dropdown menu based on whether email is sendable
     * @param {boolean} disabled
     */
    setMainButtonsDisabled: function(disabled) {
        this.getField('main_dropdown').setDisabled(disabled);
    },

/**
     * Add Cc/Bcc toggle buttons
     * Initialize whether to show/hide fields and toggle show/hide buttons appropriately
     */
    addSenderOptions: function() {
        this._renderSenderOptions('to_addresses');
        this._initSenderOption('cc_addresses');
        this._initSenderOption('bcc_addresses');
    },

/**
     * Render the sender option buttons and place them in the given container
     *
     * @param {string} container Name of field that will contain the sender option buttons
     * @private
     */
    _renderSenderOptions: function(container) {
        var field = this.getField(container),
            $panelBody,
            senderOptionTemplate;

if (field) {
            $panelBody = field.$el.closest(this.FIELD_PANEL_BODY_SELECTOR);
            senderOptionTemplate = app.template.getView('compose-senderoptions', this.module);

$(senderOptionTemplate({'module' : this.module}))
                .insertAfter($panelBody.find('div span.normal'));
        }
    },

/**
     * Check if the given field has a value
     * Hide the field if there is no value prepopulated
     *
     * @param {string} fieldName Name of the field to initialize active state on
     * @private
     */
    _initSenderOption: function(fieldName) {
        var fieldValue = this.model.get(fieldName) || [];
        this.toggleSenderOption(fieldName, (fieldValue.length > 0));
    },

/**
     * Toggle the state of the given field
     * Sets toggle button state and visibility of the field
     *
     * @param {string} fieldName Name of the field to toggle
     * @param {boolean} [active] Whether toggle button active and field shown
     */
    toggleSenderOption: function(fieldName, active) {
        var toggleButtonSelector = '[data-toggle-field="' + fieldName + '"]',
            $toggleButton = this.$(toggleButtonSelector);

// if explicit active state not set, toggle to opposite
        if (_.isUndefined(active)) {
            active = !$toggleButton.hasClass('active');
        }

$toggleButton.toggleClass('active', active);
        this._toggleFieldVisibility(fieldName, active);
    },

/**
     * Event Handler for toggling the Cc/Bcc options on the page.
     *
     * @param {Event} event click event
     * @private
     */
    _handleSenderOptionClick: function(event) {
        var $toggleButton = $(event.currentTarget),
            fieldName = $toggleButton.data('toggle-field');

this.toggleSenderOption(fieldName);
        this.resizeEditor();
    },

/**
     * Show/hide a field section on the form
     *
     * @param {string} fieldName Name of the field to show/hide
     * @param {boolean} show Whether to show or hide the field
     * @private
     */
    _toggleFieldVisibility: function(fieldName, show) {
        var field = this.getField(fieldName);
        if (field) {
            field.$el.closest(this.FIELD_PANEL_BODY_SELECTOR).toggleClass('hide', !show);
        }
    },

/**
     * Cancel and close the drawer
     */
    cancel: function() {
        app.drawer.close();
    },

/**
     * Get the attachments from the model and format for the API
     *
     * @return {Array} array of attachments or empty array if none found
     */
    getAttachmentsForApi: function() {
        var attachments = this.model.get('attachments') || [];

if (!_.isArray(attachments)) {
            attachments = [attachments];
        }

return attachments;
    },

/**
     * Get the individual related object fields from the model and format for the API
     *
     * @return {Object} API related argument as array with appropriate fields set
     */
    getRelatedForApi: function() {
        var related = {};
        var id = this.model.get('parent_id');
        var type;

if (!_.isUndefined(id)) {
            id = id.toString();
            if (id.length > 0) {
                related['id'] = id;
                type = this.model.get('parent_type');
                if (!_.isUndefined(type)) {
                    type = type.toString();
                }
                related.type = type;
            }
        }

return related;
    },

/**
     * Get the team information from the model and format for the API
     *
     * @return {Object} API teams argument as array with appropriate fields set
     */
    getTeamsForApi: function() {
        var teamName = this.model.get('team_name') || [];
        var teams = {};
        teams.others = [];

if (!_.isArray(teamName)) {
            teamName = [teamName];
        }

_.each(teamName, function(team) {
            if (team.primary) {
                teams.primary = team.id.toString();
            } else if (!_.isUndefined(team.id)) {
                teams.others.push(team.id.toString());
            }
        }, this);

if (teams.others.length == 0) {
            delete teams.others;
        }

return teams;
    },

/**
     * Build a backbone model that will be sent to the Mail API
     */
    initializeSendEmailModel: function() {
        var sendModel = new Backbone.Model(_.extend({}, this.model.attributes, {
            to_addresses: this.model.get('to_addresses'),
            cc_addresses: this.model.get('cc_addresses'),
            bcc_addresses: this.model.get('bcc_addresses'),
            subject: this.model.get('name'),
            html_body: this.model.get('description_html'),
            attachments: this.getAttachmentsForApi(),
            related: this.getRelatedForApi(),
            teams: this.getTeamsForApi()
        }));
        return sendModel;
    },

/**
     * Save the email as a draft for later sending
     */
    saveAsDraft: function() {
        this.saveModel(
            'draft',
            app.lang.get('LBL_DRAFT_SAVING', this.module),
            app.lang.get('LBL_DRAFT_SAVED', this.module),
            app.lang.get('LBL_ERROR_SAVING_DRAFT', this.module)
        );
    },

/**
     * Send the email immediately or warn if user did not provide subject or body
     */
    send: function() {
        var sendEmail = _.bind(function() {
            this.saveModel(
                'ready',
                app.lang.get('LBL_EMAIL_SENDING', this.module),
                app.lang.get('LBL_EMAIL_SENT', this.module),
                app.lang.get('LBL_ERROR_SENDING_EMAIL', this.module)
            );
        }, this);

if (!this.isFieldPopulated('to_addresses') &&
            !this.isFieldPopulated('cc_addresses') &&
            !this.isFieldPopulated('bcc_addresses')
        ) {
            this.model.trigger('error:validation:to_addresses');
            app.alert.show('send_error', {
                level: 'error',
                messages: 'LBL_EMAIL_COMPOSE_ERR_NO_RECIPIENTS'
            });
        } else if (!this.isFieldPopulated('name') && !this.isFieldPopulated('description_html')) {
            app.alert.show('send_confirmation', {
                level: 'confirmation',
                messages: app.lang.get('LBL_NO_SUBJECT_NO_BODY_SEND_ANYWAYS', this.module),
                onConfirm: sendEmail
            });
        } else if (!this.isFieldPopulated('name')) {
            app.alert.show('send_confirmation', {
                level: 'confirmation',
                messages: app.lang.get('LBL_SEND_ANYWAYS', this.module),
                onConfirm: sendEmail
            });
        } else if (!this.isFieldPopulated('description_html')) {
            app.alert.show('send_confirmation', {
                level: 'confirmation',
                messages: app.lang.get('LBL_NO_BODY_SEND_ANYWAYS', this.module),
                onConfirm: sendEmail
            });
        } else {
            sendEmail();
        }
    },

/**
     * Build the backbone model to be sent to the Mail API with the appropriate status
     * Also display the appropriate alerts to give user indication of what is happening.
     *
     * @param {string} status (draft or ready)
     * @param {string} pendingMessage message to display while Mail API is being called
     * @param {string} successMessage message to display when a successful Mail API response has been received
     * @param {string} errorMessage message to display when Mail API call fails
     */
    saveModel: function(status, pendingMessage, successMessage, errorMessage) {
        var myURL,
            sendModel = this.initializeSendEmailModel();

if (this._hasInvalidRecipients(sendModel)) {
            app.alert.show('mail_invalid_recipients', {
                level: 'error',
                messages: app.lang.get('ERR_INVALID_RECIPIENTS', this.module)
            });
            this.setMainButtonsDisabled(false);
            return;
        }

this.setMainButtonsDisabled(true);
        app.alert.show('mail_call_status', {level: 'process', title: pendingMessage});

sendModel.set('status', status);
        myURL = app.api.buildURL('Mail');
        app.api.call('create', myURL, sendModel, {
            success: function() {
                app.alert.dismiss('mail_call_status');
                app.alert.show('mail_call_status', {autoClose: true, level: 'success', messages: successMessage});
                app.drawer.close(sendModel);
            },
            error: function(error) {
                var msg = {level: 'error'};
                if (error && _.isString(error.message)) {
                    msg.messages = error.message;
                }
                app.alert.dismiss('mail_call_status');
                app.alert.show('mail_call_status', msg);
            },
            complete: _.bind(function() {
                if (!this.disposed) {
                    this.setMainButtonsDisabled(false);
                }
            }, this)
        });
    },

/**
     * Is this field populated?
     * @param {string} fieldName
     * @return {boolean}
     */
    isFieldPopulated: function(fieldName) {
        var value = this.model.get(fieldName) || '';

if (value instanceof Backbone.Collection) {
            return value.length !== 0;
        } else {
            return !_.isEmpty(value.trim());
        }
    },

/**
     * Check if the recipients in any of the recipient fields are invalid.
     *
     * @param {Backbone.Model} model
     * @return {boolean} Return true if there are invalid recipients in any of
     *   the fields. Return false otherwise.
     * @private
     */
    _hasInvalidRecipients: function(model) {
        return _.some(['to_addresses', 'cc_addresses', 'bcc_addresses'], function(fieldName) {
            var recipients = model.get(fieldName);
            if (!recipients) {
                return false;
            }
            return _.some(recipients.models, function(recipient) {
                return recipient.get('_invalid');
            });
        }, this);
    },

/**
     * Open the drawer with the EmailTemplates selection list layout. The callback should take the data passed to it
     * and replace the existing editor contents with the selected template.
     */
    launchTemplateDrawer: function() {
        app.drawer.open({
                layout: 'selection-list',
                context: {
                    module: 'EmailTemplates'
                }
            },
            _.bind(this.templateDrawerCallback, this)
        );
    },

/**
     * Receives the selected template to insert and begins the process of confirming the operation and inserting the
     * template into the editor.
     *
     * @param {Data.Bean} model
     */
    templateDrawerCallback: function(model) {
        if (model) {
            var emailTemplate = app.data.createBean('EmailTemplates', { id: model.id });
            emailTemplate.fetch({
                success: _.bind(this.confirmTemplate, this),
                error: _.bind(function(model, error) {
                    this._showServerError(error);
                }, this)
            });
        }
    },

/**
     * Presents the user with a confirmation prompt indicating that inserting the template will replace all content
     * in the editor. If the user confirms "yes" then the template will inserted.
     *
     * @param {Data.Bean} template
     */
    confirmTemplate: function(template) {
        if (this.disposed === true) return; //if view is already disposed, bail out
        app.alert.show('delete_confirmation', {
            level: 'confirmation',
            messages: app.lang.get('LBL_EMAILTEMPLATE_MESSAGE_SHOW_MSG', this.module),
            onConfirm: _.bind(this.insertTemplate, this, template)
        });
    },

/**
     * Inserts the template into the editor.
     *
     * @param {Data.Bean} template
     */
    insertTemplate: function(template) {
        var subject,
            notes;

if (_.isObject(template)) {
            subject = template.get('subject');

if (subject) {
                this.model.set('name', subject);
            }

//TODO: May need to move over replaces special characters.
            if (template.get('text_only') === 1) {
                this.model.set('description_html', template.get('body'));
            } else {
                this.model.set('description_html', template.get('body_html'));
            }

notes = app.data.createBeanCollection('Notes');

notes.fetch({
                'filter': {
                    'filter': [
                        //FIXME: email_type should be EmailTemplates
                        {'email_id': {'$equals': template.id}}
                    ]
                },
                success: _.bind(function(data) {
                    if (this.disposed === true) return; //if view is already disposed, bail out
                    if (!_.isEmpty(data.models)) {
                        this.insertTemplateAttachments(data.models);
                    }
                }, this),
                error: _.bind(function(collection, error) {
                    this._showServerError(error);
                }, this)
            });

// currently adds the html signature even when the template is text-only
            this._updateEditorWithSignature(this._lastSelectedSignature);
        }
    },

/**
     * Inserts attachments associated with the template by triggering an "add" event for each attachment to add to the
     * attachments field.
     *
     * @param {Array} attachments
     */
    insertTemplateAttachments: function(attachments) {
        this.context.trigger('attachments:remove-by-tag', 'template');
        _.each(attachments, function(attachment) {
            var filename = attachment.get('filename');
            this.context.trigger('attachment:add', {
                id: attachment.id,
                name: filename,
                nameForDisplay: filename,
                tag: 'template',
                type: this.ATTACH_TYPE_TEMPLATE
            });
        }, this);
    },

/**
     * Launch the file upload picker on the attachments field.
     */
    launchFilePicker: function() {
        this.context.trigger('attachment:filepicker:launch');
    },

/**
     * Open the drawer with the SugarDocuments attachment selection list layout. The callback should take the data
     * passed to it and add the document as an attachment.
     */
    launchDocumentDrawer: function() {
        app.drawer.open({
                layout: 'selection-list',
                context: {module: 'Documents'}
            },
            _.bind(this.documentDrawerCallback, this)
        );
    },

/**
     * Fetches the selected SugarDocument using its ID and triggers an "add" event to add the attachment to the
     * attachments field.
     *
     * @param {Data.Bean} model
     */
    documentDrawerCallback: function(model) {
        if (model) {
            var sugarDocument = app.data.createBean('Documents', { id: model.id });
            sugarDocument.fetch({
                success: _.bind(function(model) {
                    if (this.disposed === true) return; //if view is already disposed, bail out
                    this.context.trigger('attachment:add', {
                        id: model.id,
                        name: model.get('filename'),
                        nameForDisplay: model.get('filename'),
                        type: this.ATTACH_TYPE_SUGAR_DOCUMENT
                    });
                }, this),
                error: _.bind(function(model, error) {
                    this._showServerError(error);
                }, this)
            });
        }
    },

/**
     * Hide attachment field row if no attachments, show when added
     *
     * @param {Array} attachments
     */
    toggleAttachmentVisibility: function(attachments) {
        var $row = this.$('.attachments').closest('.row-fluid');
        if (attachments.length > 0) {
            $row.removeClass('hidden');
            $row.addClass('single');
        } else {
            $row.addClass('hidden');
            $row.removeClass('single');
        }
        this.resizeEditor();
    },

/**
     * Open the drawer with the signature selection layout. The callback should take the data passed to it and insert
     * the signature in the correct place.
     *
     * @private
     */
    launchSignatureDrawer: function() {
        app.drawer.open(
            {
                layout: 'selection-list',
                context: {
                    module: 'UserSignatures'
                }
            },
            _.bind(this._updateEditorWithSignature, this)
        );
    },

/**
     * Fetches the signature content using its ID and updates the editor with the content.
     *
     * @param {Data.Bean} model
     */
    _updateEditorWithSignature: function(model) {
        if (model && model.id) {
            var signature = app.data.createBean('UserSignatures', { id: model.id });

signature.fetch({
                success: _.bind(function(model) {
                    if (this.disposed === true) return; //if view is already disposed, bail out
                    if (this._insertSignature(model)) {
                        this._lastSelectedSignature = model;
                    }
                }, this),
                error: _.bind(function(model, error) {
                    this._showServerError(error);
                }, this)
            });
        }
    },

/**
     * Inserts the signature into the editor.
     *
     * @param {Data.Bean} signature
     * @return {Boolean}
     * @private
     */
    _insertSignature: function(signature) {
        if (_.isObject(signature) && signature.get('signature_html')) {
            var signatureContent = this._formatSignature(signature.get('signature_html')),
                emailBody = this.model.get('description_html') || '',
                signatureOpenTag = '<br class="signature-begin" />',
                signatureCloseTag = '<br class="signature-end" />',
                signatureOpenTagForRegex = '(<br\ class=[\'"]signature\-begin[\'"].*?\/?>)',
                signatureCloseTagForRegex = '(<br\ class=[\'"]signature\-end[\'"].*?\/?>)',
                signatureOpenTagMatches = emailBody.match(new RegExp(signatureOpenTagForRegex, 'gi')),
                signatureCloseTagMatches = emailBody.match(new RegExp(signatureCloseTagForRegex, 'gi')),
                regex = new RegExp(signatureOpenTagForRegex + '[\\s\\S]*?' + signatureCloseTagForRegex, 'g');

if (signatureOpenTagMatches && !signatureCloseTagMatches) {
                // there is a signature, but no close tag; so the signature runs from open tag until EOF
                emailBody = this._insertSignatureTag(emailBody, signatureCloseTag, false); // append the close tag
            } else if (!signatureOpenTagMatches && signatureCloseTagMatches) {
                // there is a signature, but no open tag; so the signature runs from BOF until close tag
                emailBody = this._insertSignatureTag(emailBody, signatureOpenTag, true); // prepend the open tag
            } else if (!signatureOpenTagMatches && !signatureCloseTagMatches) {
                // there is no signature, so add the tag to the correct location
                emailBody = this._insertSignatureTag(
                    emailBody,
                    signatureOpenTag + signatureCloseTag, // insert both tags as one
                    (app.user.getPreference('signature_prepend') == 'true'));
            }

this.model.set('description_html', emailBody.replace(regex, '$1' + signatureContent + '$2'));

return true;
        }

return false;
    },

/**
     * Inserts a tag into the editor to surround the signature so the signature can be identified again.
     *
     * @param {string} body
     * @param {string} tag
     * @param {string} prepend
     * @return {string}
     * @private
     */
    _insertSignatureTag: function(body, tag, prepend) {
        var preSignature = '',
            postSignature = '';

prepend = prepend || false;

if (prepend) {
            var bodyOpenTag = '<body>',
                bodyOpenTagLoc = body.indexOf(bodyOpenTag);

if (bodyOpenTagLoc > -1) {
                preSignature = body.substr(0, bodyOpenTagLoc + bodyOpenTag.length);
                postSignature = body.substr(bodyOpenTagLoc + bodyOpenTag.length, body.length);
            } else {
                postSignature = body;
            }
        } else {
            var bodyCloseTag = '</body>',
                bodyCloseTagLoc = body.indexOf(bodyCloseTag);

if (bodyCloseTagLoc > -1) {
                preSignature = body.substr(0, bodyCloseTagLoc);
                postSignature = body.substr(bodyCloseTagLoc, body.length);
            } else {
                preSignature = body;
            }
        }

return preSignature + tag + postSignature;
    },

/**
     * Formats HTML signatures to replace select HTML-entities with their true characters.
     *
     * @param {string} signature
     */
    _formatSignature: function(signature) {
        signature = signature.replace(/&lt;/gi, '<');
        signature = signature.replace(/&gt;/gi, '>');

return signature;
    },

/**
     * Show a generic alert for server errors resulting from custom API calls during Email Compose workflows. Logs
     * the error message for system administrators as well.
     *
     * @param {SUGAR.HttpError} error
     * @private
     */
    _showServerError: function(error) {
        app.alert.show('server-error', {
            level: 'error',
            messages: 'ERR_GENERIC_SERVER_ERROR'
        });
        app.error.handleHttpError(error);
    },

/**
     * When toggling to show/hide hidden panel, resize editor accordingly
     */
    handleMoreLessToggled: function() {
        this.resizeEditor();
    },

/**
     * When TinyMCE has been completely initialized, go ahead and resize the editor
     */
    handleTinyMceInit: function() {
        this.resizeEditor();
    },

_dispose: function() {
        if (app.drawer) {
            app.drawer.off(null, null, this);
        }
        app.alert.dismiss('email-client-status');
        this._super('_dispose');
    },

/**
     * Register keyboard shortcuts.
     */
    registerShortcuts: function() {
        app.shortcuts.register({
            id: 'Compose:Action:More',
            keys: 'm',
            component: this,
            description: 'LBL_SHORTCUT_OPEN_MORE_ACTION',
            handler: function() {
                var $primaryDropdown = this.$('.btn-primary[data-bs-toggle=dropdown]');
                if ($primaryDropdown.is(':visible') && !$primaryDropdown.hasClass('disabled')) {
                    $primaryDropdown.click();
                }
            }
        });
        this._super('registerShortcuts');
    },

/**
     * Resize the html editor based on height of the drawer it is in
     *
     * @param {number} [drawerHeight] current height of the drawer or height the drawer will be after animations
     */
    resizeEditor: function(drawerHeight) {
        var $editor, headerHeight, recordHeight, showHideHeight, diffHeight, editorHeight, newEditorHeight;

$editor = this.$('.mce-stack-layout .mce-stack-layout-item iframe');
        //if editor not already rendered, cannot resize
        if ($editor.length === 0) {
            return;
        }

drawerHeight = drawerHeight || app.drawer.getHeight();
        headerHeight = this.$('.headerpane').outerHeight(true);
        recordHeight = this.$('.record').outerHeight(true);
        showHideHeight = this.$('.show-hide-toggle').outerHeight(true);
        editorHeight = $editor.height();

//calculate the space left to fill - subtracting padding to prevent scrollbar
        diffHeight = drawerHeight - headerHeight - recordHeight - showHideHeight -
            this.ATTACHMENT_FIELD_HEIGHT - this.EDITOR_RESIZE_PADDING;

//add the space left to fill to the current height of the editor to get a new height
        newEditorHeight = editorHeight + diffHeight;

//maintain min height
        if (newEditorHeight < this.MIN_EDITOR_HEIGHT) {
            newEditorHeight = this.MIN_EDITOR_HEIGHT;
        }

//set the new height for the editor
        $editor.height(newEditorHeight);
    },

/**
     * Turn off logic from record view which handles clicking the cancel button
     * as it causes issues for email compose.
     *
     * TODO: Remove this when record view changes to use button events instead
     * of DOM based events
     */
    cancelClicked: $.noop
}) },
"activity-card-detail": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Emails.ActivityCardDetailView
 * @alias SUGAR.App.view.views.BaseEmailsActivityCardDetailView
 * @extends View.Views.Base.ActivityCardDetailview
 */
({
	// Activity-card-detail View (base)

extendsFrom: 'ActivityCardDetailview',

/**
     * The state of the email
     */
    state: null,

/**
     * Initializes hbs date variables with date_entered
     */
    initDateDetails: function() {
        if (this.activity) {
            this.state = this.activity.get('state');
            const activityCard = this.getActivityCardLayout();
            this.setDateDetails(activityCard.getCreatedDate(this.state));
            this.detailDateTimeTooltip = (this.state === this.STATE_ARCHIVED) ?
                'LBL_DATE_SENT' :
                'LBL_DATE_CREATED';
        }
    },
}) },
"create": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Emails.CreateView
 * @alias SUGAR.App.view.views.BaseEmailsCreateView
 * @extends View.Views.Base.CreateView
 */
({
	// Create View (base)

extendsFrom: 'CreateView',

/**
     * @inheritdoc
     */
    _titleLabel: 'LNK_NEW_ARCHIVE_EMAIL',

/**
     * @inheritdoc
     *
     * Add 'TinymceHtmlEditor' plugin for view.
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], [
            'Tinymce'
        ]);

this._super('initialize', [options]);
    },

/**
     * @inheritdoc
     *
     * Hides or shows the attachments field based on whether or not there are
     * attachments when changes to the attachments are detected.
     *
     * Disables the save button if the attachments exceed the
     * max_aggregate_email_attachments_bytes configuration. Alerts the user, as
     * well. Enables the save button and dismisses the alert if the attachments
     * are under the max_aggregate_email_attachments_bytes configuration
     * configuration.
     */
    bindDataChange: function() {
        if (this.model) {
            this.listenTo(this.model, 'change:attachments_collection', this._hideOrShowTheAttachmentsField);
            this.listenTo(this.model, 'attachments_collection:over_max_total_bytes', function(totalBytes, maxBytes) {
                var readableMax = app.utils.getReadableFileSize(maxBytes);
                var label = app.lang.get('LBL_TOTAL_ATTACHMENT_MAX_SIZE', this.module);
                var saveButton = this.getField(this.saveButtonName);

app.alert.show('email-attachment-status', {
                    level: 'warning',
                    messages: app.utils.formatString(label, [readableMax])
                });

if (saveButton) {
                    saveButton.setDisabled(true);
                }
            });
            this.listenTo(this.model, 'attachments_collection:under_max_total_bytes', function() {
                var saveButton = this.getField(this.saveButtonName);

app.alert.dismiss('email-attachment-status');

if (saveButton) {
                    saveButton.setDisabled(false);
                }
            });
        }

this._super('bindDataChange');
    },

/**
     * @inheritdoc
     *
     * EmailsApi responds with a 500 HTTP status code to report custom errors
     * related to sending email. Other errors in the 400-499 range are
     * handled normally in core.
     */
    saveModel: function(success, error) {
        var onError = _.bind(function(model, e) {
            if (e && e.status == 520) {
                // Mark the error as having been handled
                model.attributes.state = 'Draft';
                e.handled = true;
                this.enableButtons();
                app.alert.show(e.error, {
                    level: 'error',
                    autoClose: false,
                    messages: e.message
                });
            } else if (error) {
                error(model, e);
            }
        }, this);

this._super('saveModel', [success, onError]);
    },

return options;
    },

/**
     * @inheritdoc
     *
     * Sets the title of the page. Hides or shows the attachments field.
     */
    _render: function() {
        this._super('_render');

this.setTitle(app.lang.get(this._titleLabel, this.module));
        this._hideOrShowTheAttachmentsField();

this._resizeEditor();
    },

/**
     * Hides the attachments field if there are no attachments and shows the
     * field if there are attachments.
     */
    _hideOrShowTheAttachmentsField: function() {
        var field = this.getField('attachments_collection');
        var $el;
        var $row;

if (!field) {
            return;
        }

$el = field.getFieldElement();
        $row = $el.closest('.row-fluid');

if (field.isEmpty()) {
            $row.addClass('hidden');
            $row.removeClass('single');
        } else {
            $row.removeClass('hidden');
            $row.addClass('single');
        }
    },

/**
     * @inheritdoc
     *
     * Builds the appropriate success message for saving an archived email.
     */
    buildSuccessMessage: function() {
        return app.lang.get('LBL_EMAIL_ARCHIVED', this.module);
    }
}) },
"activity-card-header": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Emails.ActivityCardHeaderView
 * @alias SUGAR.App.view.views.BaseEmailsActivityCardHeaderView
 * @extends View.Views.Base.ActivityCardHeaderView
 */
({
	// Activity-card-header View (base)

extendsFrom: 'ActivityCardHeaderView',

/**
     * @inheritdoc
     */
    setUsersFields: function() {
        var panel = this.getUsersPanel();

const fieldsToDisplay = ['from', 'to', 'cc', 'bcc'];

fieldsToDisplay.map((name) => {
            this[`${name}Field`] = _.find(panel.fields, (field) =>
                field.name === `${name}_collection`
            );
        });

this.hasAvatarUser = !!this.fromField && !!this.toField;
    }
}) },
"compose-addressbook-list": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Emails.ComposeAddressbookListView
 * @alias SUGAR.App.view.views.BaseEmailsComposeAddressbookListView
 * @extends View.Views.Base.FlexListView
 */
({
	// Compose-addressbook-list View (base)

extendsFrom: 'FlexListView',

/**
     * Changed the address book view to use an independent mass collection
     *
     * The address book collection is not the same as the list view
     * collection and therefore we need to preserve the state of the address
     * book collection through changes to the list view collection.
     * `independentMassCollection: true` allows us to indicate that the
     * collections should not be treated as the same so that we are always
     * adding to the collection instead of resetting with completely new data.
     *
     * @property {boolean}
     */
    independentMassCollection: true,

/**
     * @inheritdoc
     */
    initialize: function(options) {
        var plugins = [
            'ListColumnEllipsis',
            'Pagination',
            'MassCollection'
        ];

this.plugins = _.union(this.plugins || [], plugins);
        this._super('initialize', [options]);
    },

/**
     * Removes the event listeners that were added to the mass collection.
     *
     * @inheritdoc
     */
    unbindData: function() {
        var massCollection = this.context.get('mass_collection');

if (massCollection) {
            this.stopListening(massCollection);
        }

this._super('unbindData');
    },

/**
     * Listens for changes to the list's mass collection. Anytime new rows are
     * selected or deselected, those models are synchronized in the selected
     * recipients collection (`this.model.get('to_collection')`).
     *
     * When the user enters a search term, the list is re-rendered with the
     * results of the search. Any recipients in the result set that have
     * already been selected are checked automatically.
     *
     * @inheritdoc
     */
    _render: function() {
        var massCollection = this.context.get('mass_collection');
        var selectedRecipients;
        var selectedRecipientsInList;

/**
         * Models in the mass collection may be beans for Contacts, Leads, etc.
         * Those beans need to be converted to EmailParticipants beans when
         * they are added to the selected recipients collection.
         *
         * @param {Data|Bean} model
         * @return {Data|Bean}
         */
        function convertModelToEmailParticipant(model) {
            return app.data.createBean('EmailParticipants', {
                _link: 'to',
                parent: {
                    _acl: model.get('_acl') || {},
                    _erased_fields: model.get('_erased_fields') || [],
                    type: model.module,
                    id: model.get('id'),
                    name: model.get('name')
                },
                parent_type: model.module,
                parent_id: model.get('id'),
                parent_name: model.get('name'),
                email_address: _.first(model.get('email')).email_address
            });
        }

this._super('_render');

selectedRecipients = this.model.get('to_collection');

if (massCollection) {
            // Stop listening to changes on the mass collection. Those event
            // handlers will be recreated.
            this.stopListening(massCollection);

// A single row was checked or all rows were checked.
            this.listenTo(massCollection, 'add', function(model) {
                var ep = convertModelToEmailParticipant(model);

selectedRecipients.add(ep);
            });

// A single row was unchecked or all rows were unchecked.
            this.listenTo(massCollection, 'remove', function(model) {
                var existingRecipient = selectedRecipients.findWhere({parent_id: model.get('id')});

selectedRecipients.remove(existingRecipient);
            });

// The mass collection was cleared. Only remove the recipients from
            // the selected recipients collection that are visible in the list
            // view.
            this.listenTo(massCollection, 'reset', function(newCollection, prevCollection) {
                var resetRecipients;
                var selectedRecipientsNotInList = _.difference(prevCollection.previousModels, this.collection.models);

newCollection.add(selectedRecipientsNotInList);
                resetRecipients = _.map(newCollection.models, convertModelToEmailParticipant);
                selectedRecipients.reset(resetRecipients);
            });

if (selectedRecipients.length > 0) {
                // Only add, to the mass collection, recipients that are
                // visible in the list view.
                selectedRecipientsInList = this.collection.filter(function(model) {
                    return !!selectedRecipients.findWhere({parent_id: model.get('id')});
                });
                massCollection.add(selectedRecipientsInList);
            }
        }
    }
}) }
}}
,
"layouts": {
"base": {
"archive-email": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Layouts.Base.Emails.ArchiveEmailLayout
 * @alias SUGAR.App.view.layouts.BaseEmailsArchiveEmailLayout
 * @extends View.Layouts.Base.Emails.CreateLayout
 * @deprecated Use {@link View.Layouts.Base.Emails.CreateLayout} instead.
 */
({
	// Archive-email Layout (base)

extendsFrom: 'EmailsCreateLayout',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        app.logger.warn('View.Layouts.Base.Emails.ArchiveEmailLayout is deprecated. ' +
            'Use View.Layouts.Base.Emails.CreateLayout instead.');

this._super('initialize', [options]);
    }
}) },
"compose-email": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Layouts.Base.Emails.ComposeEmailLayout
 * @alias SUGAR.App.view.layouts.BaseEmailsComposeEmailLayout
 * @extends View.Layouts.Base.Emails.CreateLayout
 */
({
	// Compose-email Layout (base)

extendsFrom: 'EmailsCreateLayout',

/**
     * @inheritdoc
     *
     * Enables the Compose:Send shortcut for views that implement it.
     */
    initialize: function(options) {
        this.shortcuts = _.union(this.shortcuts || [], ['Compose:Send']);
        this._super('initialize', [options]);
    }
}) },
"compose-addressbook": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Layouts.Base.Emails.ComposeAddressbookLayout
 * @alias SUGAR.App.view.layouts.BaseEmailsComposeAddressbookLayout
 * @extends View.Layout
 */
({
	// Compose-addressbook Layout (base)

/**
     * @inheritdoc
     */
    initialize: function(options) {
        app.view.Layout.prototype.initialize.call(this, options);
        this.collection.sync = this.sync;
        this.collection.allowed_modules = ['Accounts', 'Contacts', 'Leads', 'Prospects', 'Users'];
        this.context.on('compose:addressbook:search', this.search, this);
    },
    /**
     * Calls the custom Mail API endpoint to search for email addresses.
     *
     * @param {string} method
     * @param {Data.Bean} model
     * @param {Object} options
     */
    sync: function(method, model, options) {
        var callbacks;
        var url;
        var success;

options = options || {};

// only fetch from the approved modules
        if (_.isEmpty(options.module_list)) {
            options.module_list = ['all'];
        } else {
            options.module_list = _.intersection(this.allowed_modules, options.module_list);
        }

// this is a hack to make pagination work while trying to minimize the affect on existing configurations
        // there is a bug that needs to be fixed before the correct approach (config.maxQueryResult vs. options.limit)
        // can be determined
        app.config.maxQueryResult = app.config.maxQueryResult || 20;
        options.limit = options.limit || app.config.maxQueryResult;

// Is there already a success callback?
        if (options.success) {
            success = options.success;
        }

// Map the response so that the email field data is packaged as an
        // array of objects. The email field component expects the data to be
        // in that format.
        options.success = function(data) {
            if (_.isArray(data)) {
                data = _.map(data, function(row) {
                    row.email = [{
                        email_address: row.email,
                        email_address_id: row.email_address_id,
                        opt_out: row.opt_out,
                        // The email address must be seen as the primary email
                        // address to be shown in a list view.
                        primary_address: true
                    }];

// Remove the properties that are now stored in the nested
                    // email array.
                    delete row.opt_out;
                    delete row.email_address_id;

return row;
                });
            }

// Call the original success callback.
            if (success) {
                success(data);
            }
        };

options = app.data.parseOptionsForSync(method, model, options);
        options.params.erased_fields = true;

callbacks = app.data.getSyncCallbacks(method, model, options);
        this.trigger('data:sync:start', method, model, options);

url = app.api.buildURL('Mail', 'recipients/find', null, options.params);
        app.api.call('read', url, null, callbacks);
    },
    /**
     * Adds the set of modules and term that should be used to search for recipients.
     *
     * @param {Array} modules
     * @param {String} term
     */
    search: function(modules, term) {
        // reset offset to 0 on a search. make sure that it resets and does not update.
        this.collection.fetch({query: term, module_list: modules, offset: 0, update: false});
    }
}) },
"records": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Layouts.Base.Emails.RecordsLayout
 * @alias SUGAR.App.view.layouts.BaseEmailsRecordsLayout
 * @extends View.Layouts.Base.RecordsLayout
 */
({
	// Records Layout (base)

extendsFrom: 'RecordsLayout',

/**
     * @inheritdoc
     *
     * Remove shortcuts that do not apply to Emails module list view
     */
    initialize: function(options) {
        this.shortcuts = _.without(
            this.shortcuts,
            'List:Favorite',
            'List:Follow'
        );

this._super('initialize', [options]);
    }
}) },
"compose": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Layouts.Base.Emails.ComposeLayout
 * @alias SUGAR.App.view.layouts.BaseEmailsComposeLayout
 * @extends View.Layouts.Base.Emails.CreateLayout
 * @deprecated Use {@link View.Layouts.Base.Emails.ComposeEmailLayout} instead.
 */
({
	// Compose Layout (base)

extendsFrom: 'EmailsCreateLayout',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        app.logger.warn('View.Layouts.Base.Emails.ComposeLayout is deprecated. ' +
            'Use View.Layouts.Base.Emails.ComposeEmailLayout instead.');

this._super('initialize', [options]);
    }
}) },
"create": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Layouts.Base.Emails.CreateLayout
 * @alias SUGAR.App.view.layouts.BaseEmailsCreateLayout
 * @extends View.Layouts.Base.CreateLayout
 */
({
	// Create Layout (base)

extendsFrom: 'CreateLayout',

/**
     * @inheritdoc
     *
     * Enables the DragdropSelect2:SelectAll shortcut for views that implement
     * it.
     */
    initialize: function(options) {
        this.shortcuts = _.union(this.shortcuts || [], ['DragdropSelect2:SelectAll']);
        this._super('initialize', [options]);
    }
}) },
"activity-card": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Layouts.Base.Emails.ActivityCardLayout
 * @alias SUGAR.App.view.layouts.BaseEmailsActivityCardLayout
 * @extends View.Layout.Base.ActivityCardLayout
 */
({
	// Activity-card Layout (base)

extendsFrom: 'ActivityCardLayout',

/**
     * Constant representing the state of an email when it is a draft.
     *
     * @property {string}
     */
    STATE_DRAFT: 'Draft',

/**
     * Constant representing the state of an email when it is a draft.
     *
     * @property {string}
     */
    STATE_ARCHIVED: 'Archived',

/**
     * @inheritdoc
     *
     * Hides the Forward, Reply, and Reply All icons if the email card is a draft.
     */
    setCardMenuVisibilities: function() {
        // if the email card is a draft
        if (this.model && this.model.get('state') === this.STATE_DRAFT) {
            this.$('.cabmenu .activity-card-emailaction').hide();
        }
    },

/**
     * Returns the created date for the record based on the state of the email
     *
     * @param state
     * @return {string|null}
     */
    getCreatedDate: function(state) {
        if (state === this.STATE_ARCHIVED) {
            return this.model.get('date_sent');
        } else if (state === this.STATE_DRAFT) {
            return this.model.get('date_entered');
        }
        return '';
    }
}) },
"compose-documents": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Layouts.Base.Emails.ComposeDocumentsLayout
 * @alias SUGAR.App.view.layouts.BaseEmailsComposeDocumentsLayout
 * @extends View.Layout
 * @deprecated Use {@link View.Layouts.Base.SelectionListLayout} instead.
 */
({
	// Compose-documents Layout (base)

/**
     * @inheritdoc
     */
    initialize: function(options) {
        app.logger.warn('View.Layouts.Base.Emails.ComposeDocumentsLayout is deprecated.');

this._super('initialize', [options]);
    }
}) }
}}
,
"datas": {}

},
		"Meetings":{"fieldTemplates": {
"base": {
"enum": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * Enum modifications that are specific to Meeting type field
 * These modifications are temporary until the can (hopefully) be addressed in
 * the Enum field refactoring (SC-3481)
 *
 * @class View.Fields.Base.Meetings.EnumField
 * @alias SUGAR.App.view.fields.BaseMeetingsEnumField
 * @extends View.Fields.Base.EnumField
 */
({
	// Enum FieldTemplate (base)

/**
     * @inheritdoc
     */
    _render: function() {
        if (this.name === 'type') {
            this._ensureSelectedValueInItems();
        }
        this._super('_render');
    },

/**
     * Meeting type is a special case where we want to ensure the selected
     * value is an option in the list. This can happen when User A has
     * an external meeting integration set up (ie. WebEx) and sets WebEx as
     * the type. If User B does not have WebEx set up (only needed to create
     * WebEx meetings, not to join), User B should still see WebEx selected
     * on existing meetings, but not be able to create a meeting with WebEx.
     */
    _ensureSelectedValueInItems: function() {
        var value = this.model.get(this.name),
            meetingTypeLabels;

//if we don't have items list yet or no value previously selected - no work to do
        if (!this.items || _.isEmpty(this.items) || _.isEmpty(value)) {
            return;
        }

//if selected value is not in the list of items, but is in the list of meeting types...
        meetingTypeLabels = app.lang.getAppListStrings('eapm_list');
        if (_.isEmpty(this.items[value]) && !_.isEmpty(meetingTypeLabels[value])) {
            //...add it to the list
            this.items[value] = meetingTypeLabels[value];
        }
    },

/**
     * @inheritdoc
     *
     * Remove options for meeting type field which comes from the vardef - this
     * will force a retrieval of options from the server. Options is in the
     * vardef for meeting type to support mobile which does not have the ability
     * to pull dynamic enum list from the server yet.
     */
    loadEnumOptions: function(fetch, callback) {
        if (this.name === 'type') {
            this.def.options = '';
        }
        this._super('loadEnumOptions', [fetch, callback]);
    }
}) },
"label": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Meetings.LabelField
 * @alias SUGAR.App.view.fields.BaseMeetingsLabelField
 * @extends View.Fields.Base.LabelField
 */
({
	// Label FieldTemplate (base)

/**
     * @inheritdoc
     *
     * Returns the `detail` template for this type of field
     */
    _getFallbackTemplate: function(viewName) {
        return 'detail';
    },
}) },
"record-decor": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Meetings.RecordDecorFields
 * @alias SUGAR.App.view.fields.BaseMeetingsRecordDecorField
 * @extends View.Fields.Base.RecordDecorField
 */
({
	// Record-decor FieldTemplate (base)

extendsFrom: 'RecordDecorField',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['RecurringEvents']);
        this._super('initialize', [options]);
    }
}) },
"launchbutton": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * Button to launch an external meeting
 *
 * @class View.Fields.Base.Meetings.LaunchbuttonField
 * @alias SUGAR.App.view.fields.BaseMeetingsLaunchbuttonField
 * @extends View.Fields.Base.RowactionField
 */
({
	// Launchbutton FieldTemplate (base)

extendsFrom: 'RowactionField',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);
        this.type = 'rowaction';
        this.isHost = (this.def.host === true);
    },

/**
     * @inheritdoc
     *
     * Hide this button if:
     * - Status is not Planned
     * - Type is Sugar (not an external meeting type)
     * - Host button and user does not have permission to start the meeting
     */
    _render: function() {
        if (this.model.get('status') !== 'Planned' ||
            this.model.get('type') === 'Sugar' ||
            (this.isHost && !this._hasPermissionToStartMeeting())
        ) {
            this.hide();
        } else {
            this._setLabel();
            this._super('_render');
            this.show();
        }
    },

/**
     * Check if the user has permission to host the external meeting
     * True if assigned user or an admin for Meetings
     *
     * @return {boolean}
     * @private
     */
    _hasPermissionToStartMeeting: function() {
        return (this.model.get('assigned_user_id') === app.user.id || app.acl.hasAccess('admin', 'Meetings'));
    },

/**
     * Set the appropriate label for this field
     * Use the Start Meeting label for host
     * Use the Join Meeting label otherwise
     *
     * @private
     */
    _setLabel: function() {
        this.label = (this.isHost) ?
            this._getLabel('LBL_START_MEETING') :
            this._getLabel('LBL_JOIN_MEETING');
    },

/**
     * Build the appropriate label based on the meeting type
     *
     * @param {string} labelName Meetings module label
     * @return {string}
     * @private
     */
    _getLabel: function(labelName) {
        var meetingTypeStrings = app.lang.getAppListStrings('eapm_list'),
            meetingType = meetingTypeStrings[this.model.get('type')] ||
                app.lang.get('LBL_MODULE_NAME_SINGULAR', this.module);

return app.lang.get(labelName, this.module, {'meetingType': meetingType});
    },

/**
     * Event to trigger the join/start of the meeting
     * Call the API first to get the host/join URL and determine if user has permission
     */
    rowActionSelect: function() {
        var url = app.api.buildURL('Meetings', 'external', {id: this.model.id});
        app.api.call('read', url, null, {
            success: _.bind(this._launchMeeting, this),
            error: function() {
                app.alert.show('launch_meeting_error', {
                    level: 'error',
                    messages: app.lang.get('LBL_ERROR_LAUNCH_MEETING_GENERAL', this.module)
                });
            }
        });
    },

/**
     * Given the external meeting info retrieved from the API, launch the meeting
     * Display an error if user is not permitted to launch the meeting.
     *
     * @param {Object} externalInfo
     * @private
     */
    _launchMeeting: function(externalInfo) {
        var launchUrl = '';

if (this.disposed) {
            return;
        }

if (this.isHost && externalInfo.is_host_option_allowed) {
            launchUrl = externalInfo.host_url;
        } else if (!this.isHost && externalInfo.is_join_option_allowed) {
            launchUrl = externalInfo.join_url;
        } else {
            // user is not allowed to launch the external meeting
            app.alert.show('launch_meeting_error', {
                level: 'error',
                messages: app.lang.get(this.isHost ? 'LBL_EXTNOSTART_MAIN' : 'LBL_EXTNOT_MAIN', this.module)
            });
            return;
        }

if (!this.isValidExternalUrl(launchUrl)) {
            app.alert.show('launch_meeting_error', {
                level: 'error',
                messages: this._getLabel('LBL_EXTERNAL_MEETING_NO_URL')
            });
            return;
        }
        if (!_.isEmpty(launchUrl)) {
            window.open(launchUrl);
        } else {
            app.alert.show('launch_meeting_error', {
                level: 'error',
                messages: this._getLabel('LBL_EXTERNAL_MEETING_NO_URL')
            });
        }
    },

/**
     * Re-render the join button when the model changes
     */
    bindDataChange: function() {
        if (this.model) {
            this.model.on('change', this.render, this);
        }
    },

isValidExternalUrl: function(url) {
        try {
            const targetUrl = new URL(url);
            return targetUrl.protocol !== 'javascript:';
        } catch (err) {
            return false;
        }
    }
}) }
}}
,
"views": {
"base": {
"dashablerecord": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */

/**
 * @class View.Views.Base.Meetings.DashablerecordView
 * @alias SUGAR.App.view.views.MeetingsDashablerecordView
 * @extends View.Views.Base.DashablerecordView
 */
({
	// Dashablerecord View (base)

extendsFrom: 'DashablerecordView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['RecurringEvents']);
        this._super('initialize', [options]);
    },
}) },
"resolve-conflicts-list": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Meetings.ResolveConflictsListView
 * @alias SUGAR.App.view.views.BaseMeetingsResolveConflictsListView
 * @extends View.Views.Base.ResolveConflictsListView
 */
({
	// Resolve-conflicts-list View (base)

extendsFrom: 'ResolveConflictsListView',

extendsFrom: 'RecordView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['EditAllRecurrences', 'AddAsInvitee', 'RecurringEvents']);
        this._super('initialize', [options]);
    }
}) },
"create": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Meetings.CreateView
 * @alias SUGAR.App.view.views.MeetingsCreateView
 * @extends View.Views.Base.CreateView
 */
({
	// Create View (base)

extendsFrom: 'CreateView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['AddAsInvitee', 'ReminderTimeDefaults']);
        this._super('initialize', [options]);
    }
}) },
"activity-card-header": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Meetings.ActivityCardHeaderView
 * @alias SUGAR.App.view.views.BaseMeetingsActivityCardHeaderView
 * @extends View.Views.Base.ActivityCardHeaderView
 */
({
	// Activity-card-header View (base)

extendsFrom: 'ActivityCardHeaderView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);
        this.setUsersFields();
    },

/**
     * @inheritdoc
     *
     * Do not set user fields as that will be set after activity fetch
     */
    setUsersPanel: function() {
        this.setUsersTemplate();
    },

/**
     * @inheritdoc
     */
    setUsersFields: function() {
        this.setInvitees();
    }
}) },
"create-nodupecheck": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Meetings.CreateNodupecheckView
 * @alias SUGAR.App.view.views.MeetingsCreateNodupecheckView
 * @extends View.Views.Base.CreateNodupecheckView
 */
({
	// Create-nodupecheck View (base)

extendsFrom: 'CreateNodupecheckView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['AddAsInvitee', 'ReminderTimeDefaults']);
        this._super('initialize', [options]);
    }
}) }
}}
,
"layouts": {}
,
"datas": {
"base": {
"model": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class Model.Datas.Base.MeetingsModel
 * @alias SUGAR.App.model.datas.BaseMeetingsModel
 * @extends Model.Bean
 */
({
	// Model Data (base)

plugins: ['VirtualCollection']
}) }
}}

},
		"Tasks":{"fieldTemplates": {}
,
"views": {
"base": {
"activity-card-header": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Tasks.ActivityCardHeaderView
 * @alias SUGAR.App.view.views.BaseTasksActivityCardHeaderView
 * @extends View.Views.Base.ActivityCardHeaderView
 */
({
	// Activity-card-header View (base)

extendsFrom: 'ActivityCardHeaderView',

/**
     * @inheritdoc
     */
    setUsersFields: function() {
        const panel = this.getUsersPanel();
        this.userField = _.find(panel.fields, (field) => field.name === 'assigned_user_name');

this.hasAvatarUser = !!this.userField;
    }
}) }
}}
,
"layouts": {}
,
"datas": {}

},
		"Calendar":{"fieldTemplates": {
"base": {
"colorpicker": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Calendar.ColorpickerField
 * @alias SUGAR.App.view.fields.BaseCalendarColorpickerField
 * @extends View.Fields.Base.ColorpickerField
 */
 ({
	// Colorpicker FieldTemplate (base)

/**
    * @override
    */
    initialize: function(options) {
        this._super('initialize', [options]);

this.once('render', function() {
            this.listenTo(this.model, 'change:color', _.bind(function() {
                let field = this.$('.hexvar[rel=colorpicker]');
                let preview = this.$('.color-preview');

if (this.action == 'edit') {
                    var value = field.val();
                    preview.css('backgroundColor', value);
                }
            }, this));
        }, this);
    },
    /**
    * @override
    */
    _render: function() {
        this._super('_render');

if (this.action != 'edit') {
            this.fillIconBackground();
        }
    },
    /**
     * Sets the background color for the colorpicker icon.
     */
    fillIconBackground: function() {
        if (this.action != 'edit') {
            if (typeof this.value == 'string' && this.value != '') {
                this.$('[data-content=color-picker-icon]').css({
                    'background-color': this.value
                });
            }
        }
    }
}) },
"field-enum": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.FieldEnumField
 * @alias SUGAR.App.view.fields.BaseFieldEnumField
 * @extends View.Fields.Base.BaseFieldEnumField
 */
({
	// Field-enum FieldTemplate (base)

extendsFrom: 'BaseEnumField',

/**
     * @inheritdoc
     */
    bindDataChange: function() {
        this._super('bindDataChange');

if (this.model) {
            //Check if the record is copied
            if (typeof this.context.get('copiedFromModelId') === 'string') {
                this._updateFieldDropdown();
            } else {
                this.listenTo(this.model, 'sync', function() {
                    this._updateFieldDropdown();
                }.bind(this));
            }

this.listenTo(this.model, 'change:calendar_module', _.bind(this._updateFieldDropdown, this));
        }
    },

/**
     * Update list of items
     */
    _updateFieldDropdown: function() {
        if (this.name == 'dblclick_event') {
            var dropdownOptions = {};
            dropdownOptions['detail:self:id'] = app.lang.get('LBL_NAVIGATE_TO_RECORD', 'Calendar'),
                dropdownOptions['detail-newtab:self:id'] = app.lang.get('LBL_NAVIGATE_TO_RECORD_NEW_TAB', 'Calendar');
            dropdownOptions['edit:self:id'] = app.lang.get('LBL_OPEN_DRAWER_FOR_EDIT', 'Calendar');

var moduleMetadata = app.metadata.getModule(this.model.get('calendar_module'));
            if (moduleMetadata) {
                var fieldsMetadata = moduleMetadata.fields;
                _.each(fieldsMetadata, _.bind(function(fieldMetadata) {
                    var moduleName = this.model.get('calendar_module');
                    if (fieldMetadata.type == 'relate' &&
                       typeof fieldMetadata.module == 'string' && typeof fieldMetadata.id_name == 'string') {
                        dropdownOptions['detail:' + fieldMetadata.module + ':' + fieldMetadata.id_name] =
                            app.lang.get('LBL_NAVIGATE_TO_RECORD', 'Calendar') +
                            ' (' + app.lang.get(fieldMetadata.vname, moduleName) + ')';
                        dropdownOptions['detail-newtab:' + fieldMetadata.module + ':' + fieldMetadata.id_name] =
                            app.lang.get('LBL_NAVIGATE_TO_RECORD_NEW_TAB', 'Calendar') +
                            ' (' + app.lang.get(fieldMetadata.vname, moduleName) + ')';
                        dropdownOptions['edit:' + fieldMetadata.module + ':' + fieldMetadata.id_name] =
                            app.lang.get('LBL_OPEN_DRAWER_FOR_EDIT', 'Calendar') +
                            ' (' + app.lang.get(fieldMetadata.vname, moduleName) + ')';

fieldMetadata.id;
                    }
                }, this));
            }
            this.items = dropdownOptions;
        } else {
            if (!_.isArray(this.fieldDefs.field_types_allowed)) {
                return;
            }

var fieldsMetadata = [];
            if (this.model.get('calendar_module') == '' || _.isUndefined(this.model.get('calendar_module'))) {
                return;
            }
            var calendarModule = this.model.get('calendar_module');

var moduleMetadata = app.metadata.getModule(calendarModule);

if (moduleMetadata) {
                fieldsMetadata = moduleMetadata.fields;

this.items = dropdownOptions;
            }
        }

this.render();
    },

/**
     * Load enum options will not be needed on this field type
     */
    loadEnumOptions: function(fetch, callback, error) {
    }
}) },
"htmleditable_tinymce": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.CalendarHtmleditableTinymceField
 * @alias SUGAR.App.view.fields.BaseCalendarHtmleditableTinymceField
 * @extends View.Fields.Base.BaseHtmleditableTinymceField
 */
({
	// Htmleditable_tinymce FieldTemplate (base)

/**
     * Fields which should not be available to insert in the template
     */
    badFields: [
        'deleted',
        'team_count',
        'user_name',
        'user_hash',
        'password',
        'is_admin',
        'mkto_id',
        'parent_type'
    ],

specialFields: [
        'created_by_name',
        'modified_by_name',
        'primary_contact_name',
        'duration_minutes',
        'duration_hours',
        'entry_source',
        'email1'
    ],

/**
     * Field types which should not be available to insert in the template
     */
    badFieldTypes: [
        'link',
        'id',
        'collection',
        'widget',
        'html',
        'htmleditable_tinymce',
        'image',
        'teamset',
        'team_list',
        'password',
        'file'
    ],

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

// The plugin 'insertfield' needs to be aplied again to show fields of the current module
        this.listenTo(this.model, 'change:calendar_module', _.bind(this.render, this));
    },

/**
     * Return submenu items
     *
     * @param editor
     * @return {Array}
     */
    getSubmenu: function(editor) {
        var module = this.model.get('calendar_module');
        var fields = app.metadata.getModule(module).fields;
        fields = _.filter(fields, function(field) {
            return _.contains(this.specialFields, field.name) || (
                !_.isEmpty(field.name) &&
                !_.isEmpty(field.vname) &&
                !_.contains(this.badFields, field.name) &&
                !_.contains(this.badFieldTypes, field.type) &&
                !_.contains(this.badFieldTypes, field.dbType) &&
                field.link_type !== 'relationship_info' &&
                (
                    _.isUndefined(field.studio) ||
                    (_.isObject(field.studio) || field.studio == 'true' || field.studio == true)
                ) &&
                field.source !== 'non-db' &&
                typeof field.processes == 'undefined'
            );
        });

fields.push({
            name: 'event_timestamp',
            vname: app.lang.getModString('LBL_INSERTFIELD_EVENT_TIMESTAMP', 'Calendar')
        });

var insertOptions = [];

fields = _.sortBy(fields, function sortFieldsAlphabetically(field) {
            var fieldLabel = app.lang.get(field.vname, module);

if (_.isString(fieldLabel)) {
                return fieldLabel.toLowerCase();
            } else {
                return '';
            }
        });

_.each(
            fields,
            function(field) {
                var fieldLabel = app.lang.get(field.vname, module);

var option = {
                    type: 'menuitem',
                    text: fieldLabel,
                    onAction: () =>
                        editor.insertContent(`{::${field.name}::}`),
                };

insertOptions.push(option);
            }, this
        );

return insertOptions;
    },

/**
     * Add custom button to the UI
     *
     * @param editor
     */
    addCustomButtons: function(editor) {
        if (!app.acl.hasAccess('view', this.model.get('calendar_module'))) {
            return;
        }
        if (_.isEmpty(this.model.get('calendar_module'))) {
            return;
        }

editor.ui.registry.addMenuButton('insertfield_calendar', {
            text: app.lang.getModString('LBL_INSERTFIELD', 'Calendar'),
            onAction: () => {},
            fetch: (callback) =>
                callback(this.getSubmenu(editor)),
        });
    },

/**
     * @override
     */
    getTinyMCEConfig: function() {
        var getConfig = this._super('getTinyMCEConfig') || {};

getConfig.toolbar += ' insertfield_calendar';

if (this.fieldDefs.name == 'ical_event_template') {
            getConfig.toolbar = 'insertfield_calendar';
        }
        return getConfig;
    }
}) }
}}
,
"views": {
"base": {
"add-calendarcontainer": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Calendar.AddCalendarcontainerView
 * @alias SUGAR.App.view.views.BaseCalendarAddCalendarcontainerView
 * @extends View.Views.Base.View
 */
 ({
	// Add-calendarcontainer View (base)

className: 'calendarAddContainer',

/**
     * @override
     */
    _render: function() {
        this._super('_render');

let calendarParams = {
            def: {
                name: 'calendar',
                type: 'relate',
                custom_module: 'Calendar',
                ext2: 'Calendar',
                id_name: 'id',
                module: 'Calendar',
                quicksearch: 'enabled',
                required: false,
                source: 'non-db'
            },
            view: this,
            viewName: 'edit',
            model: this.model
        };
        const dashletSource = this.context.get('dashletSource');
        const mainCalendarSource = this.context.get('mainCalendarSource');

const calendarModules = [app.controller.context.get('module')];

if (dashletSource !== true && mainCalendarSource !== true) {
            calendarParams.def = _.extend(calendarParams.def, {
                initial_filter: 'available_calendars',
                initial_filter_label: 'LBL_CALENDAR_AVAILABLE_CALENDARS',
                filter_populate: {
                    'calendar_module':  {
                        $in: calendarModules
                    }
                }
            });
        }

this.calendarField = app.view.createField(calendarParams);
        this.calendarField.render();
        this.$('[data-content=calendar-field]').html(this.calendarField.$el);

this.listenTo(this.calendarField.model, 'change:calendar', _.bind(function() {
            this.context.trigger('calendar:change', this.calendarField.model.get('id'));
        }, this));
    }
}) },
"main-panel": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Calendar.MainPanelView
 * @alias SUGAR.App.view.views.BaseCalendarMainPanelView
 * @extends View.Views.Base.View
 */
 ({
	// Main-panel View (base)

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.events = this.events || {};
        this.events['click span[name=addCalendar]'] = 'addCalendar';

this.componentStorageKey = 'main-panel';
        this.keyToStoreCalendarConfigurations = app.Calendar.utils.buildUserKeyForStorage(this.componentStorageKey);

this.miniCalendar = null;

this.delaySelectMyCalendarsTime = 100;

this._super('initialize', [options]);

this.listenTo(this.context, 'scheduler:view:changed', _.bind(this.updateMiniCalendar, this));
    },

/**
     * Update the mini calendar
     */
    updateMiniCalendar: function() {
        let schedulerView = this.layout.getComponent('scheduler');
        let startDate = schedulerView.scheduler.date();

this.miniCalendar.value(startDate);
    },

/**
     * @override
     */
    bindDataChange: function() {
        this.model.on('change:myCalendars', this.reloadCalendar, this);
        this.model.on('change:otherCalendars', this.reloadCalendar, this);
    },

/**
     * @inheritdoc
     */
    _render: function() {
        let calendarsSaved = app.user.lastState.get(this.keyToStoreCalendarConfigurations);
        if (typeof calendarsSaved == 'undefined') {
            this.selectMyCalendars();
        }

calendarsSaved = calendarsSaved || {};

const myConfigurations = calendarsSaved.myCalendars || [];
        const otherConfigurations = calendarsSaved.otherCalendars || [];

this.model.set({
            myCalendars: myConfigurations,
            otherCalendars: otherConfigurations
        });

this._super('_render');

if (typeof kendo == 'object') {
            this.culturePreferences();
            this.loadMiniCalendar();
            this.calculateCalendarPosition();
        } else {
            $.getScript('cache/include/javascript/sugar_grp_calendar.js', _.bind(function() {
                this.culturePreferences();
                this.loadMiniCalendar();
                this.calculateCalendarPosition();
            }, this));
        }
    },

/**
     * Select my calendars
     */
    selectMyCalendars: function() {
        if (typeof this.delaySelectingMyCalendars !== 'undefined') {
            clearTimeout(this.delaySelectingMyCalendars);
            this.delaySelectingMyCalendars = null;
        }

/**
     * Load mini calendar
     */
    loadMiniCalendar: function() {
        const userDatePref = app.Calendar.utils.getKendoDateMapping(
            app.user.getPreference('datepref'), 'fullVerboseMonth'
        );

this.$('[data-content=mini-calendar]').kendoCalendar({
            change: _.bind(function changeMiniCalendar() {
                let schedulerView = this.layout.getComponent('scheduler');

if (schedulerView.scheduler._selectedView.name === 'month') {
                    schedulerView.scheduler.view('day');
                    schedulerView.$el.find('.k-dropdown').trigger('change');
                }

let dateSelected = new Date(moment(this.miniCalendar.current()).format('YYYY/MM/DD'));
                schedulerView.scheduler.date(dateSelected);
                schedulerView.scheduler.select({
                    events: [],
                    start: dateSelected,
                    end: dateSelected,
                    groupIndex: 0
                });

let loadedEventsStart = new Date(schedulerView._eventsLoaded.startDate);
                let loadedEventsEnd = new Date(schedulerView._eventsLoaded.endDate);

if (loadedEventsStart > dateSelected || loadedEventsEnd < dateSelected) {
                    schedulerView.trigger('calendar:reload');
                }
            }, this),
            footer: kendo.format(`{0: dddd, ${userDatePref}}`,  new Date())
        });

this.$('.k-icon.k-i-arrow-60-right')
            .removeClass('k-icon')
            .removeClass('k-i-arrow-60-right')
            .addClass('sicon')
            .addClass('sicon-chevron-right');
        this.$('.k-icon.k-i-arrow-60-left')
            .removeClass('k-icon')
            .removeClass('k-i-arrow-60-left')
            .addClass('sicon')
            .addClass('sicon-chevron-left');

this.miniCalendar = this.$('[data-content=mini-calendar]').data('kendoCalendar');
    },

/**
     * Calculate calendar position
     *
     * When refresh on this page, we might get into here before kendo css loaded,
     * so no positioninig possible.
     * solution is to generate a resonable amount of tries before quit
     */
    calculateCalendarPosition: function() {
        if (this.$el.css('background-color') == 'rgba(0, 0, 0, 0)') {
            /**
             * A count down for number of tries. Wait for slow networks
             */
            let resonableLimit = 50;
            /**
             * Try interval
             */
            const timeToWait = 100;

const waitForCssToLoad = setInterval(function() {
                if (this.$el.css('background-color') != 'rgba(0, 0, 0, 0)') {
                    this.positionMiniCalendar();
                    clearInterval(waitForCssToLoad);
                }

if (resonableLimit == 0) {
                    clearInterval(waitForCssToLoad);
                }
                resonableLimit--;
            }.bind(this), timeToWait);
        } else {
            this.positionMiniCalendar();
        }
    },

/**
     * Position mini calendar
     */
    positionMiniCalendar: function() {
        this.$('[data-content=mini-calendar]').css('width', '100%');
        this.$('[data-content=mini-calendar] .k-calendar-view').css('width', '100%');
    },

/**
     * Add other calendar drawer
     */
    addCalendar: function() {
        app.drawer.open(
            {
                layout: 'add-calendar',
                context: {
                    module: 'Calendar',
                    mixed: true,
                    mainCalendarSource: true
                }
            },
            _.bind(function closeCalendarAdd(calendar) {
                if (typeof calendar == 'undefined') {
                    return;
                }

calendar.selected = true;
                let otherCalendarsList = this.model.get('otherCalendars');
                otherCalendarsList.push(calendar);

app.user.lastState.set(this.keyToStoreCalendarConfigurations, {
                    myCalendars: this.model.get('myCalendars'),
                    otherCalendars: this.model.get('otherCalendars')
                });

this.model.trigger('change:otherCalendars');

const field = this.getField('otherCalendars');
                field.render();
            }, this)
        );
    },

/**
     * Reload calendar
     */
    reloadCalendar: function() {
        let scheduler = this.layout.getComponent('scheduler');
        if (scheduler.$el.html() == '') {
            return;
        }
        const myConfigurations = this.model.get('myCalendars') || [];
        const otherConfigurations = this.model.get('otherCalendars') || [];

const otherConfigurationsSelected = _.filter(otherConfigurations, function(configuration) {
            return configuration.selected;
        });

const calendarsList = myConfigurations.concat(otherConfigurationsSelected);
        const calendarsModels = _.map(calendarsList, function(calendarData) {
            return app.data.createBean('Calendar', calendarData);
        });
        scheduler.calendars = app.data.createBeanCollection('Calendar', calendarsModels);

scheduler.trigger('calendar:reconfigure');
    },

/**
     * Setup the culture preference
     */
    culturePreferences: function() {
        const weekStart = parseInt(app.user.getPreference('first_day_of_week'), 10);
        kendo.culture('en-US');

if (weekStart) {
            kendo.culture().calendar.firstDay = weekStart;
        }
    },

/**
     * @inheritdoc
     */
    _dispose: function() {
        if (this.miniCalendar) {
            this.miniCalendar.destroy();
            this.miniCalendar = null;
        }

this.context.off('scheduler:view:changed');

this._super('_dispose');
    }
}) },
"add-filter": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Calendar.AddFilterView
 * @alias SUGAR.App.view.views.BaseCalendarAddFilterView
 * @extends View.Views.Base.View
 */
({
	// Add-filter View (base)

/**
     * Converts the input field to a select2 field and adds the module filter for refining the search.
     *
     * @override
     */
    _render: function() {
        this._super('_render');
        this.buildModuleFilterList();
        this.buildFilter();
    },

/**
     * Builds the list of allowed modules to provide the data to the select2 field.
     */
    buildModuleFilterList: function() {
        const allowedModules = this.collection.allowed_modules;

this._moduleFilterList = [
            {id: this._allModulesId, text: app.lang.get('LBL_MODULE_ALL')}
        ];

/**
     * Converts the input field to a select2 field and initializes the selected module.
     */
    buildFilter: function() {
        let $filter = this.getFilterField();
        if ($filter.length > 0) {
            $filter.select2({
                data: this._moduleFilterList,
                allowClear: false,
                multiple: false,
                minimumResultsForSearch: -1,
                formatSelection: _.bind(this.formatModuleSelection, this),
                formatResult: _.bind(this.formatModuleChoice, this),
                dropdownCss: {width: 'auto'},
                dropdownCssClass: 'search-filter-dropdown',
                initSelection: _.bind(this.initSelection, this),
                escapeMarkup: function(m) {
                    return m;
                },
                width: 'off'
            });

$filter.off('change');
            $filter.on('change', _.bind(this.handleModuleSelection, this));
            this._selectedModule = this._selectedModule || this._allModulesId;
            $filter.select2('val', this._selectedModule);
        }
    },

/**
     * Gets the filter DOM field.
     *
     * @return {jQuery} DOM Element
     */
    getFilterField: function() {
        return this.$('input.select2');
    },

/**
     * Gets the module filter DOM field.
     *
     * @return {jQuery} DOM Element
     */
    getModuleFilter: function() {
        return this.$('span.choice-filter-label');
    },

/**
     * Destroy the select2 plugin.
     */
    unbind: function() {
        let $filter = this.getFilterField();
        if ($filter.length > 0) {
            $filter.off();
            $filter.select2('destroy');
        }
        this._super('unbind');
    },

/**
     * Performs a search once the user has entered a term.
     *
     * @param {Object} evt
     */
    throttledSearch: _.debounce(function(evt) {
        const newSearch = this.$(evt.currentTarget).val();
        if (this._currentSearch !== newSearch) {
            this._currentSearch = newSearch;
            this.applyFilter();
        }
    }, 400),

/**
     * Initialize the module selection with the value for all modules.
     *
     * @param {jQuery} el
     * @param {Function} callback
     */
    initSelection: function(el, callback) {
        if (el.is(this.getFilterField())) {
            const module = _.findWhere(this._moduleFilterList, {id: el.val()});
            callback({id: module.id, text: module.text});
        }
    },

/**
     * Format the selected module to display its name.
     *
     * @param {Object} item
     * @return {string}
     */
    formatModuleSelection: function(item) {
        // update the text for the selected module
        this.getModuleFilter().text(item.text);
        return '<span class=\'select2-choice-type\'>' +
            app.lang.get('LBL_MODULE') +
            '<i class=\'sicon sicon-caret-down\'></i></span>';
    },

/**
     * Format the choices in the module select box.
     *
     * @param {Object} option
     * @return {string}
     */
    formatModuleChoice: function(option) {
        return '<div><span class=\'select2-match\'></span>' + option.text + '</div>';
    },

/**
     * Handler for when the module filter dropdown value changes, either via a click or manually calling jQuery's
     * .trigger('change') event.
     *
     * @param {Object} evt jQuery Change Event Object
     * @param {string} overrideVal (optional) ID passed in when manually changing the filter dropdown value
     */
    handleModuleSelection: function(evt, overrideVal) {
        const module = overrideVal || evt.val || this._selectedModule || this._allModulesId;
        // only perform a search if the module is in the approved list
        if (!_.isEmpty(_.findWhere(this._moduleFilterList, {id: module}))) {
            this._selectedModule = module;
            this.getFilterField().select2('val', this._selectedModule);
            this.getModuleFilter().css('cursor', 'pointer');
            this.applyFilter();
        }
    },

/**
     * Triggers an event that makes a call to search the user/team and filter the data set.
     */
    applyFilter: function() {
        const searchAllModules = (this._selectedModule === this._allModulesId);
        // pass an empty array when all modules are being searched
        const module = searchAllModules ? [] : [this._selectedModule];
        // determine if the filter is dirty so the 'clearQuickSearchIcon' can be added/removed appropriately
        const isDirty = !_.isEmpty(this._currentSearch);

this._toggleClearQuickSearchIcon(isDirty);
        this.context.trigger('calendar:add:search', module, this._currentSearch);
    },

/**
     * Append or remove an icon to the quicksearch input so the user can clear the search easily.
     *
     * @param {boolean} addIt TRUE if you want to add it, FALSE to remove
     */
    _toggleClearQuickSearchIcon: function(addIt) {
        if (addIt && !this.$('.add-on.sicon-close')[0]) {
            this.$('.filter-view.search').append('<i class=\'add-on sicon sicon-close\'></i>');
        } else if (!addIt) {
            this.$('.add-on.sicon-close').remove();
        }
    },

/**
     * Clear input
     */
    clearInput: function() {
        let $filter = this.getFilterField();
        this._currentSearch = '';
        this._selectedModule = this._allModulesId;
        this.$('.search-name').val(this._currentSearch);
        if ($filter.length > 0) {
            $filter.select2('val', this._selectedModule);
        }
        this.applyFilter();
    }
}) },
"bwc": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @inheritdoc
 */
({
	// Bwc View (base)

convertToSidecarUrl: function(href) {
        var module = this.moduleRegex.exec(href);

module = (_.isArray(module)) ? module[1] : null;
        if (!module) {
            return '';
        }
        //Route links for BWC modules through bwc/ route
        //Remove any './' nonsense in existing hrefs
        href = href.replace(/^.*\//, '');

return 'bwc/' + href;
    }
}) },
"module-menu": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Module-menu View (base)

/**
     * @inheritdoc
     */
    populateMenu: function() {
        this.populate('calendars');
    },

/**
     * @inheritdoc
     */
    populate: function(tplName, filter, limit) {
        app.api.call('read', app.api.buildURL('Calendar/modules'), {}, {
            success: _.bind(function(data) {
                this.resetCollection(tplName);

_.each(data.modules, function(moduleInfo, module) {
                    let collection = this.getCollection(tplName);
                    let createLabel = '';

if (module === 'KBContents') {
                        createLabel = app.lang.getModString('LNK_NEW_KBCONTENT_TEMPLATE', module);
                    } else {
                        let createLabelKey = 'LNK_NEW_' + moduleInfo.objName.toUpperCase();
                        createLabel = app.lang.get(createLabelKey, module);

if (createLabel === createLabelKey) {
                            createLabelKey = 'LNK_NEW_RECORD';
                            createLabel = app.lang.getModString(createLabelKey, module);
                        }
                    }

const moduleItem = {
                        module: module,
                        label: createLabel
                    };
                    collection.push(moduleItem);
                }, this);

this._renderPartial(tplName);
            }, this)
        });
    },

/**
     * Reset collection
     *
     * @param {string} tplName The name of the partial template which uses this collection
     */
    resetCollection: function(tplName) {
        this._collections[tplName] = [];
    },

/**
     * @inheritdoc
     */
    getCollection: function(tplName) {
        if (!this._collections[tplName]) {
            this._collections[tplName] = [];
        }

return this._collections[tplName];
    },

/**
     * @inheritdoc
     */
    _renderPartial: function(tplName, options) {
        if (this.disposed || !this.isOpen()) {
            return;
        }
        options = options || {};

let tpl = app.template.getView(this.name + '.' + tplName, this.module) ||
            app.template.getView(this.name + '.' + tplName);

const modules = this.getCollection(tplName);

let $placeholder = this.$('[data-container="' + tplName + '"]');
        let $old = $placeholder.nextUntil('.divider');

//grab the focused element's route (if exists) for later re-focusing
        const focusedRoute = $old.find(document.activeElement).data('route');

//replace the partial using newly updated modules collection
        $old.remove();
        $placeholder.after(tpl(_.extend({'modules': modules}, options)));

//if there was a focused element previously, restore its focus
        if (focusedRoute) {
            const $new = $placeholder.nextUntil('.divider');
            const focusSelector = '[data-route="' + focusedRoute + '"]';
            const $newFocus = $new.find(focusSelector);
            if ($newFocus.length > 0) {
                $newFocus.focus();
            }
        }
    }
}) },
"add-calendars-bottom": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Calendar.AddCalendarsBottomView
 * @alias SUGAR.App.view.views.BaseCalendarAddCalendarsBottomView
 * @extends View.Views.Base.ListBottomView
 */
({
	// Add-calendars-bottom View (base)

extendsFrom: 'ListBottomView',

/**
     * Assign proper label for 'show more' link.
     * Label should be 'More recipients...'.
     */
    setShowMoreLabel: function() {
        this.showMoreLabel = app.lang.getModString('LBL_CALENDAR_ADD_SHOW_MORE_RECIPIENTS', this.module);
    }
}) },
"add-calendars": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Calendar.AddCalendarcontainerView
 * @alias SUGAR.App.view.views.BaseCalendarAddCalendarcontainerView
 * @extends View.Views.Base.FlexListView
 */
({
	// Add-calendars View (base)

extendsFrom: 'FlexListView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        var plugins = [
            'ListColumnEllipsis',
            'Pagination',
        ];

this.plugins = _.union(this.plugins || [], plugins);
        this._super('initialize', [options]);

this.context.on('change:selection_model', this._selectUserOrTeamAndClose, this);
        this.context.on('calendar:change', this._selectCalendarAndClose, this);

this.events = {
            'click .single': 'triggerCheck'
        };
        this.newCalendar = {
            calendarId: '',
            userId: '',
            teamId: ''
        };
    },

/**
     * Closes the drawer passing the selected model attributes to the callback if calendar is set
     *
     * @param {Object} context
     * @param {Data.Bean} selectionModel The selected calendar configuration.
     */
    _selectUserOrTeamAndClose: function(context, selectionModel) {
        var selectedModule = selectionModel.get('_module');

if (selectedModule == 'Users') {
            this.newCalendar.userId = selectionModel.get('id');
            this.newCalendar.teamId = '';
        } else if (selectedModule == 'Teams') {
            this.newCalendar.userId = '';
            this.newCalendar.teamId = selectionModel.get('id');
        }

if (!_.isEmpty(this.newCalendar.calendarId)) {
            app.drawer.close(this.newCalendar);
        }
    },

/**
     * Select calendar and eventually close the drawer
     *
     * @param {string} calendarId
     */
    _selectCalendarAndClose: function(calendarId) {
        this.newCalendar.calendarId = calendarId;

if (!_.isEmpty(this.newCalendar.userId) || !_.isEmpty(this.newCalendar.teamId)) {
            app.drawer.close(this.newCalendar);
        }
    },

/**
     * Trigger check
     *
     * @param {Object} event
     */
    triggerCheck: function(event) {
        var checkbox = $(event.currentTarget).find('[data-check=one]');
        checkbox[0].click();
    }
}) },
"add-headerpane": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Calendar.CalendarAddHeaderpaneView
 * @alias SUGAR.App.view.views.BaseCalendarAddHeaderpaneView
 * @extends View.Views.Base.HeaderpaneView
 */
({
	// Add-headerpane View (base)

extendsFrom: 'HeaderpaneView',

events: {
        'click [name=cancel_button]': '_cancel'
    },

/**
     * Close the drawer.
     *
     * @private
     */
    _cancel: function() {
        app.drawer.close();
    }
}) },
"scheduler": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Calendar.SchedulerView
 * @alias SUGAR.App.view.views.BaseCalendarSchedulerView
 * @extends View.Views.Base.View
 */
 ({
	// Scheduler View (base)

className: 'calendar-scheduler',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._initVars();
        this._super('initialize', [options]);

this.positionLegend = _.bind(this.positionLegend, this);

this.setSchedulerEvents();
    },

/**
     * Initialize parameters
     */
    _initVars: function() {
        /**
         * A reference to the Kendo Scheduler component
         */
        this.scheduler = null;

/**
         * Reference to toolbar SubView
         */
        this.toolbarView = null;

/**
         * Reference to popul used to confirm email sending
         */
        this.confirmationPopupView = null;

/**
         * The event focused at a given moment
         */
        this._selectedState = {};

/**
         * Calendar definitions fetched for calendars in this component.
         * Contains all fields from db
         */
        this.calendarDefs = [];
        /**
         * Raw events got from the last fetch
         * The start and end dates show the interval of the fetch
         */
        this._eventsLoaded = {
            startDate: '',
            endDate: '',
            events: []
        };

/**
         * Calendar wrapper id. Unique identifier of the scheduler
         */
        this._schedulerCssId = 'scheduler_' + this.cid;

/**
         * Event deleted. Store it at this level to have access to it anywhere needed until it's gone
         */
        this._deletedEvent = {};

/**
         * Flage to indicate the action in progress. Store it at this level to have access to it everywhere
         */
        this._isDeleteAction = false;

/**
         * Raw views which can be seen in the calendar.
         */
        this._allPossibleViews = ['day', 'workWeek', 'week', 'expandedMonth', 'agenda', 'timeline', 'monthSchedule'];

this.DAY_VIEW = 'day';
        this.WEEK_VIEW = 'week';
        this.WORK_WEEK_VIEW = 'workWeek';
        this.EXPANDED_MONTH_VIEW = 'expandedMonth';
        this.AGENDA_VIEW = 'agenda';
        this.TIMELINE_VIEW = 'timeline';
        this.MONTH_SCHEDULE_VIEW = 'monthSchedule';

/**
         * Calendar's views
         */
        this.views = this.setupCalendarViews();

/**
         * URI to get events
         */
        this.eventsURL = 'Calendar/getEvents';

/**
         * Number of next months to load events
         */
        this.nrOfNextMonthsToLoadEvents = 1;

/**
         * Calendars to show on this view
         */
        this.calendars = app.data.createBeanCollection('Calendar', this.options.context.get('calendars'));

/**
         * Location of the scheduler: main, record or records
         */
        this.location = this.options.context.get('location') || '';

/**
         * Options for kendo scheduler
         */
        this.customKendoOptions = this.options.context.get('customKendoOptions') || {};

/**
         * Flag whether to load calendars or not
         */
        this.options.skipFetch = this.options.context.get('skipFetch') || false;

this.keyToStoreCalendarConfigurations = this.options.context.get('keyToStoreCalendarConfigurations');
        this.keyToStoreCalendarView = app.Calendar.utils.buildUserKeyForStorage(this.location);
        this.keyToStoreCalendarBusinessHours = 'calendarBusinessHours';

this._setBusinessHours();
    },

/**
     * Adds events this component will listen for
     */
    setSchedulerEvents: function() {
        this.listenTo(app.events, 'calendar:reload', _.bind(this.loadData, this));
        this.listenTo(this, 'calendar:reload', _.bind(this.loadData, this));
        this.listenTo(this, 'calendar:reconfigure', _.bind(this._reconfigureCalendar, this));
        this.listenTo(this.context, 'change:calendars', _.bind(this.updateCalendars, this));
        this.listenTo(this.context, 'button:cancel:click', _.bind(this.cancelSave, this));
        this.listenTo(this.context, 'button:save:click', _.bind(this.saveRecord, this));
        this.listenTo(this.context, 'button:saveAndSendInvites:click', _.bind(this.saveRecordAndSendInvites, this));

this.events = {
            'click .previewEvent': '_previewEvent'
        };
    },

/**
     * Setup calendar views
     *
     * @return {Array}
     */
    setupCalendarViews: function() {
        let views = this.options.context.get('availableViews');
        if (typeof views == 'undefined' || views.length == 0) {
            views = app.utils.deepCopy(this._allPossibleViews); //make sure to use a copy
        }

let defaultView = this.options.context.get('defaultView');
        if (typeof defaultView == 'undefined' || defaultView == '') {
            defaultView = views[0];
        }

views = _.map(views, _.bind(function(view) {
            let newView = {
                type: this.getViewType(view),
                title: this.getViewTitle(view),
                selected: false,
                schedulerViewName: view,
                showWorkHours: true,
            };

if (view === this.MONTH_SCHEDULE_VIEW) {
                newView.showWorkHours = false;
            }
            if (defaultView === view) {
                newView.selected = true;
            }
            return newView;
        }, this));

return views;
    },

/**
     * Update Calendars
     *
     * Useful when loading the main scheduler. Calendar configurations are set
     * on the main-scheduler layout so we need to update default vars and reload the scheduler
     */
    updateCalendars: function() {
        this.location = this.options.context.get('location') || '';
        this.customKendoOptions = this.options.context.get('customKendoOptions') || {};
        this.options.skipFetch = this.options.context.get('skipFetch') || false;
        this.views = this.setupCalendarViews();
        this.calendars = app.data.createBeanCollection('Calendar', this.options.context.get('calendars'));
        this.keyToStoreCalendarConfigurations = this.options.context.get('keyToStoreCalendarConfigurations');
        this.keyToStoreCalendarView = app.Calendar.utils.buildUserKeyForStorage(this.location);

if (_.isNull(this.scheduler)) {
            this.once('calendar:initialized', _.bind(this._reconfigureCalendar, this));
        } else {
            this._reconfigureCalendar();
        }
    },

/**
     * Cancel save record
     */
    cancelSave: function() {
        this.offlineRefreshDataSource();
    },

/**
     * Save record
     *
     * @param {Object} clonedEvent Event
     */
    saveRecord: function(clonedEvent) {
        if (_.isNull(this.eventInChange)) {
            app.logger.error('Failed to get event in change');
            return;
        }

if (clonedEvent) {
            this.updateEvent(clonedEvent);
        }
    },

/**
     * Save record and send invites
     *
     * @param {Object} clonedEvent
     */
    saveRecordAndSendInvites: function(clonedEvent) {
        if (clonedEvent) {
            clonedEvent.sendInvites = true;
            this.saveRecord(clonedEvent);
        }
    },

/**
     * Populate calendar
     *
     * @param  {Object} res Full response from api
     */
    populateCalendarWithData: function(res) {
        if (this.disposed) {
            return;
        }

let kendoEvents = [];
        this._eventsLoaded.events = [];
        this._eventsLoaded.startDate = res.startDate;
        this._eventsLoaded.endDate = res.endDate;
        this._usersInEventsLoaded = res.users;

if (!_.isEmpty(res)) {
            _.each(
                res.data,
                function(row) {
                    let rowData = {
                        recordId: row.id,
                        calendarId: row.calendarId,
                        id: row.calendarId + '_' + row.id,
                        eventUsers: row.eventUsers,
                        name: DOMPurify.sanitize(row.title, {
                            FORBID_ATTR: ['style'],
                            FORBID_TAGS: ['style'],
                        }),
                        start: moment(row.start).toDate(),
                        end: moment(row.end).toDate(),
                        title: DOMPurify.sanitize(row.title, {
                            FORBID_ATTR: ['style'],
                            FORBID_TAGS: ['style'],
                        }),
                        description: row.description !== undefined ?
                            DOMPurify.sanitize(row.description, {
                                FORBID_ATTR: ['style'],
                                FORBID_TAGS: ['style'],
                            }) :
                            undefined,
                        isAllDay: row.isAllDay,
                        module: row.module,
                        event_tooltip: DOMPurify.sanitize(row.event_tooltip, {
                            FORBID_ATTR: ['style'],
                            FORBID_TAGS: ['style'],
                        }),
                        day_event_template: DOMPurify.sanitize(row.day_event_template, {
                            FORBID_ATTR: ['style'],
                            FORBID_TAGS: ['style'],
                        }),
                        week_event_template: DOMPurify.sanitize(row.week_event_template, {
                            FORBID_ATTR: ['style'],
                            FORBID_TAGS: ['style'],
                        }),
                        month_event_template: DOMPurify.sanitize(row.month_event_template, {
                            FORBID_ATTR: ['style'],
                            FORBID_TAGS: ['style'],
                        }),
                        agenda_event_template: DOMPurify.sanitize(row.agenda_event_template, {
                            FORBID_ATTR: ['style'],
                            FORBID_TAGS: ['style'],
                        }),
                        timeline_event_template: DOMPurify.sanitize(row.timeline_event_template, {
                            FORBID_ATTR: ['style'],
                            FORBID_TAGS: ['style'],
                        }),
                        schedulermonth_event_template: DOMPurify.sanitize(row.schedulermonth_event_template, {
                            FORBID_ATTR: ['style'],
                            FORBID_TAGS: ['style'],
                        }),
                        dbclickRecordId: row.dbclickRecordId,
                        color: _.escape(row.color),
                        assignedUserName: row.assignedUserName,
                        assignedUserId: row.assignedUserId,
                        invitees: row.invitees
                    };

const start = moment(row.start);
                    const end = moment(row.end);
                    const duration = moment.duration(end.diff(start));
                    if (duration.asDays() >= 1) {
                        rowData.isAllDay = true;
                    }

if (start.format() === end.format()) {
                        rowData.isAllDay = true;
                    }

//fix kendo not showing events made on date types spanning
                    //on expected cells
                    let schedulerViewType = this.scheduler._selectedView.name;
                    schedulerViewType = this.getViewType(schedulerViewType);
                    if (schedulerViewType === this.EXPANDED_MONTH_VIEW) {
                        let calendarDef = _.find(this.calendarDefs, function(calendarDef) {
                            return calendarDef.calendarId === row.calendarId;
                        });
                        let calendarModule = calendarDef.module;
                        let moduleMetadata = app.metadata.getModule(calendarModule);
                        let fieldsMetadata = moduleMetadata.fields;

let endDef = fieldsMetadata[calendarDef.end_field];
                        if (typeof endDef != 'undefined') {
                            let endDefFieldType = endDef.dbType || endDef.dbtype || endDef.type;
                            if (endDefFieldType == 'date') {
                                rowData.end = moment(rowData.end).set('minute', 1);
                                rowData.end = new Date(rowData.end);
                            }
                        }
                    }
                    const kendoSchedulerEvent = new kendo.data.SchedulerEvent(rowData);

this._eventsLoaded.events.push(app.utils.deepCopy(rowData));
                    kendoEvents.push(kendoSchedulerEvent);
                }, this
            );
        }
        if (this.scheduler) {
            this._syncedEvents = app.utils.deepCopy(kendoEvents);
            this.scheduler._selectedView.options.dataSource.data(kendoEvents);

this.updateUsersLegend(res);
            this.positionLegend();
        }
    },

/**
     * Generates and adds on DOM the list of users
     *
     * @param {Object} data Response from the database
     */
    updateUsersLegend: function(data) {
        let list = '';
        _.each(data.users, function(user) {
            const userColor = app.Calendar.utils.pastelColor(user.id);

list += '<li><div><span class="userDot" style="background-color:' + _.escape(userColor) +
             '"></span> ' + DOMPurify.sanitize(user.name, {
                    FORBID_ATTR: ['style'],
                    FORBID_TAGS: ['style'],
                }) + '</div></li>';
        });

this.$('.usersLegend ul').html(list);
    },

/**
     * @inheritdoc
     */
    loadData: function(options) {
        if (!this.scheduler) {
            return;
        }

const url = app.api.buildURL(this.eventsURL);
        let data = {};

if (this.calendars instanceof app.data.beanCollection) {
            data.calendarConfigurations = this.calendars.compile();
        } else {
            data.calendarConfigurations = this.calendars;
        }

if (typeof this.listFilter !== 'undefined' && !_.isEmpty(this.listFilter)) {
            data.listFilter = this.listFilter;
        }
        if (typeof this.filterModule !== 'undefined' && !_.isEmpty(this.filterModule)) {
            data.filterModule = this.filterModule;
        }

//show loading alert
        const visibleAlerts = app.alert.getAll();
        if (!visibleAlerts['loading-calendar-events'] && !visibleAlerts['data:sync:process']) {
            app.alert.show('loading-calendar-events', {
                level: 'process',
                messages: app.lang.get('LBL_LOADING')
            });
        }

//set start/end dates based on the current view
        const schedulerView = this.scheduler.view();
        if (schedulerView) {
            data.startDate = moment(schedulerView.startDate()).format();
            data.endDate = moment(schedulerView.endDate()).set({
                hour: 23,
                minute: 59,
                second: 59
            }).format();

app.api.call('create', url, data, retrieveEventsOptions);
        }
    },

/**
     * Reconfigure the calendar
     */
    _reconfigureCalendar: function() {
        const params = {
            calendars: this.calendars.compile()
        };
        if (params.calendars.length == 0) {
            this.calendarDefs = [];
            this.loadData();
            return;
        }
        app.api.call('create', app.api.buildURL('Calendar/getCalendarDefs'), params, {
            success: _.bind(function(calendarDefs) {
                if (this.disposed) {
                    return;
                }

this.calendarDefs = calendarDefs;

_.each(calendarDefs, function(calendarDef) {
                    if (this.scheduler) {
                        this.scheduler.resources[0].dataSource.add({
                            text: DOMPurify.sanitize(calendarDef.name, {
                                FORBID_ATTR: ['style'],
                                FORBID_TAGS: ['style'],
                            }),
                            value: DOMPurify.sanitize(calendarDef.id, {
                                FORBID_ATTR: ['style'],
                                FORBID_TAGS: ['style'],
                            }),
                            color: _.escape(calendarDef.color)
                        });
                    }
                }, this);

this.loadData();
            }, this),
            error: _.bind(function(data) {
                // refresh token if it has expired
                app.error.handleHttpError(data, {});
            }, this),
        });
    },

/**
     * Update templates
     *
     * Add circles on each event then put them on DOM
     */
    _updateTemplates: function() {
        if (this.disposed) {
            return;
        }

let cells;
        let viewName = this.scheduler.view().name;
        const viewType = this.scheduler.view().type;
        if (viewType === this.EXPANDED_MONTH_VIEW) {
            viewName = 'Month';
        } else if (viewName === this.MONTH_SCHEDULE_VIEW) {
            viewName = 'Scheduler';
        }

if (viewName === this.AGENDA_VIEW) {
            cells = this.$('div.k-task .event-template');
        } else {
            cells = this.$('div[role=gridcell] > .event-template');
        }
        let prependCircle = _.bind(function(htmlContent, event) {
            //add text color based on backround color
            if (event.color) {
                const isWhiteColor = app.Calendar.utils.whiteColor(event.color);
                let color;

if (isWhiteColor) {
                    color = '#000000';
                } else {
                    color = '#FFFFFF';
                }
                htmlContent = '<div class="templateHtmlWrapper" style="color:' + _.escape(color) + ';">' +
                    '<div class="calendarEventBody">' + DOMPurify.sanitize(htmlContent, {
                        FORBID_ATTR: ['style'],
                        FORBID_TAGS: ['style'],
                    }) + '</div></div>';

if (viewName === this.AGENDA_VIEW) {
                    this.$('div.k-task[data-uid=' + event.uid + ']').each(function() {
                        $(this).css('background-color', _.escape(event.color));
                    });
                }

const assignedUserColor = app.Calendar.utils.pastelColor(event.assignedUserId);
                htmlContent = $(htmlContent).prepend('<div class="previewEvent" data-module=' +
                    _.escape(event.module) +
                    ' data-record=' +  _.escape(event.dbclickRecordId) + ' rel="tooltip" data-bs-placement="bottom"' +
                    ' aria-haspopup="true" aria-expanded="false" data-original-title="' +
                    _.escape(DOMPurify.sanitize(event.assignedUserName, {
                        FORBID_ATTR: ['style'],
                        FORBID_TAGS: ['style'],
                    })) +
                    '"><span class="userBar" style="background-color:' +
                    _.escape(assignedUserColor) + '"></span></div>');

_.each(event.invitees, function(invitee, idx) {
                    if (invitee.id !== event.assignedUserId && idx < 3) {
                        const inviteeColor = app.Calendar.utils.pastelColor(invitee.id);
                        const inviteeName = invitee.name;

htmlContent = $(htmlContent).prepend('<div class="previewEvent" data-module=' +
                            _.escape(event.module) +
                        ' data-record=' +  _.escape(event.dbclickRecordId) +
                            ' rel="tooltip" data-bs-placement="bottom"' +
                        ' aria-haspopup="true" aria-expanded="false" data-original-title="' +
                            _.escape(DOMPurify.sanitize(inviteeName, {
                                FORBID_ATTR: ['style'],
                                FORBID_TAGS: ['style'],
                            })) +
                        '"><span class="userBar" style="background-color:' +
                            _.escape(inviteeColor) + '"></span></div>');
                    }
                }, this);
            }
            return htmlContent;
        }, this);

_.each(cells, function(cell) {
            let uid;
            if (viewName === this.AGENDA_VIEW) {
                uid = $(cell)
                    .parent()
                    .parent()
                    .data('uid');
            } else {
                uid = $(cell)
                    .parent()
                    .data('uid');
            }

let event = this.scheduler.occurrenceByUid(uid);
            switch (viewName) {
                case this.DAY_VIEW:
                    $(cell).html(prependCircle(event.day_event_template, event));
                    break;
                case this.WEEK_VIEW:
                case this.WORK_WEEK_VIEW:
                    $(cell).html(prependCircle(event.week_event_template, event));
                    break;
                case this.EXPANDED_MONTH_VIEW:
                case 'Month':
                    $(cell).html(prependCircle(event.month_event_template, event));
                    break;
                case this.AGENDA_VIEW:
                    $(cell).html(prependCircle(event.agenda_event_template, event));
                    break;
                case this.TIMELINE_VIEW:
                    $(cell).html(prependCircle(event.timeline_event_template, event));
                    break;
                case this.MONTH_SCHEDULE_VIEW:
                case 'Scheduler':
                    $(cell).html(prependCircle(event.schedulermonth_event_template, event));
                    break;
            }
        }, this);

this.addTooltips();
    },

/**
     * Add a preview of the record when the circle is clicked
     *
     * @param {Object} e
     */
    _previewEvent: function(e) {
        const module = e.currentTarget.dataset.module;
        const recordId = e.currentTarget.dataset.record;
        const model = app.data.createBean(module, {id: recordId});

const windowWidth = window.innerWidth;
        const mainPanelWidth = app.controller.layout.$('.calendar-main-panel').width();
        const previewPanelWidth = app.controller.layout.$('.preview-pane').width();
        const calendarWidth = windowWidth - mainPanelWidth - previewPanelWidth;
        const intialCalendarWidth = windowWidth - mainPanelWidth;

app.events.trigger('preview:render', model, null);

app.controller.layout.$('.preview-pane').removeClass('hide');
        app.controller.layout.$('.scheduler-component').css('width', calendarWidth);
        this.scheduler.resize();

app.controller.layout.$('.closeSubdetail').on('click', _.bind(function() {
            app.controller.layout.$('.preview-pane').addClass('hide');
            app.controller.layout.$('.scheduler-component').css('width', intialCalendarWidth);
            this.scheduler.resize();
        }, this));
    },

/**
     * Add tooltips to the events
     */
    addTooltips: function() {
        let kendoTooltip = this.$('.k-scheduler-content').data('kendoTooltip');
        if (kendoTooltip) {
            kendoTooltip.hide();
            kendoTooltip.destroy();
        }

const tooltip = app.template.getView('scheduler.tooltip', 'Calendar')();

if (this.scheduler.view().name === this.AGENDA_VIEW) {
            this.$('.k-scheduler-content').kendoTooltip({
                    filter: '.k-task',
                    content: tooltip,
                    position: 'left',
                    autoHide: true,
                    showAfter: 500,
                    callout: false,
                    show: _.bind(this._setTooltipContent, this),
                    animation: {
                        close: {
                            duration: 0
                        }
                    }
                }
            );
        } else {
            this.$('.k-scheduler-header, .k-scheduler-content').kendoTooltip({
                    filter: 'div[role=gridcell]',
                    content: tooltip,
                    position: 'right',
                    autoHide: true,
                    showAfter: 500,
                    callout: false,
                    show: _.bind(this._setTooltipContent, this),
                    width: 200,
                    animation: {
                        close: {
                            duration: 0
                        }
                    }
                }
            );
        }
    },

/**
     * Set the tooltip content
     *
     * @param {Object} tooltip
     */
    _setTooltipContent: function(tooltip) {
        if (tooltip.sender.target().hasClass('k-event-drag-hint') || this._isDeleteAction) {
            tooltip.sender.hide();
        } else {
            const target = tooltip.sender.target();
            const uid = target.data('uid');
            let event = this.scheduler.occurrenceByUid(uid);

const assignedUserColor = app.Calendar.utils.pastelColor(event.assignedUserId);

let time = '<span>' + moment(event.start).format('ddd, MMMM D');
            if (moment(event.start).format('ddd MMMM') != moment(event.end).format('ddd MMMM')) {
                time += ' - ' + moment(event.end).format('ddd, MMMM D');
            }
            time += '</span><span>' + moment(event.start).format('h:mma') + ' - ' +
                moment(event.end).format('h:mma') + '</span>';

if (event.module == 'Calls' || event.module == 'Meetings') {
                tooltip.sender.content.find('.event-tooltip .tooltip-attendees').removeClass('hidden');
                tooltip.sender.content.find('.event-tooltip .tooltip-description').removeClass('hideBottomBorder');

const acceptedInvitees = _.filter(event.invitees, function(invitee) {
                    return invitee.acceptStatus == 'accept';
                });

const inviteesAcceptedTemplate = app.lang.getModString('LBL_INVITEES_ACCEPTED', 'Calendar', {
                    count: acceptedInvitees.length
                });

let attendees = inviteesAcceptedTemplate;
                let moreAttendees = '';

_.each(acceptedInvitees, function(attendee, idx) {
                    const attendeeColor = app.Calendar.utils.pastelColor(attendee.id);

const newAttendee = '<div class="attendee"><span class="userDot" style="background-color:' +
                        _.escape(attendeeColor) + '"></span><span>' + DOMPurify.sanitize(attendee.name, {
                            FORBID_ATTR: ['style'],
                            FORBID_TAGS: ['style'],
                        }) + '</span></div>';

if (idx < 2) {
                        attendees += newAttendee;
                    } else {
                        moreAttendees += newAttendee;
                    }
                });

if (acceptedInvitees.length > 2) {
                    const moreToLoad = acceptedInvitees.length - 2;
                    const moreToLoadLabel = app.lang.getModString('LBL_MORE_INVITEES_TO_LOAD', 'Calendar', {
                        count: moreToLoad
                    });
                    moreAttendees = '<a data-toggle="collapse" role="button" href="#attendeeCollapse-' +
                        event.id + '">' + moreToLoadLabel + '</a> <div class="collapse" id="attendeeCollapse-' +
                        event.id + '">' + moreAttendees + '</div>';

attendees += moreAttendees;
                }

tooltip.sender.content.find('.event-tooltip .tooltip-attendees .category-container').html(attendees);
                tooltip.sender.content.find('#attendeeCollapse-' + event.id).on('show.bs.collapse', _.bind(function() {
                    tooltip.sender.content.find('a[data-toggle=collapse]').addClass('hide');
                }, this));
            } else {
                tooltip.sender.content.find('.event-tooltip .tooltip-attendees').addClass('hidden');
                tooltip.sender.content.find('.event-tooltip .tooltip-description').addClass('hideBottomBorder');
            }

const sanitizedEventName = DOMPurify.sanitize(event.name, {
                FORBID_ATTR: ['style'],
                FORBID_TAGS: ['style'],
            });
            const sanitizedEventTooltip = DOMPurify.sanitize(event.event_tooltip, {
                FORBID_ATTR: ['style'],
                FORBID_TAGS: ['style'],
            });
            tooltip.sender.content.find('.event-tooltip .tooltip-header .category-container').html(sanitizedEventName);
            tooltip.sender.content.find('.event-tooltip .tooltip-time .category-container').html(time);
            tooltip.sender.content.find('.event-tooltip .tooltip-description .category-container')
                .html(sanitizedEventTooltip);
            tooltip.sender.content.find('.event-tooltip .tooltip-header .userDot')
                .css('background-color', _.escape(assignedUserColor));
            tooltip.sender.content.parent().css('box-shadow', 'none');
            tooltip.sender.content.parent().parent().css('margin-left', '0px');
        }
    },

/**
     * Render
     *
     * Render this view in DOM
     * and eventually start initializing Kendo Scheduler
     *
     * @inheritdoc
     */
    _render: function() {
        this._super('_render');

const params = {
            calendars: this.calendars.compile()
        };

if (params.calendars.length == 0 || (_.isNull(this.scheduler) && this.options.skipFetch)) {
            this.calendarDefs = [];
            this._createCalendar();

return;
        }

app.api.call('create', app.api.buildURL('Calendar/getCalendarDefs'), params, {
            success: _.bind(function(calendarDefs) {
                this.calendarDefs = calendarDefs;

this._createCalendar();
            }, this),
            error: _.bind(function(data) {
                // refresh token if it has expired
                app.error.handleHttpError(data, {});
            }, this),
        });
    },

/**
     * Initializes Kendo Scheduler component
     */
    _initializeScheduler: function() {
        let rawResources = [];
        _.each(this.calendarDefs, function(calendar) {
            rawResources.push({
                text: calendar.id,
                value: calendar.id,
                color: _.escape(calendar.color)
            });
        });

let resourcesDS = new kendo.data.DataSource({
            data: rawResources
        });

//considering the autoBind is set to false, we have to manually fetch resources ds
        resourcesDS.fetch();

let kendoOptions = _.extend({}, {
            date: new Date(),
            timezone: app.user.attributes.preferences.timezone,
            currentTimeMarker: {
                useLocalTimezone: false
            },
            startTime: new Date('2000/1/1 00:00 AM'),
            toolbar: ['pdf'],
            messages: {
                pdf: app.lang.getModString('LBL_CALENDAR_PDF_EXPORT', 'Calendar'),
                showWorkDay: app.lang.getModString('LBL_CALENDAR_SHOW_FULL_DAY', 'Calendar')
            },
            pdf: {
                fileName: app.lang.getModString('LBL_CALENDAR_CALENDAR_EXPORT', 'Calendar') + '.pdf',
                landscape: false,
                calculatePaperSize: true,
                calendarIdRef: this._schedulerCssId
            },
            pdfExport: _.debounce(this._pdfExport, 0),
            eventTemplate: '<div class="event-template"></div>',
            workDays: [1,2,3,4,5],
            views: this.views,
            dataSource: new kendo.data.SchedulerDataSource({
                data: []
            }),
            autoBind: false,
            selectable: true,
            editable: {
                confirmation: false, //default delete confirmation,
                resize: true,
                move: true
            },
            edit: _.bind(this._eventDoubleClickHandler, this),
            moveStart: _.bind(this._moveResizeStartHandler, this),
            moveEnd: _.debounce(_.bind(this._moveResizeHandler, this), 0),
            resizeStart: _.bind(this._moveResizeStartHandler, this),
            resizeEnd: _.debounce(_.bind(this._moveResizeHandler, this), 0),
            remove: _.bind(this._deleteHandler, this),
            dataBound: _.bind(this._updateTemplates, this),
            navigate: _.bind(this._navigateHandler, this),
            workDayStart: this._getBusinessHours('start'),
            workDayEnd: this._getBusinessHours('end'),
            resources: [
                {
                    field: 'calendarId',
                    title: 'calendarId',
                    dataSource: resourcesDS
                },
            ],
            majorTimeHeaderTemplate: this._getMajorTimeHeaderTemplate(),
        }, this.customKendoOptions);

const selectedView = _.find(this.views, (view) => view.selected).type;
        if (selectedView !== this.MONTH_SCHEDULE_VIEW) {
            kendoOptions.dateHeaderTemplate = this._getDateHeaderTemplate(
                _.find(this.views, (view) => view.selected).type
            );
        }

if (selectedView !== this.EXPANDED_MONTH_VIEW) {
            kendoOptions.selectedDateFormat = this._getSelectedDateFormat(selectedView);
        }

//finally, kendo initialization
        this.$('#' + this._schedulerCssId).kendoScheduler(kendoOptions);
        this.scheduler = this.$('#' + this._schedulerCssId)
            .data('kendoScheduler');

this.toolbarView = app.view.createView({
            name: 'scheduler-toolbar',
            type: 'scheduler-toolbar',
            module: 'Calendar',
        });
        this.toolbarView.views = this.views;
        this.toolbarView.formattedDate = this.scheduler._model.formattedDate;
        this.toolbarView.formattedShortDate = this.scheduler._model.formattedShortDate;

this.toolbarView.render();

this.$('.k-scheduler-toolbar.k-toolbar').html(this.toolbarView.$el.html());

this.scheduler._model.bind('change', _.bind(function(e) {
            if (e.field == 'formattedDate') {
                this.$('.k-lg-date-format').html(e.sender.source.formattedDate);
                this.$('.k-sm-date-format').html(e.sender.source.formattedShortDate);
            }
        }, this));

this.scheduler.wrapper.on('mousedown.kendoScheduler', _.debounce(_.bind(function(e) {
            if (e.target.hasAttribute('role') && e.target.getAttribute('role') === 'gridcell') {
                this.context.trigger('scheduler:view:changed');
            }
        }, this), 0));

//we need to wait until the dashlet is loaded in order to have a context menu
        _.defer(_.bind(function() {
            this.$('#' + this._schedulerCssId).find('.k-dropdown').select2({
                minimumResultsForSearch: -1,
            });

$('#context_menu_' + this._schedulerCssId).kendoContextMenu({
                filter: '.k-scheduler-table',
                showOn: 'dblclick',
                open: _.bind(this._contextMenuOpen, this),
                select: _.bind(this._contextMenuSelect, this),
                target: '#' + this._schedulerCssId
            });
        }, this));

this.trigger('calendar:initialized');
    },

/**
     * PDF export
     *
     * @param {Object} e
     */
    _pdfExport: function(e) {
        const calendarFont = app.user.getPreference('sugarpdf_pdf_calendar_font_name_data');
        const notoSansFont = 'NotoSansSC-Regular';
        const currentFont = this.wrapper.css('font-family');
        let cssFontFamily = '';

if (calendarFont === notoSansFont) {
            cssFontFamily += notoSansFont;
        }

//refreshLayout adds heights to elements that needs to be removed
        _.defer(_.bind(function() {
            this.wrapper.find('.k-scheduler-content').css('height', '');
            this.wrapper.find('.k-scheduler-times').css('height', '');
            this.wrapper.find('.k-scheduler-table').css('height', '');
        }, this));

e.sender.wrapper.css('font-family', cssFontFamily);

e.promise.done(_.bind(function() {
            this.element.css('font-family', currentFont);
        }, this));
    },

/**
     * Returns if the calendar is created
     *
     * @return {boolean}
     */
    _calendarIsCreated: function() {
        if (typeof kendo == 'undefined' || !(this.scheduler instanceof kendo.ui.Scheduler)) {
            return false;
        }
        return true;
    },

/**
     * Bind legend position event
     */
    _bindLegendEvent: function() {
        $(window).on('resize', this.positionLegend);
    },

/**
     * Position the legend dropdown
     */
    positionLegend: function() {
        if (_.isEmpty(this.$el)) {
            return;
        }
        _.each(this.$('.dropdown-menu'), function(dropdownMenu) {
            const menuWidth = $(dropdownMenu).width();
            const parentWidth = $(dropdownMenu).parent().width();
            const parentOffset = $(dropdownMenu).parent().offset();
            const leftOffSet = 27;
            const topOffset = 30;
            $(dropdownMenu).css({
                left: parentOffset.left - menuWidth + parentWidth - leftOffSet,
                top: parentOffset.top + topOffset
            });
        },this);
    },

/**
     * Create the Kendo component
     */
    _createCalendar: function() {
        if (this._calendarIsCreated()) {
            return;
        }

this.views = this.setupCalendarViews();
        if (typeof kendo === 'object') {
            this.culturePreferences();
            this._initializeScheduler();
            this._bindExportEvent();
            this._bindLegendEvent();
        } else {
            $.getScript('cache/include/javascript/sugar_grp_calendar.js', _.bind(function() {
                this.culturePreferences();
                this._initializeScheduler();
                this._bindExportEvent();
                this._bindLegendEvent();
            }, this));
        }
    },

/**
     * Open drawer to edit the record
     *
     * @param {Object} data
     */
    _editHandlerSuccessCallback: function(data) {
        const module = data.module;
        app.drawer.open(
            {
                layout: 'create',
                context: {
                    layoutName: 'create',
                    create: true,
                    module: data.module,
                    model: data
                }
            },
            _.bind(function() {
                this.loadData();

if (this.isPageWithSubpanels()) {
                    this.refreshSubpanels(module);
                }
            },this)
        );
    },

/**
     * Trigger a route change to the specified url
     *
     * @param {string} url
     */
    _navigate: function(url) {
        _.defer(function() {
            app.router.navigate(url, {
                trigger: true
            });
        });
    },

/**
     * Handler for double click event
     *
     * @param {Object} e
     */
    _eventDoubleClickHandler: function(e) {
        e.preventDefault();

this._selectedState = e.event;
        let moduleMeta = app.metadata.getModule(e.event.module);
        let url;
        let model;

if (e.event.isNew()) {
            return;
        }

let actionOnDbClick = this.getActionOnDbClick(e.event);

if (_.isEmpty(e.event.dbclickRecordId)) {
            const moduleName = app.lang.getModuleName(e.event.module);
            const relatedModule = app.lang.getModuleName(actionOnDbClick.module);
            const message = app.lang.getModString('LBL_NAVIGATE_TO_RECORD_WARNING', 'Calendar', {
                relatedModule: relatedModule.toLowerCase(),
                moduleName: moduleName.toLowerCase()
            });

app.alert.show('navigation-record', {
                level: 'confirmation',
                messages: message,
                autoClose: false,
                onConfirm: _.bind(function() {
                    this.navigateToRecord(e.event);
                }, this),
            });
            return;
        }

if (actionOnDbClick.action == 'detail') {
            if (moduleMeta.isBwcEnabled) {
                url = '#bwc/index.php?module=' + actionOnDbClick.module + '&action=DetailView&record=' +
                    e.event.dbclickRecordId;
                this._navigate(url);
            } else {
                url = '#' + actionOnDbClick.module + '/' + e.event.dbclickRecordId;
                this._navigate(url);
            }
        } else if (actionOnDbClick.action == 'detail-newtab') {
            if (moduleMeta.isBwcEnabled) {
                url = app.utils.getSiteUrl() + '#bwc/index.php?module=' + actionOnDbClick.module +
                    '&action=DetailView&record=' + e.event.dbclickRecordId;
                window.open(url);
            } else {
                url = app.utils.getSiteUrl() + '#' + actionOnDbClick.module + '/' + e.event.dbclickRecordId;
                window.open(url);
            }
        } else if (actionOnDbClick.action == 'edit') {
            moduleMeta = app.metadata.getModule(actionOnDbClick.module);

if (this.isAllowed('allow_update', e.event)) {
                if (moduleMeta.isBwcEnabled) {
                    url = '#bwc/index.php?module=' + actionOnDbClick.module + '&action=EditView&record=' +
                         e.event.dbclickRecordId;
                    this._navigate(url);
                } else {
                    model = app.data.createBean(actionOnDbClick.module, {
                        id: e.event.dbclickRecordId,
                        module: actionOnDbClick.module
                    });
                    model.fetch({
                        params: {
                            view: 'record'
                        },
                        success: _.bind(this._editHandlerSuccessCallback, this),
                        error: function() {
                            app.alert.show('error-fetch-model', {
                                level: 'error',
                                messages: app.lang.getModString('LBL_CALENDAR_ERROR_FETCH_MODEL', 'Calendar'),
                                autoClose: false
                            });
                        }
                    });
                }
            } else {
                app.alert.show('not-allowed', {
                    level: 'warning',
                    messages: app.lang.getModString('LBL_CALENDAR_NOT_ALLOWED_TO_EDIT', 'Calendar'),
                    autoClose: true
                });
            }
        }
    },

/**
     * Get informations about double click action of this event
     *
     * @param {Object} event
     * @return {Object}
     */
    getActionOnDbClick: function(event) {
        let dblClick;
        let calendar;

const currentUserType = app.user.get('type');
        const calendarId = event.calendarId;

calendar = _.find(this.calendarDefs, function(calendar) {
            return calendar.calendarId === calendarId;
        });
        dblClick = calendar.dblclick_event.split(':');
        if (dblClick.length == 3) {
            dblClick = {
                action: dblClick[0],
                module: dblClick[1],
                id: dblClick[2] == 'id' ? event.recordId : event.dbclickRecordId
            };
        }

if (dblClick.module == 'self') {
            dblClick.module = calendar.module;
        }

if (currentUserType == 'user' && dblClick.module == 'Users') {
            dblClick.module = 'Employees';
        }

return dblClick;
    },

/**
     * Build model with proper default fields
     *
     * @param {Object} calendarDef
     * @param {Object} view
     * @param {Object} state
     * @return {Data.Bean} A new instance of a bean.
     */
    buildModelWithProperDefaultFields: function(calendarDef, view, state) {
        let model;
        const startField = calendarDef.start_field;
        let dataPrefill = {
            module: calendarDef.module
        };

dataPrefill[startField] = moment(state.start).format();

let endField = calendarDef.end_field;

//in Calls & Meetings modules, end date is calculated based on durations
        if (calendarDef.module == 'Calls' || calendarDef.module == 'Meetings') {
            dataPrefill.duration_minutes = 30;
            endField = 'date_end';
        }

if (!_.isEmpty(endField)) {
            dataPrefill[endField] = moment(state.start).add(30, 'minutes').format();
        }

let moduleMetadata = app.metadata.getModule(calendarDef.module);
        let fieldsMetadata = moduleMetadata.fields;

model = app.data.createBean(calendarDef.module, dataPrefill);

return model;
    },

/**
     * Open list with available calendars
     *
     * @param {Object} e
     */
    _contextMenuOpen: function(e) {
        //on Agenda View edit event is not triggered so we have to trigger it here
        const schedulerView = this.scheduler.view();
        if (schedulerView.name === this.AGENDA_VIEW) {
            const uid = $(e.event.target)
                .closest('.k-task')
                .data('uid');

const event = this.scheduler.occurrenceByUid(uid);
            this.scheduler.editEvent(event);
            e.preventDefault();
            return;
        }

const state = this._selectedState;
        if (state && typeof state.isNew == 'function' && state.isNew()) {
            let menu = e.sender;
            menu.remove('.contextCalendarItem');

//get all calendar defs of My Calendars in this scheduler. Only one per module
            let calendars;
            if (this.location == 'dashboard') {
                calendars = this.calendarDefs;
            } else {
                calendars = this.context.get('myAvailableCalendars');
            }
            const availableCalendars = _.filter(calendars, function(calendar) {
                return app.acl.hasAccess('view', calendar.module) && calendar.allow_create;
            });

_.each(
                availableCalendars,
                function(calendar) {
                    let text = '';

if (calendar.module === 'KBContents') {
                        text = app.lang.getModString('LNK_NEW_KBCONTENT_TEMPLATE', calendar.module);
                    } else {
                        let createLabel = 'LNK_NEW_' + calendar.objName.toUpperCase();
                        text = app.lang.get(createLabel, calendar.module);

if (text === createLabel) {
                            createLabel = 'LNK_NEW_RECORD';
                            text = app.lang.getModString(createLabel, calendar.module);
                        }
                    }
                    menu.append([{
                        text: text,
                        cssClass: 'contextCalendarItem', //used to remove old items
                        uid: calendar.module
                    }]);
                }, this
            );
        } else {
            e.preventDefault();
        }
    },

/**
     * Context menu select
     *
     * @param {Object} e
     */
    _contextMenuSelect: function(e) {
        const state = this._selectedState;
        const selectedIdx = $(e.item).index();

const availableCalendars = _.filter(calendars, function(calendar) {
            return app.acl.hasAccess('view', calendar.module);
        });

const calendar = availableCalendars[selectedIdx];
        const selectedModule = calendar.module;

if (selectedModule === 'Quotes') {
            app.router.navigate('Quotes/create', {trigger: true});
        } else {
            //open drawer with default values based on module
            const model = this.buildModelWithProperDefaultFields(calendar, this, state);
            app.drawer.open({
                layout: 'create',
                context: {
                    layoutName: 'create',
                    create: true,
                    module: selectedModule,
                    model: model
                }},
                _.bind(function(context, model) {
                    if (!(model instanceof app.data.beanModel)) {
                        return; //no record created
                    }

this.loadData();

if (this.isPageWithSubpanels()) {
                        this.refreshSubpanels(model.module);
                    }
                }, this)
            );
        }
    },

/**
     * Move event is starting
     *
     * @param {Object} e
     */
    _moveResizeStartHandler: function(e) {
        if (this.isAllowed('allow_update', e.event)) {
            this.setCssMarkerToHideTooltip(e);
        } else {
            let errorMessage = app.lang.getModString('LBL_CALENDAR_NOT_ALLOWED_TO_MOVE', 'Calendar');
            if (arguments.callee.name == 'resizeHandler') {
                errorMessage = app.lang.getModString('LBL_CALENDAR_NOT_ALLOWED_TO_CHANGE', 'Calendar');
            }
            app.alert.show('not-allowed', {
                level: 'warning',
                messages: errorMessage,
                autoClose: true
            });
            e.preventDefault();
        }
    },

/**
     * Hide tooltip when the event is resized
     *
     * @param {Object} e
     */
    setCssMarkerToHideTooltip: function(e) {
        let element = this.$('[data-uid=' + e.event.uid + ']');
        element.addClass('k-event-drag-hint');
    },

/**
     * Move event was done
     *
     * @param {Object} e
     */
    _moveResizeHandler: function(e) {
        this.eventInChange = e;
        let clonedEvent = app.utils.deepCopy(e.event);

let schedulerViewType = this.scheduler._selectedView.name;
        schedulerViewType = this.getViewType(schedulerViewType);

if (schedulerViewType === this.EXPANDED_MONTH_VIEW || schedulerViewType === this.MONTH_SCHEDULE_VIEW) {
            let originalEvent = this._eventsLoaded.events.find((evt) => evt.recordId === e.event.recordId);
            if (!originalEvent) {
                e.preventDefault();
            }

// When resizing elements in the month/scheduler view,
            // the end date of the event will come as 00:00 the next day
            // We will need to turn that back in order to use the correct day of the month
            let startDate = moment(e.start);
            let endDate = moment(e.end);

let origStartDate = moment(originalEvent.start);
            let origEndDate = moment(originalEvent.end);

let calendarDef = _.find(this.calendarDefs, function(calendarDef) {
                return calendarDef.calendarId === originalEvent.calendarId;
            });
            let moduleMetadata = app.metadata.getModule(calendarDef.module);
            let fieldsMetadata = moduleMetadata.fields;

let endDef = fieldsMetadata[calendarDef.end_field];
            let endDefFieldType = '';

if (typeof endDef != 'undefined') {
                endDefFieldType = endDef.dbType || endDef.dbtype || endDef.type;
            }

const dateFormat = 'YYYYMMDD';

if (origStartDate.format(dateFormat) === startDate.format(dateFormat)) {
                if (origStartDate.format(dateFormat) === origEndDate.format(dateFormat) &&
                    startDate.format(dateFormat) !== endDate.format(dateFormat) &&
                    endDefFieldType != 'date') {
                    endDate.subtract(1, 'days');
                }
            } else if (schedulerViewType === this.MONTH_SCHEDULE_VIEW && originalEvent.isAllDay) {
                endDate.subtract(1, 'days');
            }

let newStart = origStartDate.year(startDate.year()).month(startDate.month()).date(startDate.date());
            let newEnd = origEndDate.year(endDate.year()).month(endDate.month()).date(endDate.date());

e.event.start = newStart.toDate();
            e.event.end = newEnd.toDate();

e.event.dirtyFields.start = true;
            e.event.dirtyFields.end = true;

clonedEvent.start = newStart.toDate();
            clonedEvent.end = newEnd.toDate();
        }

if (clonedEvent.module == 'Calls' || clonedEvent.module == 'Meetings') {
            this.confirmationPopupView = app.view.createView({
                context: this.context,
                type: 'confirm-invitation',
                event: clonedEvent,
            });

$('#alerts').append(this.confirmationPopupView.$el);

this.confirmationPopupView.render();
        } else {
            app.alert.show('moveResizeHandlerAlert', {
                level: 'confirmation',
                messages: app.lang.getModString('LBL_CALENDAR_CONFIRM_CHANGE_RECORD', 'Calendar'),
                autoClose: false,
                onConfirm: _.bind(function() {
                    this.saveRecord(clonedEvent);
                }, this),
                onCancel: _.bind(this.cancelSave, this)
            });
        }
    },

/**
     * Update event
     *
     * @param {Object} eventData
     */
    updateEvent: function(eventData) {
        let data = {
            recordId: eventData.recordId,
            module: eventData.module,
            calendarId: eventData.calendarId,
            start: moment(eventData.start).format(),
            end: moment(eventData.end).format()
        };

if (typeof eventData.sendInvites == 'boolean') {
            data.sendInvites = true;
        }

app.alert.show('move_resize_event', {
            level: 'process',
            title: app.lang.get('LBL_LOADING'),
            autoClose: false
        });

//solve the case when multiple move/resize actions are made quicker then requests
        this.scheduler.dataSource.trigger('progress');

let url = app.api.buildURL('Calendar/updateRecord') + '/' + this.eventInChange.event.recordId;
        app.api.call('create', url, data, {
            success: _.bind(function(updated) {
                if (this.disposed) {
                    return;
                }

if (updated) {
                    app.alert.show('successUpdateRecordAlert', {
                        level: 'success',
                        messages: app.lang.getModString('LBL_CALENDAR_RECORD_SAVED', 'Calendar'),
                        autoClose: true
                    });

if (this.isPageWithSubpanels()) {
                        this.refreshSubpanels(this.eventInChange.event.module);
                        app.events.trigger('multidateFieldChanged');
                    }
                } else {
                    app.alert.show('update-record-restricted', {
                        level: 'error',
                        messages: app.lang.getModString('LBL_CALENDAR_RESTRICT_UPDATE', 'Calendar'),
                        autoClose: true
                    });
                }
            }, this),
            error: function(data) {
                // refresh token if it has expired
                app.error.handleHttpError(data, {});
            },
            complete: _.bind(function() {
                app.alert.dismiss('move_resize_event');
                this.eventInChange = null;
                app.events.trigger('calendar:reload');
            }, this)
        });
    },

/**
     * Delete handler
     *
     * @param {Object} e
     */
    _deleteHandler: function(e) {
        e.preventDefault();

if (this.isAllowed('allow_delete', e.event)) {
            this._deletedEvent = e;
            this._isDeleteAction = true;
            app.alert.show('confirmRemoveRecordAlert', {
                level: 'confirmation',
                messages: app.lang.getModString('LBL_CALENDAR_CONFIRM_DELETE_RECORD', 'Calendar'),
                autoClose: false,
                onConfirm: _.bind(this.deleteEvent, this),
                onCancel: _.bind(this.cancelDelete, this)
            });
        } else {
            app.alert.show('not-allowed', {
                level: 'warning',
                messages: app.lang.getModString('LBL_CALENDAR_NOT_ALLOWED_TO_DELETE', 'Calendar'),
                autoClose: true
            });
        }
    },

/**
     * Delete event
     */
    deleteEvent: function() {
        app.alert.show('event-deleted', {
            level: 'process',
            messages: app.lang.getModString('LBL_DELETING', 'Calendar')
        });
        app.api.call(
            'delete',
            app.api.buildURL(this._deletedEvent.event.module) + '/' + this._deletedEvent.event.recordId, null, {
                success: _.bind(this._deleteEventSuccessCallback, this),
                error: function(data) {
                    // refresh token if it has expired
                    app.error.handleHttpError(data, {});
                }
            }
        );
    },

/**
    * Event delete success callback
    */
    _deleteEventSuccessCallback: function() {
        app.alert.dismiss('event-deleted');
        app.alert.show('deleteAlert', {
            level: 'success',
            messages: app.lang.getModString('LBL_CALENDAR_RECORD_DELETED', 'Calendar'),
            autoClose: true
        });

app.events.trigger('calendar:reload');

if (this.isPageWithSubpanels()) {
            this.refreshSubpanels(this._deletedEvent.event.module);
        }

this._isDeleteAction = false;
    },

/**
     * Mark delete action
     */
    cancelDelete: function() {
        this._isDeleteAction = false;
    },

/**
     * Offline refresh data source
     *
     * Loads events from last fetch (cached on this view), on the calendar component
     */
    offlineRefreshDataSource: function() {
        // Need to patch end/start dates
        this._syncedEvents.forEach((evt) => {
            evt.start = moment(evt.start).toDate();
            evt.end = moment(evt.end).toDate();
        });

this.scheduler._selectedView.options.dataSource.data(this._syncedEvents);
    },

/**
     * Refresh collections on all subpanels of the given module
     *
     * @param {string} module
     */
    refreshSubpanels: function(module) {
        const filterpanel = app.controller.layout
            .getComponent('sidebar')
            .getComponent('main-pane')
            .getComponent('filterpanel');
        const subpanels = filterpanel.componentsList.subpanels;
        const targetSubpanels = _.filter(subpanels._components, function(subpanel) {
            return subpanel.module === module;
        });

if (targetSubpanels.length > 0) {
            _.each(targetSubpanels, function(subpanel) {
                subpanel.collection.fetch();
            });
        }
    },

/**
     * Returns whether the current page contains subpanels
     *
     * @return {boolean}
     */
    isPageWithSubpanels: function() {
        let filterPanel;
        const sidebar = app.controller.layout.getComponent('sidebar');
        if (sidebar) {
            const mainPane = sidebar.getComponent('main-pane');
            if (mainPane) {
                filterPanel = mainPane.getComponent('filterpanel');
            }
        }

if (filterPanel instanceof app.view.Layout) {
            if (filterPanel.componentsList.subpanels) {
                return true;
            }
        }

return false;
    },

/**
     * Navigate handler
     *
     * @param {Object} options
     */
    _navigateHandler: function(options) {
        if (options.action === 'changeView') {
            if (options.view === this.MONTH_SCHEDULE_VIEW) {
                delete this.scheduler.options.dateHeaderTemplate;
            } else {
                this.scheduler.options.dateHeaderTemplate = this._getDateHeaderTemplate(options.view);
            }

if (options.view === this.EXPANDED_MONTH_VIEW) {
                delete this.scheduler.options.selectedDateFormat;
            } else {
                this.scheduler.options.selectedDateFormat = this._getSelectedDateFormat(options.view);
            }
        }

this._navigationLoadData(options);
    },

/**
     * Load data after navigation
     *
     * Wait for UI navigation to complete, then load data if not already loaded
     *
     * @param {Object} options
     */
    _navigationLoadData: _.debounce(function(options) {
        let schedulerView = this.scheduler.view();
        const intervalDates = {
            start: moment(schedulerView.startDate()).format('YYYY-MM-DD'),
            end: moment(schedulerView.endDate()).format('YYYY-MM-DD')
        };

let selectedDate = new Date(options.date.getTime());;
        schedulerView = this.scheduler.view();

schedulerView.select({
            events: [],
            start: selectedDate,
            end: selectedDate,
            groupIndex: 0
        });

this.context.trigger('scheduler:view:changed');

let intervalStart = moment(intervalDates.start).format('YYYY-MM-DD');
        let intervalEnd = moment(intervalDates.end).format('YYYY-MM-DD');
        if (
            intervalStart != moment(this._eventsLoaded.startDate).format('YYYY-MM-DD') ||
            intervalEnd != moment(this._eventsLoaded.endDate).format('YYYY-MM-DD')
        ) {
            this.loadData();
        }

const viewName = schedulerView.options.schedulerViewName;
        app.cache.set(this.keyToStoreCalendarView, viewName);
    }, 0),

/**
     * Returns whether an action like create/update/delete is allowed for a calendar event
     *
     * @param {string} action
     * @param {Object} event
     * @return {boolean}
     */
    isAllowed: function(action, event) {
        let calendar = _.find(this.calendarDefs, function(calendar) {
            return calendar.id === event.calendarId;
        });
        if (typeof calendar == 'undefined') {
            return false;
        } else {
            return calendar[action] || false;
        }
    },

/**
     * Transforms a View Name into an accepted View Name format
     *
     * @param {string} viewName
     * @return {string}
     */
    getViewType: function(viewName) {
        let type;
        switch (viewName) {
            case this.DAY_VIEW:
            case 'DayView':
                type = this.DAY_VIEW;
                break;
            case this.WEEK_VIEW:
            case 'WeekView':
                type = this.WEEK_VIEW;
                break;
            case this.WORK_WEEK_VIEW:
            case 'WorkWeekView':
                type = this.WORK_WEEK_VIEW;
                break;
            case 'month':
            case this.EXPANDED_MONTH_VIEW:
            case 'Month':
                type = this.EXPANDED_MONTH_VIEW;
                break;
            case this.AGENDA_VIEW:
                type = this.AGENDA_VIEW;
                break;
            case this.TIMELINE_VIEW:
            case 'TimelineView':
                type = this.TIMELINE_VIEW;
                break;
            case this.MONTH_SCHEDULE_VIEW:
            case 'Scheduler':
                type = this.MONTH_SCHEDULE_VIEW;
                break;
        }
        return type;
    },

/**
     * Transforms a view title into an accepted View Title format
     *
     * @param {string} viewName
     * @return {string}
     */
    getViewTitle: function(viewName) {
        let title;
        switch (viewName) {
            case this.DAY_VIEW:
                title = app.lang.getModString('LBL_CALENDAR_VIEW_DAY', 'Calendar');
                break;
            case this.WEEK_VIEW:
                title = app.lang.getModString('LBL_CALENDAR_VIEW_WEEK', 'Calendar');
                break;
            case this.WORK_WEEK_VIEW:
                title = app.lang.getModString('LBL_CALENDAR_VIEW_WORKWEEK', 'Calendar');
                break;
            case 'month':
            case 'Month':
            case this.EXPANDED_MONTH_VIEW:
                title = app.lang.getModString('LBL_CALENDAR_VIEW_MONTH', 'Calendar');
                break;
            case this.AGENDA_VIEW:
                title = app.lang.getModString('LBL_CALENDAR_VIEW_AGENDA', 'Calendar');
                break;
            case this.TIMELINE_VIEW:
                title = app.lang.getModString('LBL_CALENDAR_VIEW_TIMELINE', 'Calendar');
                break;
            case this.MONTH_SCHEDULE_VIEW:
            case 'Scheduler':
                title = app.lang.getModString('LBL_CALENDAR_VIEW_SCHEDULERMONTH', 'Calendar');
                break;
        }
        return title;
    },

/**
     * Bind export events
     *
     * After creating the scheduler, and it's on DOM, we need to attach the handlers for Export, Publish and Settings
     */
    _bindExportEvent: function() {
        this.$('.export_icalendar')
            .on(
                'click',
                _.bind(this._getICalIdentifier, this)
            );

this.$('.publish_icalendar')
            .on(
                'click',
                _.bind(this._publishCalendar, this)
            );
        this.$('.userSettings')
        .on(
            'click',
            _.bind(this._userSettings, this)
        );
    },

/**
     * Get iCal id
     *
     * Get the ICal id where we store calendar definitions
     */
    _getICalIdentifier: function() {
        const postData = {
            calendarConfigurations: this.calendars.compile()
        };
        app.api.call('create', app.api.buildURL('Calendar/getICalConfigurationsUID'), postData, {
            success: _.bind(function successSaveCalendarConfigurations(data) {
                if (this.disposed) {
                    return;
                }

if (_.isEmpty(data.key)) {
                    app.alert.show('set-publish-key', {
                        level: 'info',
                        messages: app.lang.getModString('LBL_CALENDAR_CONFIGURE_PUBLISH_KEY', 'Calendar'),
                        autoClose: false
                    });
                    return;
                }
                this._exportCalendar(data);
            }, this),
            error: function errorSaveCalendarConfigurations(data) {
                // refresh token if it has expired
                app.error.handleHttpError(data, {});
            }
        });
    },

/**
     * Export ICal calendar
     *
     * @param {Object} options
     */
    _exportCalendar: function(options) {
        let sugarLocation = app.utils.getSiteUrl();
        sugarLocation = sugarLocation
            .replace(/#$/, '')
            .replace(/(index\.php)$/, '')
            .replace(/\/$/, '');
        const url = sugarLocation + '/' + app.config.serverUrl +
        '/Calendar/getICalData?type=ics&user_id=' + app.user.id + '&key=' + options.key +
        '&calendarsUID=' + options.calendarConfigurationUID + '&export=1';

window.open(url);
    },

/**
     * Publish ICal calendar
     */
    _publishCalendar: function() {
        this.addPublishModalElementOnDom();

const postData = {
            calendarConfigurations: this.calendars.compile()
        };

//obtain a publish key
        app.api.call('create', app.api.buildURL('Calendar/getICalPublishUrl'), postData, {
            success: function(data) {
                if (this.disposed) {
                    return;
                }

if (data === 'empty_publish_key') {
                    app.alert.show('set-publish-key', {
                        level: 'info',
                        messages: app.lang.getModString('LBL_CALENDAR_CONFIGURE_PUBLISH_KEY', 'Calendar'),
                        autoClose: false
                    });
                    return;
                }
                //update modal
                $('[data-content=publish-icalendar-modal]')
                    .find('input')
                    .attr('value', data);

//open modal
                $('[data-content=publish-icalendar-modal]').modal('show');
                //on close, remove it from body in order to not mess with other modals
                $('[data-content=publish-icalendar-modal]')
                    .on('hidden.bs.modal', function modalCloseHandler() {
                        $('[data-content=publish-icalendar-modal]').remove();
                    });
            },
            error: function(data) {
                // refresh token if it has expired
                app.error.handleHttpError(data, {});
            }
        });
    },

/**
     * User settings
     *
     * Added possibility to set business hours
     */
    _userSettings: function() {
        this.addBusinessHoursElementOnDom();

//update modal
        const calendarBusinessHours = app.user.lastState.get(this.keyToStoreCalendarBusinessHours);

$('[name=startTime]').timepicker({
            timeFormat: app.user.getPreference('timepref'),
            disableTextInput: true
        });

$('[name=endTime]').timepicker({
            timeFormat: app.user.getPreference('timepref'),
            disableTextInput: true
        });

if (calendarBusinessHours) {
            $('[data-content=business-hours-modal]')
                .find('[name=startTime]')
                .timepicker('setTime', calendarBusinessHours.start);

$('[data-content=business-hours-modal]')
                .find('[name=endTime]')
                .timepicker('setTime', calendarBusinessHours.end);
        }
        //open modal
        $('[data-content=business-hours-modal]').modal('show');
        //on close, remove it from body in order to not mess with other modals
        $('[data-content=business-hours-modal]')
            .on('hidden.bs.modal', function modalCloseHandler() {
                $('[data-content=business-hours-modal]').remove();
            });

$('[name=saveHours]').on('click', _.bind(function() {
            this._saveBusinessHours();
        }, this));
    },

/**
     * Add publish modal element on DOM
     */
    addPublishModalElementOnDom: function() {
        const modal = app.template.getView('scheduler.publish-modal', 'Calendar');
        $('body').append(modal());
    },

/**
     * Add business hours modal element on DOM
     */
    addBusinessHoursElementOnDom: function() {
        const modal = app.template.getView('scheduler.business-hours', 'Calendar');
        $('body').append(modal());
    },

if (weekStart) {
            kendo.culture().calendar.firstDay = weekStart;
        }
    },

/**
     * Save business hours to local storage
     */
    _saveBusinessHours: function() {
        let startTime = $('[name=startTime]').val();
        let endTime = $('[name=endTime]').val();

if (startTime && endTime) {
            startTime = app.date(startTime, app.date.convertFormat(app.user.getPreference('timepref')));
            endTime = app.date(endTime, app.date.convertFormat(app.user.getPreference('timepref')));

const businessHours = {
                start: startTime.format('HH:mm'),
                end: endTime.format('HH:mm')
            };

app.user.lastState.set(this.keyToStoreCalendarBusinessHours, businessHours);

$('[data-content=business-hours-modal]').remove();
            $('.modal-backdrop').remove();

//need to remove the old calendar and recreate it with the new options
            if (this.toolbarView) {
                this.toolbarView.dispose();
                this.$('.k-scheduler-toolbar.k-toolbar').remove();
            }

if (this.confirmationPopupView) {
                this.confirmationPopupView.dispose();
            }

this.stopListening(this.context, 'change:calendars');

this.$('#' + this._schedulerCssId).find('.k-scheduler-layout').remove();
            this.$('#' + this._schedulerCssId).find('.k-scheduler-footer').remove();

this.cleanupScheduler();
            this._createCalendar();

app.events.trigger('calendar:reload');
        }
    },

/**
     * Set business hours
     */
    _setBusinessHours: function() {
        let businessHours = app.user.lastState.get(this.keyToStoreCalendarBusinessHours);

if (!businessHours) {
            businessHours = {
                start: '09:00',
                end: '17:00'
            };
            app.user.lastState.set(this.keyToStoreCalendarBusinessHours, businessHours);
        }
    },

/**
     * Get business hours
     *
     * @param {string} momentIdentifier
     * @return {Object}
     */
    _getBusinessHours: function(momentIdentifier) {
        const businessHours = app.user.lastState.get(this.keyToStoreCalendarBusinessHours);
        return new Date(`2000-01-01 ${businessHours[momentIdentifier]}`);
    },

/**
     * Get date header template
     *
     * @param {string} view
     * @return {string}
     */
    _getDateHeaderTemplate: function(view) {
        let dataHeaderTemplate = '';
        let kendoDateFormat = '';

if (view === this.TIMELINE_VIEW) {
            kendoDateFormat = app.Calendar.utils.getKendoDateMapping(
                app.user.getPreference('datepref'), 'dayAndVerboseMonth'
            );
            dataHeaderTemplate = kendo.template(
                `<span class='k-link k-nav-day'>#=kendo.format('{0:${kendoDateFormat}}', date)#</span>`
            );
        } else if (view === this.MONTH_SCHEDULE_VIEW) {
            kendoDateFormat = app.Calendar.utils.getKendoDateMapping(app.user.getPreference('datepref'), 'dayAndMonth');
            dataHeaderTemplate = kendo.template(
                `<span class='k-link k-nav-day'>#=kendo.format('{0:m}', date)#</span>`
            );
        } else {
            kendoDateFormat = app.Calendar.utils.getKendoDateMapping(app.user.getPreference('datepref'), 'dayAndMonth');
            dataHeaderTemplate = kendo.template(`#var dateString = isMobile ? kendo.toString(date,'ddd')[0] :
                kendo.toString(date,'ddd ${kendoDateFormat}'); #<span class='k-link k-nav-day'>#=dateString#</span>`);
        }

return dataHeaderTemplate;
    },

/**
     * Get major time header template
     *
     * @return {string}
     */
    _getMajorTimeHeaderTemplate: function() {
        let kendoTimeFormat = app.Calendar.utils.getKendoTimeMapping(app.user.getPreference('timepref'));
        return `#=kendo.toString(date, '${kendoTimeFormat}')#`;
    },

/**
     * Get selected date format
     *
     * @param {string} view
     * @return {string}
     */
    _getSelectedDateFormat: function(view) {
        const userDatePref = app.Calendar.utils.getKendoDateMapping(
            app.user.getPreference('datepref'), 'fullVerboseMonth'
        );
        let selectedDateFormat = '';
        switch (view) {
            case this.DAY_VIEW:
            case this.TIMELINE_VIEW:
                selectedDateFormat = `{0:dddd, ${userDatePref}}`;
                break;
            case this.WORK_WEEK_VIEW:
            case this.WEEK_VIEW:
            case this.AGENDA_VIEW:
            case this.MONTH_SCHEDULE_VIEW:
                selectedDateFormat = `{0:dddd, ${userDatePref}} - {1:dddd, ${userDatePref}}`;
                break;
        }

return selectedDateFormat;
    },

/**
     * Navigate to record view
     *
     * @param {Object} event
     */
    navigateToRecord: function(event) {
        let url;
        const moduleMeta = app.metadata.getModule(event.module);

if (moduleMeta.isBwcEnabled) {
            url = '#bwc/index.php?module=' + event.module + '&action=DetailView&record=' +
                event.recordId;
            this._navigate(url);
        } else {
            url = '#' + event.module + '/' + event.recordId;
            this._navigate(url);
        }
    },

/**
     * Destroy Kendo Scheduler and remove legend positioning event
     */
    cleanupScheduler: function() {
        if (typeof kendo != 'undefined' && this.scheduler instanceof kendo.ui.Scheduler) {
            this.scheduler.destroy();
            this.scheduler = null;
        }
    },

/**
     * @inheritdoc
     */
    _dispose: function() {
        if (this.toolbarView) {
            this.toolbarView.dispose();
        }
        if (this.confirmationPopupView) {
            this.confirmationPopupView.dispose();
        }

this.stopListening(this.context);

this.cleanupScheduler();

this._super('_dispose');
    }
}) },
"confirm-invitation": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Confirm-invitation View (base)

className: 'alert-wrapper calendar-alert',

extendsFrom: 'AlertView',

/**
     * @override
     */
    initialize: function(options) {
        this.events = _.extend({}, this.events, {
            'click [data-action=confirm]': 'saveClicked',
            'click [data-action=saveAndSendEmails]': 'saveAndSendEmailsClicked'
        });
        this.context = options.context;

this._super('initialize', [options]);

this.name = 'confirm-invitation';
    },

/**
     * @override
     */
    _getAlertTemplate: function(options, templateOptions) {
        options = options || {};
        let template = app.template.getView('confirm-invitation.email', this.options.module);

return template();
    },

/**
     * @override
     */
    cancelClicked: function(event) {
        $('.calendar-alert').remove();
        this.context.trigger('button:cancel:click');
    },

/**
     * @override
     */
    saveClicked: function(event) {
        $('.calendar-alert').remove();
        this.context.trigger('button:save:click', this.options.event);
    },

/**
     * Save and send emails handler
     */
    saveAndSendEmailsClicked: function() {
        $('.calendar-alert').remove();
        this.context.trigger('button:saveAndSendInvites:click', this.options.event);
    }
}) },
"activity-card-header": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Basic.ActivityCardHeaderView
 * @alias SUGAR.App.view.views.BaseBasicActivityCardHeaderView
 * @extends View.Views.Base.ActivityCardHeaderView
 */
({
	// Activity-card-header View (base)

extendsFrom: 'ActivityCardHeaderView',

this.hasAvatarUser = !!this.userField;
    }
}) }
}}
,
"layouts": {
"base": {
"main-scheduler": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Layouts.Base.Calendar.MainSchedulerLayout
 * @alias SUGAR.App.view.layouts.BaseCalendarMainSchedulerLayout
 * @extends View.Layouts.Base.BaseLayout
 */
({
	// Main-scheduler Layout (base)

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.initVars();

options.context.set('skipFetch', true);

this._super('initialize', [options]);

this.listenTo(this.context, 'calendars:cache:force-refresh', _.bind(this.forceCalendarRefresh, this));
    },

/**
     * Initialize variables
     */
    initVars: function() {
        /**
         * Identifier of the type of calendar we are showing in this component
         */
        this.componentStorageKey = 'main-panel';

/**
         * Scheduler key used to store calendar configurations
         * Each location where user can modify the calendar on the fly, has it's own key
         * ie: main / lists / subpanels
         */
        this.keyToStoreCalendarConfigurations = app.Calendar.utils.buildUserKeyForStorage(this.componentStorageKey);
    },

/**
     * Force Calendar Refresh
     *
     * Setup context parameters like calendars, location... then update context
     */
    forceCalendarRefresh: function() {
        let schedulerContext = this.getContextSettingsForScheduler();
        this.context.set(schedulerContext);
    },

/**
     * @override
     */
    _render: function() {
        let schedulerContext = this.getContextSettingsForScheduler();
        this.context.set(schedulerContext);

this._super('_render');
    },

/**
     * Get context settings for scheduler component
     *
     * @return {Object}
     */
    getContextSettingsForScheduler: function() {
        let calendarConfigurations = app.Calendar.utils.getConfigurationsByKey(this.keyToStoreCalendarConfigurations);

calendarConfigurations.otherCalendars = _.filter(calendarConfigurations.otherCalendars,
            function filterCalendars(calendar) {
                return calendar.selected;
            }
        );
        calendarConfigurations = calendarConfigurations.myCalendars.concat(calendarConfigurations.otherCalendars);

const keyToStoreCalendarView = app.Calendar.utils.buildUserKeyForStorage('main');
        const defaultView = app.cache.get(keyToStoreCalendarView) || 'expandedMonth';

return {
            module: this.module,
            calendars: calendarConfigurations,
            defaultView: defaultView,
            visibleRelationsInContextList: [],
            location: 'main',
            keyToStoreCalendarConfigurations: this.keyToStoreCalendarConfigurations,
            customKendoOptions: {
                listExportButtons: true
            }
        };
    },

/**
     * @override
     */
    _dispose: function() {
        this.context.off('calendars:cache:force-refresh');
        this._super('_dispose');
    }
}) },
"sidebar-nav-flyout-module-menu": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */

/**
 * @class View.Layouts.Base.CalendarSidebarNavFlyoutModuleMenuLayout
 * @alias SUGAR.App.view.layouts.BaseCalendarSidebarNavFlyoutModuleMenuLayout
 * @extends View.Layout
 */
({
	// Sidebar-nav-flyout-module-menu Layout (base)

extendsFrom: 'SidebarNavFlyoutModuleMenuLayout',

/**
     * @inheritdoc
     */
    bindDataChange: function() {
        this._super('bindDataChange');
        this.listenTo(this.layout, 'popover:opened', this._populateCalendarModules);
    },

/**
     * Adds the calendar modules to the menu components.
     *
     * @private
     */
    _getMenuComponents: function() {
        let menuComponents = this._super('_getMenuComponents');
        menuComponents.splice(1,0 ,{
            view: {
                type: 'sidebar-nav-flyout-actions',
                name: 'calendar-modules',
                actions: []
            }
        });
        return menuComponents;
    },

/**
     * Calls the the Calendar Modules api to get the list of calendar modules.
     *
     * @private
     */
    _populateCalendarModules: function() {
        app.api.call('read', app.api.buildURL('Calendar/modules'), {}, {
            success: _.bind(this._populateCalendarModulesSucceess, this)
        });
    },

/**
     * Populates the calendar modules componenet and renders the actions.
     * @param data
     * @private
     */
    _populateCalendarModulesSucceess: function(data) {
        let actions = [];
        let calendarModules = this.getComponent('calendar-modules');

_.each(data.modules, function(moduleInfo, module) {
            let createLabel = '';
            if (module === 'KBContents') {
                createLabel = app.lang.getModString('LNK_NEW_KBCONTENT_TEMPLATE', module);
            } else {
                let createLabelKey = 'LNK_NEW_' + moduleInfo.objName.toUpperCase();
                createLabel = app.lang.get(createLabelKey, module);

if (createLabel === createLabelKey) {
                    createLabelKey = 'LNK_NEW_RECORD';
                    createLabel = app.lang.getModString(createLabelKey, module);
                }
            }
            actions.push({
                acl_action: 'create',
                acl_module: module,
                icon: app.metadata.getModule(module).icon || '',
                label: createLabel,
                route: `#${module}/create`
            });
        }, this);
        calendarModules.updateActions(actions);
    }
}) },
"add-calendar": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Layouts.Base.Calendar.AddCalendarLayout
 * @alias SUGAR.App.view.layouts.BaseAddCalendarLayout
 * @extends View.Layouts.Base.BaseLayout
 */
({
	// Add-calendar Layout (base)

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

this.collection.sync = this.sync;
        this.collection.getSyncCallbacks = this.getSyncCallbacks;

this.collection.allowed_modules = ['Users', 'Teams'];
        this.context.on('calendar:add:search', this.search, this);
    },

/**
     * Collection's sync method
     *
     * @param {string} method
     * @param {Data.Bean} model
     * @param {Object} options
     */
    sync: function(method, model, options) {
        let callbacks;
        let url;

options = options || {};

app.config.maxQueryResult = app.config.maxQueryResult || 20;
        options.limit = options.limit || app.config.maxQueryResult;

options = app.data.parseOptionsForSync(method, model, options);

callbacks = this.getSyncCallbacks(method, model, options);
        this.trigger('data:sync:start', method, model, options);

url = app.api.buildURL('Calendar', 'usersAndTeams', null, options.params);
        app.api.call('read', url, null, callbacks);
    },

/**
     * @override
     * Customizations needed just for teams_offset flag we send from server
     */
    getSyncCallbacks: function(method, model, options) {
        return {
            success: app.data.getSyncSuccessCallback(method, model, options),
            error: app.data.getSyncErrorCallback(method, model, options),
            complete: app.data.getSyncCompleteCallback(method, model, options),
            abort: app.data.getSyncAbortCallback(method, model, options)
        };
    },
    /**
     * Adds the set of modules and term that should be used to search for recipients.
     *
     * @param {Array} modules
     * @param {string} term
     */
    search: function(modules, term) {
        // reset offset to 0 on a search. make sure that it resets and does not update.
        this.collection.fetch({
            query: term,
            module_list: modules,
            offset: 0,
            update: false
        });
    },

/**
     * @override
     */
    _dispose: function() {
        this.context.off('calendar:add:search');

this._super('_dispose');
    }
}) }
}}
,
"datas": {
"base": {
"collection": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/*
 * @class Data.Base.CalendarBeanCollection
 * @extends Data.BeanCollection
 */
({
	// Collection Data (base)

/**
     * Returns all calendars formatted for events retrival
     *
     * @return {Array}
     */
    compile: function() {
        const calendarConfigurations = _.map(this.models, function(calendarConfiguration) {
            return calendarConfiguration.compile();
        });
        return calendarConfigurations;
    },
}) },
"model": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class Model.Datas.Base.CalendarModel
 * @alias SUGAR.App.model.datas.BaseCalendarModel
 * @extends Data.Bean
 */
 ({
	// Model Data (base)

initialize: function(options) {
        app.Bean.prototype.initialize.call(this, options);

if (this.isNew()) {
            this.listenTo(this, 'change:calendar_module', _.debounce(_.bind(this.prefillDefaultFields, this), 0));
        } else {
            this.once('sync', function() {
                this.listenTo(this, 'change:calendar_module', _.debounce(_.bind(this.prefillDefaultFields, this), 0));
            }, this);
        }

this.addValidationTask('dates_exists', _.bind(this._validateDateFields, this));
        this.addValidationTask('fields_required', _.bind(this.validateRequiredFields, this));

this.denyFields = ['date_entered', 'date_modified'];
    },

/**
     * Returns data of a calendar configuration
     *
     * @return {Object}
     */
    compile: function() {
        return {
            id: this.get('id') || this.get('calendarId'),
            calendarId: this.get('calendarId'),
            userId: this.get('userId'),
            teamId: this.get('teamId'),
        };
    },

/**
     * Prefill default fields
     *
     * @param {Object} model
     * @param {string} module
     * @param {Object} options
     */
    prefillDefaultFields: function(model, module, options) {
        if (options.revert) {
            return;
        }

const calendarModule = this.get('calendar_module');
        const moduleMeta = app.metadata.getModule(calendarModule);

if (moduleMeta) {
            const fieldsMetadata = moduleMeta.fields;

const fieldsToCalculate = {
                'subject': {
                    fieldTypes: ['varchar', 'name', 'fullname'],
                    keys: ['subject', 'name']
                },
                'event_start': {
                    fieldTypes: ['datetime', 'datetimecombo'],
                    keys: ['startdate', 'datestart', 'start', 'dateentered']
                },
                'event_end': {
                    fieldTypes: ['datetime', 'datetimecombo'],
                    keys: ['enddate', 'dateend', 'end', 'dateentered']
                },
            };

_.each(fieldsToCalculate, function(fieldToCalculate, fieldName) {
                let bestScore = 0;
                let bestScoreField = '';
                _.each(fieldToCalculate.keys, function(keyToSearch) {
                    _.each(fieldsMetadata, function(fieldDef, fieldDefName) {
                        if (this.denyFields.indexOf(fieldDef.name) == -1 &&
                        fieldToCalculate.fieldTypes.indexOf(fieldDef.type) >= 0) {
                            const fieldScore = this.calculateMatchScore(keyToSearch, fieldDef);
                            if (fieldScore > bestScore) {
                                bestScore = fieldScore;
                                bestScoreField = fieldDefName;
                            }
                        }
                    }, this);
                }, this);
                if (bestScore > 0) {
                    this.set(fieldName, bestScoreField);
                } else {
                    this.unset(fieldName);
                }
            }, this);

const defaultColor = this.getDefaultBackgroundColor(this.get('calendar_module'));

let defaultParams = {
                duration_minutes: '',
                duration_hours: '',
                duration_days: '',
                color: defaultColor,
                dblclick_event: 'detail:self:id',
                allow_create: true,
                allow_update: true,
                allow_delete: true,
                event_tooltip_template: defaultTemplate,
                day_event_template: defaultTemplate,
                week_event_template: defaultTemplate,
                month_event_template: defaultTemplate,
                agenda_event_template: defaultTemplate,
                timeline_event_template: defaultTemplate,
                schedulermonth_event_template: defaultTemplate,
                ical_event_template: defaultTemplate,
            };
            //Calls and Meetings needs durations instead of event_end
            if (calendarModule == 'Calls' || calendarModule == 'Meetings') {
                defaultParams = _.extend(defaultParams, {
                    event_end: '',
                    duration_minutes: 'duration_minutes',
                    duration_hours: 'duration_hours',
                });
            }

this.set(defaultParams);
        }
    },

/**
     * Validate date fields
     *
     * Validate there is start date and an end or some duration
     *
     * @param {Object} fields The list of field names and their definitions.
     * @param {Object} errors The list of field names and their errors.
     * @param {Function} callback Async.js waterfall callback.
     * @private
     */
    _validateDateFields: function(fields, errors, callback) {
        const eventStartGiven = !_.isEmpty(this.get('event_start'));
        const eventEndGiven = !_.isEmpty(this.get('event_end'));
        const durationMinutesGiven = !_.isEmpty(this.get('duration_minutes'));
        const durationHoursGiven = !_.isEmpty(this.get('duration_hours'));
        const durationDaysGiven = !_.isEmpty(this.get('duration_days'));

if (!eventStartGiven) {
            errors.event_start = app.lang.get('LBL_EVENT_START_ERROR', 'Calendar');
        }
        if (!eventEndGiven && !durationMinutesGiven && !durationHoursGiven && !durationDaysGiven) {
            errors.event_end = app.lang.get('LBL_EVENT_END_ERROR', 'Calendar');
        }

callback(null, fields, errors);
    },

/**
     * It will validate required fields.
     *
     * @param {Array} fields The list of fields to be validated.
     * @param {Object} errors A list of error messages.
     * @param {Function} callback Callback to be called at the end of the validation.
     */
    validateRequiredFields: function(fields, errors, callback) {
        if (!app.acl.hasAccess('view', this.get('calendar_module'))) {
            this.set({
                calendar_module: '',
                event_start: '',
                event_end: '',
                duration_minutes: '',
                duration_hours: '',
                duration_days: ''
            });
        }

_.each(fields, function(field) {
            if (_.has(field, 'required') && field.required) {
                var key = field.name;

if (!this.get(key)) {
                    errors[key] = errors[key] || {};
                    errors[key].required = true;
                }
            }
        }, this);

callback(null, fields, errors);
    },

/**
     * Calculates a value representing how close a field is to a given concept (start date / end date...)
     *
     * @param {string} text         Concept key to search for
     * @param {Object} fieldDef     A field definition
     * @return {number}
     */
    calculateMatchScore: function(text, fieldDef) {
        if (typeof text != 'string' || typeof fieldDef != 'object') {
            return 0;
        }

const fieldModule = this.get('calendar_module');
        let fieldName = fieldDef.name;

if (fieldName.substr(fieldName.length - 2) === '_c') {
            fieldName = fieldName.substr(0, fieldName.length - 2);
        }

fieldName = fieldName.replace(/_/g, '');

let fieldLabel = fieldDef.vname || '';
        if (!_.isEmpty(fieldLabel)) {
            fieldLabel = app.lang.get(fieldLabel, fieldModule);
            fieldLabel = fieldLabel.toLowerCase().replace(/\s/g, '');
        }

let score = 0;

if (fieldName.indexOf(text) >= 0) {
            score += 1;

//prioritize 'startdate' above 'bigstartfieldname' for given 'startdate'
            if (fieldName.length > text.length) {
                score -= fieldName.length / text.length;
            } else if (fieldName.length < text.length) {
                score -= text.length / fieldName.length;
            }
        }
        if (fieldLabel.indexOf(text) >= 0) {
            score += 1;

//prioritize 'startdate' above 'bigstartfieldname' for given 'startdate'
            if (fieldName.length > text.length) {
                score -= fieldLabel.length / text.length;
            } else if (fieldName.length < text.length) {
                score -= text.length / fieldLabel.length;
            }
        }
        return score;
    },

/**
     * Get default color of a module
     *
     * @param {string} module
     * @return {string} Hex format
     */
    getDefaultBackgroundColor: function(module) {
        const defaultStyleSheet = _.find(document.styleSheets, function(styleSheet) {
            return styleSheet.href.indexOf('cache/themes/clients/base/default') > 0;
        });
        const labelRule = _.find(defaultStyleSheet.rules, function(rule) {
            return rule.selectorText == '.label-' + module;
        });
        if (typeof labelRule == 'object') {
            let rgbColor = labelRule.style['background-color'];
            rgbColor = rgbColor.match(/\d+/g);
            rgbColor = _.map(rgbColor, function(color) {
                return parseInt(color);
            });
            return this.rgbToHex(rgbColor);
        }
        return '';
    },

/**
     * Convert rgb color to hex
     *
     * @param {int} comp
     * @return {string}
     */
    componentToHex: function(comp) {
        let hex = comp.toString(16);
        return hex.length == 1 ? '0' + hex : hex;
    },

/**
     * Return hex from rgb
     *
     * @param {Array} rgb
     * @return {string}
     */
    rgbToHex: function(rgb) {
        return '#' + this.componentToHex(rgb[0]) + this.componentToHex(rgb[1]) + this.componentToHex(rgb[2]);
    },
}) }
}}

},
		"Leads":{"fieldTemplates": {
"base": {
"badge": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Leads.BadgeField
 * @alias SUGAR.App.view.fields.BaseLeadsBadgeField
 * @extends View.Fields.Base.BadgeField
 */
({
	// Badge FieldTemplate (base)

/**
     * @inheritdoc
     *
     * This field doesn't support `showNoData`.
     */
    showNoData: false,

events: {
        'click [data-action=convert]': 'convertLead'
    },

/**
     * @inheritdoc
     *
     * The badge is always a readonly field.
     */
    initialize: function(options) {
        options.def.readonly = true;
        app.view.Field.prototype.initialize.call(this, options);
    },

/**
     * @inheritdoc
     */
    isHidden: function() {
        return false;
    },

/**
     * Kick off convert lead process.
     */
    convertLead: function() {
        var model = app.data.createBean(this.model.module);
        model.set(app.utils.deepCopy(this.model.attributes));

app.drawer.open({
            layout : 'convert',
            context: {
                forceNew: true,
                skipFetch: true,
                module: this.model.module,
                leadsModel: model
            }
        });
    }
}) },
"convertbutton": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Leads.ConvertbuttonField
 * @alias SUGAR.App.view.fields.BaseLeadsConvertbuttonField
 * @extends View.Fields.Base.RowactionField
 */
({
	// Convertbutton FieldTemplate (base)

extendsFrom: 'RowactionField',

initialize: function (options) {
        this._super("initialize", [options]);
        this.type = 'rowaction';

// Fix for when the convert button is in the dashablerecord view
        if (this.view.layout && this.view.layout.type === 'dashlet-grid-wrapper') {
            this.model = this.view.layout.getComponent("dashablerecord").model;
        }
    },

_render: function () {
        var convertMeta = app.metadata.getLayout('Leads', 'convert-main');
        var missingRequiredAccess = _.some(convertMeta.modules, function (moduleMeta) {
            return (moduleMeta.required === true && !app.acl.hasAccess('create', moduleMeta.module));
        }, this);

if (this.model.get('converted') || missingRequiredAccess) {
            this.hide();
        } else {
            this._super("_render");
        }
    },

/**
     * Event to trigger the convert lead process for the lead
     */
    rowActionSelect: function() {
        let model = app.data.createBean(this.model.module);
        model.set(app.utils.deepCopy(this.model.attributes));

let isOnDashlet = this.view.name === 'dashlet-toolbar';

app.drawer.open({
            layout : "convert",
            context: {
                forceNew: true,
                skipFetch: true,
                module: 'Leads',
                leadsModel: model,
                doRedirect: !isOnDashlet
            }
        }, success => {
            if (success && isOnDashlet) {
                let dashlet = this.view.layout.getComponent('dashablerecord');
                dashlet._updateAllowedButtons();
            }
        });
    },

bindDataChange: function () {
        if (this.model) {
            this.model.on("change", this.render, this);
        }
    },

/**
     * @inheritdoc
     */
    isAllowedDropdownButton: function() {
        // Filter logic for when its on a dashlet
        if (this.view.name === 'dashlet-toolbar') {
            if (this.module === 'Leads') {
                var model = this.context.parent.get('model');
                return model && !model.get('converted') && !_.isUndefined(model.get('converted'));
            }
            return false;
        }
        return true;
    }
}) },
"status": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Leads.StatusField
 * @alias SUGAR.App.view.fields.BaseLeadsStatusField
 * @extends View.Fields.Base.EnumField
 */
({
	// Status FieldTemplate (base)

extendsFrom: 'EnumField',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);
        this.type = 'enum';
    },

/**
     * @inheritdoc
     *
     * Filter out the Converted option if the Lead is not already converted.
     */
    _filterOptions: function(options) {
        var status = this.model.get('status');
        var filteredOptions = this._super('_filterOptions', [options]);

return (!_.isUndefined(status) && status !== 'Converted') ?
            _.omit(filteredOptions, 'Converted') :
            filteredOptions;
    }

}) }
}}
,
"views": {
"base": {
"convert-results": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Convert-results View (base)

extendsFrom: 'ConvertResultsView',

/**
     * Build a collection of associated models and re-render the view
     */
    populateResults: function() {
        var model;

//only show related records if lead is converted
        if (!this.model.get('converted')) {
            return;
        }

this.associatedModels.reset();

model = this.buildAssociatedModel('Contacts', 'contact_id', 'contact_name');
        if (model) {
            this.associatedModels.push(model);
        }
        model = this.buildAssociatedModel('Accounts', 'account_id', 'account_name');
        if (model) {
            this.associatedModels.push(model);
        }
        model = this.buildAssociatedModel('Opportunities', 'opportunity_id', 'converted_opp_name');
        if (model) {
            this.associatedModels.push(model);
        }
        app.view.View.prototype.render.call(this);
    },

/**
     * Build an associated model based on given id & name fields on the Lead record
     *
     * @param {String} moduleName
     * @param {String} idField
     * @param {String} nameField
     * @return {*} model or false if id field is not set on the lead
     */
    buildAssociatedModel: function(moduleName, idField, nameField) {
        var moduleSingular = app.lang.getAppListStrings('moduleListSingular'),
            model;

if (_.isEmpty(this.model.get(idField))) {
            return false;
        }

model = app.data.createBean(moduleName, {
            id: this.model.get(idField),
            name: this.model.get(nameField),
            row_title: moduleSingular[moduleName],
            _module: moduleName,
            target_module: moduleName
        });
        model.module = moduleName;
        return model;
    }
}) },
"pipeline-recordlist-content": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Leads.PipelineRecordlistContentView
 * @alias App.view.views.BaseLeadsPipelineRecordlistContentView
 * @extends View.Views.Base.PipelineRecordlistContentView
 */
({
	// Pipeline-recordlist-content View (base)

extendsFrom: 'PipelineRecordlistContentView',

/**
     * Overrides the base function to account for the lead conversion functionality
     * @override
     */
    saveModel: function(model, pipelineData) {
        if (this.headerField === 'status') {
            // If the lead has already been converted, don't allow the user to change
            // its status. If the lead status is being changed to from non-converted
            // to converted, open the lead conversion layout in a drawer instead of
            // the normal change saving process
            if (model.get('converted')) {
                this._postChange(model, true, pipelineData);
                var moduleName = app.lang.getModuleName(this.module, {plural: false});
                app.alert.show('error_converted', {
                    level: 'error',
                    messages: app.lang.get('LBL_PIPELINE_ERR_CONVERTED', this.module, {moduleSingular: moduleName})
                });
                return;
            } else if (_.isObject(pipelineData.newCollection) &&
                pipelineData.newCollection.headerKey === 'Converted') {
                app.drawer.open({
                    layout: 'convert',
                    context: {
                        forceNew: true,
                        skipFetch: true,
                        module: 'Leads',
                        leadsModel: model
                    }
                }, _.bind(function(success) {
                    this._callWithTileModel(model, '_postChange', [!success, pipelineData]);
                }, this));
                return;
            }
        }

this._super('saveModel', [model, pipelineData]);
    }
}) },
"convert-headerpane": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Convert-headerpane View (base)

extendsFrom: 'HeaderpaneView',

events: {
        'click [name=save_button]:not(".disabled")': 'initiateSave',
        'click [name=cancel_button]': 'initiateCancel'
    },

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super("initialize", [options]);
        this.context.on('lead:convert-save:toggle', this.toggleSaveButton, this);
    },

/**
     * @override
     *
     * Grabs the lead's name and format the title such as `Convert: <name>`.
     */
    _formatTitle: function(title) {
        var leadsModel = this.context.get('leadsModel'),
            name = !_.isUndefined(leadsModel.get('name')) ?
                leadsModel.get('name') :
                leadsModel.get('first_name') + ' ' + leadsModel.get('last_name');
        return app.lang.get(title, this.module) + ': ' + name;
    },

/**
     * When finish button is clicked, send this event down to the convert layout to wrap up
     */
    initiateSave: function() {
        this.context.trigger('lead:convert:save');
    },

/**
     * When cancel clicked, hide the drawer
     */
    initiateCancel : function() {
        app.drawer.close();
    },

/**
     * Enable/disable the Save button
     *
     * @param enable true to enable, false to disable
     */
    toggleSaveButton: function(enable) {
        this.$('[name=save_button]').toggleClass('disabled', !enable);
    }
}) },
"record": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Record View (base)

extendsFrom: 'RecordView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['HistoricalSummary']);
        this._super('initialize', [options]);
        this.listenTo(this.context, 'button:custom_sf_iframebutton:click', this.viewInMarket);
    },

/**
     * Remove id, status and converted fields
     * (including associations created during conversion) when duplicating a Lead
     * @param prefill
     */
    setupDuplicateFields: function(prefill){
        // Clear sugar predict fields
        const predictFields = [
            'ai_icp_fit_score_classification',
            'ai_icp_fit_score_classification_c',
            'ai_conv_score_classification',
            'ai_conv_score_classification_c'
        ];
        predictFields.forEach(fieldName => prefill.unset(fieldName));

extendsFrom: 'CreateView',

getCustomSaveOptions: function(){
        var options = {};

if(this.context.get('prospect_id')) {
            options.params = {};
            // Needed for populating the relationship
            options.params.relate_to = 'Prospects';
            options.params.relate_id = this.context.get('prospect_id');
            this.context.unset('prospect_id');
        }

return options;
    }
}) },
"convert-options": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Convert-options View (base)

/**
     * @inheritdoc
     *
     * Prevent render if transfer activities action is not move.
     */
    _render: function() {
        var transferActivitiesAction = app.metadata.getConfig().leadConvActivityOpt;
        if (transferActivitiesAction === 'move') {
            this.model.setDefault('transfer_activities', true);
            this._super('_render');
        }
    }
}) },
"convert-panel-header": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Convert-panel-header View (base)

events: {
        'click .toggle-link': 'handleToggleClick'
    },

/**
     * @inheritdoc
     */
    initialize: function(options) {
        options.meta.buttons = this.getButtons(options);
        app.view.View.prototype.initialize.call(this, options);
        this.layout.on('toggle:change', this.handleToggleChange, this);
        this.layout.on('lead:convert-dupecheck:pending', this.setDupeCheckPending, this);
        this.layout.on('lead:convert-dupecheck:complete', this.setDupeCheckResults, this);
        this.layout.on('lead:convert-panel:complete', this.handlePanelComplete, this);
        this.layout.on('lead:convert-panel:reset', this.handlePanelReset, this);
        this.layout.on('lead:convert:duplicate-selection:change', this.setAssociateButtonState, this);
        this.context.on('lead:convert:' + this.meta.module + ':shown', this.handlePanelShown, this);
        this.context.on('lead:convert:' + this.meta.module + ':hidden', this.handlePanelHidden, this);
        this.initializeSubTemplates();
    },

/**
     * Return the metadata for the Associate/Reset buttons to be added to the
     * convert panel header
     *
     * @param {Object} options
     * @return {Array}
     */
    getButtons: function(options) {
        return [
            {
                name: 'associate_button',
                type: 'button',
                label: this.getLabel(
                    'LBL_CONVERT_CREATE_MODULE',
                    {'moduleName': options.meta.moduleSingular}
                ),
                css_class: 'btn-primary disabled'
            },
            {
                name: 'reset_button',
                type: 'button',
                label: 'LBL_CONVERT_RESET_PANEL',
                css_class: 'btn-invisible btn-link'
            }
        ];
    },

/**
     * Initialize the Reset button to be hidden on render
     * @inheritdoc
     */
    _render: function() {
        app.view.View.prototype._render.call(this);
        this.getField('reset_button').hide();
    },

/**
     * Compile data from the convert panel layout with some of the metadata to
     * be used when rendering sub-templates
     *
     * @return {Object}
     */
    getCurrentState: function() {
        var currentState = _.extend({}, this.layout.currentState, {
            create: (this.layout.currentToggle === this.layout.TOGGLE_CREATE_LAYOUT),
            labelModule: this.module,
            moduleInfo: {'moduleName': this.meta.moduleSingular},
            required: this.meta.required
        });

if (_.isNumber(currentState.dupeCount)) {
            currentState.duplicateCheckResult = {'duplicateCount': currentState.dupeCount};
        }

return currentState;
    },

/**
     * Pull in the sub-templates to be used to render & re-render pieces of the convert header
     * Pieces of the convert header change based on various states the panel is in
     */
    initializeSubTemplates: function() {
        this.tpls = {};
        this.initial = {};

this.tpls.title = app.template.getView(this.name + '.title', this.module);
        this.initial.title = this.tpls.title(this.getCurrentState());

this.tpls.dupecheckPending = app.template.getView(this.name + '.dupecheck-pending', this.module);
        this.tpls.dupecheckResults = app.template.getView(this.name + '.dupecheck-results', this.module);
    },

/**
     * Toggle the subviews based on which link was clicked
     *
     * @param {Event} event The click event on the toggle link
     */
    handleToggleClick: function(event) {
        var nextToggle = this.$(event.target).data('next-toggle');
        this.layout.trigger('toggle:showcomponent', nextToggle);
        event.preventDefault();
        event.stopPropagation();
    },

/**
     * When switching between sub-views, change the appropriate header components:
     * - Title changes to reflect New vs. Select (showing New ModuleName or just ModuleName)
     * - Dupe check results are shown/hidden based on whether dupe view is shown
     * - Change the toggle link to allow the user to toggle back to the other one
     * - Enable Associate button when on create view - Enable/Disable button based
     *   on whether dupe selected on dupe view
     *
     * @param {string} toggle Which view is now being displayed
     */
    handleToggleChange: function(toggle) {
        this.renderTitle();
        this.toggleDupeCheckResults(toggle === this.layout.TOGGLE_DUPECHECK);
        this.setSubViewToggle(toggle);
        this.setAssociateButtonState();
    },

/**
     * When opening a panel, change the appropriate header components:
     * - Activate the header
     * - Display the subview toggle link
     * - Enable Associate button when on create view - Enable/Disable button
     *   based on whether dupe selected on dupe view
     * - Mark active indicator pointing up
     */
    handlePanelShown: function() {
        this.$('.accordion-heading').addClass('active');
        this.toggleSubViewToggle(true);
        this.setAssociateButtonState();
        this.toggleActiveIndicator(true);
    },

/**
     * When hiding a panel, change the appropriate header components:
     * - Deactivate the header
     * - Hide the subview toggle link
     * - Disable the Associate button
     * - Mark active indicator pointing down
     */
    handlePanelHidden: function() {
        this.$('.accordion-heading').removeClass('active');
        this.toggleSubViewToggle(false);
        this.setAssociateButtonState(false);
        this.toggleActiveIndicator(false);
    },

/**
     * When a panel has been marked complete, change the appropriate header components:
     * - Mark the step circle as check box
     * - Title changes to show the record associated
     * - Hide duplicate check results
     * - Hide the subview toggle link
     * - Switch to Reset button
     */
    handlePanelComplete: function() {
        this.setStepCircle(true);
        this.renderTitle();
        this.toggleDupeCheckResults(false);
        this.toggleSubViewToggle(false);
        this.toggleButtons(true);
    },

/**
     * When a panel has been reset, change the appropriate header components:
     * - Mark the step circle back to step number
     * - Title changes back to incomplete (showing New ModuleName or just ModuleName)
     * - Show duplicate check count (if any found)
     * - Switch to back to Associate button
     * - Enable Associate button when on create view - Enable/Disable button
     *   based on whether dupe selected on dupe view
     */
    handlePanelReset: function() {
        this.setStepCircle(false);
        this.renderTitle();
        this.toggleDupeCheckResults(true);
        this.toggleButtons(false);
        this.setAssociateButtonState();
    },

/**
     * Switch between check mark and step number
     *
     * @param {boolean} complete Whether to mark panel completed
     */
    setStepCircle: function(complete) {
        var $stepCircle = this.$('.step-circle');
        if (complete) {
            $stepCircle.addClass('complete');
        } else {
            $stepCircle.removeClass('complete');
        }
    },

/**
     * Render the title based on current state Create vs DupeCheck and
     * Complete vs. Incomplete
     */
    renderTitle: function() {
        this.$('.title').html(this.tpls.title(this.getCurrentState()));
    },

/**
     * Put up "Searching for duplicates" message
     */
    setDupeCheckPending: function() {
        this.renderDupeCheckResults('pending');
    },

/**
     * Display duplicate results (if any found) or hide subview links if none found
     *
     * @param {number} duplicateCount Number of duplicates found
     */
    setDupeCheckResults: function(duplicateCount) {
        if (duplicateCount > 0) {
            this.renderDupeCheckResults('results');
        } else {
            this.renderDupeCheckResults('clear');
        }
        this.setSubViewToggleLabels(duplicateCount);
    },

/**
     * Render either dupe check results or pending (or empty if no dupes found)
     *
     * @param {string} type Which message to show - `results` or `pending`
     */
    renderDupeCheckResults: function(type) {
        var results = '';
        if (type === 'results') {
            results = this.tpls.dupecheckResults(this.getCurrentState());
        } else if (type === 'pending') {
            results = this.tpls.dupecheckPending(this.getCurrentState());
        }
        this.$('.dupecheck-results').text(results);
    },

/**
     * Show/hide dupe check results
     * If duplicate already selected, results will not be shown
     *
     * @param {boolean} show Whether to show the duplicate check results
     */
    toggleDupeCheckResults: function(show) {
        // if we are trying to show this, but we already have a dupeSelected, change the show to false
        if (show && this.layout.currentState.dupeSelected) {
            show = false;
        }
        this.$('.dupecheck-results').toggle(show);
    },

/**
     * Show/hide the subview toggle links altogether
     * If panel is complete, the subview toggle will not be shown
     *
     * @param {boolean} show Whether to show the subview toggle
     */
    toggleSubViewToggle: function(show) {
        if (this.layout.currentState.complete) {
            show = false;
        }
        this.$('.subview-toggle').toggleClass('hide', !show);
    },

/**
     * Show/hide appropriate toggle link for the subview being displayed
     *
     * @param {string} nextToggle Css class labeling the next toggle
     */
    setSubViewToggle: function(nextToggle) {
        _.each(['dupecheck', 'create-layout'], function(currentToggle) {
            this.toggleSubViewLink(currentToggle, (nextToggle === currentToggle));
        }, this);
    },

/**
     * Show/hide a single subview toggle link
     *
     * @param {string} currentToggle Css class labeling the current toggle
     * @param {boolean} show Whether to show the toggle link
     */
    toggleSubViewLink: function(currentToggle, show) {
        this.$('.subview-toggle .' + currentToggle).toggle(show);
    },

/**
     * Switch subview toggle labels based on whether duplicates were found or not
     *
     * @param {number} duplicateCount
     */
    setSubViewToggleLabels: function(duplicateCount) {
        if (duplicateCount > 0) {
            this.setSubViewToggleLabel('dupecheck', 'LBL_CONVERT_IGNORE_DUPLICATES');
            this.setSubViewToggleLabel('create-layout', 'LBL_CONVERT_BACK_TO_DUPLICATES');
        } else {
            this.setSubViewToggleLabel('dupecheck', 'LBL_CONVERT_SWITCH_TO_CREATE');
            this.setSubViewToggleLabel('create-layout', 'LBL_CONVERT_SWITCH_TO_SEARCH');
        }
    },

/**
     * Set label for given subview toggle
     *
     * @param {string} currentToggle Css class labeling the current toggle
     * @param {string} label Label to replace the toggle text with
     */
    setSubViewToggleLabel: function(currentToggle, label) {
        this.$('.subview-toggle .' + currentToggle).text(this.getLabel(label));
    },

/**
     * Toggle between Associate and Reset buttons
     *
     * @param {boolean} complete
     */
    toggleButtons: function(complete) {
        var associateButton = 'associate_button',
            resetButton = 'reset_button';

if (complete) {
            this.getField(associateButton).hide();
            this.getField(resetButton).show();
        } else {
            this.getField(associateButton).show();
            this.getField(resetButton).hide();
        }
    },

/**
     * Activate/Deactivate the Associate button based on which subview is active
     * and whether the panel itself is active (keep disabled when panel not active)
     *
     * @param {boolean} [activate]
     */
    setAssociateButtonState: function(activate) {
        let shouldActivate = _.isUndefined(activate) ? null : false;
        const $associateButton = this.$('[name="associate_button"]');
        const panelActive = this.$('.accordion-heading').hasClass('active');

//use current state to determine activate if not explicit in call
        if (shouldActivate === null) {
            if (this.layout.currentToggle === this.layout.TOGGLE_CREATE_LAYOUT) {
                shouldActivate = true;
            } else {
                shouldActivate = this.layout.currentState.dupeSelected;
            }
        }

this.setAssociateButtonLabel(this.layout.currentToggle === this.layout.TOGGLE_CREATE_LAYOUT);

//only activate if current panel is active
        if (shouldActivate && panelActive) {
            $associateButton.removeClass('disabled');
        } else {
            $associateButton.addClass('disabled');
        }
    },

/**
     * Set the label for the Associate Button
     *
     * @param {boolean} isCreate
     */
    setAssociateButtonLabel: function(isCreate) {
        var label = 'LBL_CONVERT_SELECT_MODULE';
        if (isCreate) {
            label = 'LBL_CONVERT_CREATE_MODULE';
        }
        this.$('[name="associate_button"]').html(this.getLabel(label, {'moduleName': this.meta.moduleSingular}));
    },

/**
     * Toggle the active indicator up/down
     *
     * @param {boolean} active
     */
    toggleActiveIndicator: function(active) {
        var $activeIndicator = this.$('.active-indicator i');
        $activeIndicator.toggleClass('sicon-chevron-down', active);
        $activeIndicator.toggleClass('sicon-chevron-right', !active);
    },

/**
     * Get translated strings from the Leads module language file
     *
     * @param {string} key The app/mod string
     * @param {Object} [context] Any placeholder data to populate in the string
     * @return {string} The translated string
     */
    getLabel: function(key, context) {
        context = context || {};
        return app.lang.get(key, 'Leads', context);
    }
}) },
"activity-card-header": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Leads.ActivityCardHeaderView
 * @alias SUGAR.App.view.views.BaseLeadsActivityCardHeaderView
 * @extends View.Views.Base.ActivityCardHeaderView
 */
({
	// Activity-card-header View (base)

extendsFrom: 'ActivityCardHeaderView',

/**
     * @inheritdoc
     */
    setUsersFields: function() {
        const panel = this.getUsersPanel();

this.userField = _.find(panel.fields, function(field) {
            return field.name === 'assigned_user_name';
        });

this.hasAvatarUser = !!this.userField;
    }
}) }
}}
,
"layouts": {
"base": {
"convert-panel": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Convert-panel Layout (base)

extendsFrom: 'ToggleLayout',

TOGGLE_DUPECHECK: 'dupecheck',
    TOGGLE_CREATE: 'create',
    TOGGLE_CREATE_LAYOUT: 'create-layout',

availableToggles: {
        'dupecheck': {},
        'create': {},
        'create-layout': {}
    },

//selectors
    accordionHeading: '.accordion-heading',
    accordionBody: '.accordion-body',

//turned on, but could be turned into a setting later
    autoCompleteEnabled: true,

/**
     * @inheritdoc
     */
    initialize: function(options) {
        var convertPanelEvents;

this.meta = options.meta;
        this._setModuleSpecificValues();

convertPanelEvents = {};
        convertPanelEvents['click .accordion-heading.enabled'] = 'togglePanel';
        convertPanelEvents['click [name="associate_button"]'] = 'handleAssociateClick';
        convertPanelEvents['click [name="reset_button"]'] = 'handleResetClick';
        this.events = _.extend({}, this.events, convertPanelEvents);
        this.plugins = _.union(this.plugins || [], [
            'FindDuplicates'
        ]);

this.currentState = {
            complete: false,
            dupeSelected: false
        };
        this.toggledOffDupes = false;

this._super('initialize', [options]);

this._initSubpanelsData();
        this.addSubComponents();

this.context.on('lead:convert:populate', this.handlePopulateRecords, this);
        this.context.on('lead:convert:' + this.meta.module + ':enable', this.handleEnablePanel, this);
        this.context.on('lead:convert:' + this.meta.moduleNumber + ':open', this.handleOpenRequest, this);
        this.context.on('lead:convert:exit', this.turnOffUnsavedChanges, this);
        this.context.on('lead:convert:' + this.meta.module + ':shown', this.handleShowComponent, this);

//if this panel is dependent on others - listen for changes and react accordingly
        this.addDependencyListeners();

//open the first module upon the first autocomplete check completion
        if (this.meta.moduleNumber === 1) {
            this.once('lead:autocomplete-check:complete', this.handleOpenRequest, this);
        }
    },

/**
     * Initializes the metadata that drives which create subpanels are included
     * on this convert panel
     *
     * @private
     */
    _initSubpanelsData: function() {
        this.subpanelsMeta = this.meta.subpanels || [];

// Check for Opps+RLI subpanel settings and add the RLI create subpanel
        // to the subpanels meta if needed
        if (this.meta.module === 'Opportunities' && this.meta.enableRlis) {
            this.subpanelsMeta.push({
                layout: 'subpanel-create',
                label: 'LBL_RLI_SUBPANEL_TITLE',
                override_subpanel_list_view: 'subpanel-for-opportunities-create',
                context: {
                    link: 'revenuelineitems'
                },
                settings: {
                    allowEmpty: !this.meta.requireRlis,
                    copyData: this.meta.copyDataToRlis
                }
            });
        }
    },

/**
     * Retrieve module specific values (like modular singular name and whether
     * dupe check is enabled at a module level).
     * @private
     */
    _setModuleSpecificValues: function() {
        var module = this.meta.module;
        this.meta.modulePlural = app.lang.getAppListStrings('moduleList')[module] || module;
        this.meta.moduleSingular = app.lang.getAppListStrings('moduleListSingular')[module] ||
            this.meta.modulePlural;

//enable or disable duplicate check
        var moduleMetadata = app.metadata.getModule(module);
        this.meta.enableDuplicateCheck = (moduleMetadata && moduleMetadata.dupCheckEnabled) ||
            this.meta.enableDuplicateCheck ||
            false;
        this.meta.duplicateCheckOnStart = this.meta.enableDuplicateCheck && this.meta.duplicateCheckOnStart;
    },

/**
     * Used by toggle layout to determine where to place sub-components.
     *
     * @param {Object} component
     * @return {jQuery}
     */
    getContainer: function(component) {
        if (component.name === 'convert-panel-header') {
            return this.$('[data-container="header"]');
        } else {
            return this.$('[data-container="inner"]');
        }
    },

/**
     * Add all sub-components of the panel.
     */
    addSubComponents: function() {
        this.addHeaderComponent();
        this.addDupeCheckComponent();
        this.addRecordCreateComponent();
    },

/**
     * Add the panel header view.
     */
    addHeaderComponent: function() {
        var header = app.view.createView({
            context: this.context,
            type: 'convert-panel-header',
            layout: this,
            meta: this.meta
        });
        this.addComponent(header);
    },

/**
     * Add the duplicate check layout along with events to listen for changes to
     * the duplicate view.
     */
    addDupeCheckComponent: function() {
        var leadsModel = this.context.get('leadsModel'),
            context = this.context.getChildContext({
                'module': this.meta.module,
                'forceNew': true,
                'skipFetch': true,
                'dupelisttype': 'dupecheck-list-select',
                'collection': this.createDuplicateCollection(leadsModel, this.meta.module),
                'layoutName': 'records',
                'dataView': 'selection-list'
            });
        context.prepare();

this.duplicateView = app.view.createLayout({
            context: context,
            type: this.TOGGLE_DUPECHECK,
            layout: this,
            module: context.get('module')
        });
        this.duplicateView.context.on('change:selection_model', this.handleDupeSelectedChange, this);
        this.duplicateView.collection.on('reset', this.dupeCheckComplete, this);
        this.addComponent(this.duplicateView);
    },

/**
     * Add the create toggle layout, including the create view and any
     * applicable create subpanels
     */
    addRecordCreateComponent: function() {
        // Create the context for all the record create components
        let context = this._buildRecordCreateContext();

// Create a single layout that will contain all the create subcomponents.
        // This is done so that both the record create view and create subpanels
        // will be wrapped into one component that can be toggled
        this.toggleLayout = this._buildRecordCreateToggleLayout(context);

// Add the record create view component to the toggle layout
        this.createView = this._buildRecordCreateView(context);
        this.toggleLayout.addComponent(this.createView);

// Add the create subpanels component to the toggle layout if needed
        if (!_.isEmpty(this.subpanelsMeta)) {
            this.createSubpanelsLayout = this._buildRecordCreateSubpanelsLayout(context);
            this.toggleLayout.addComponent(this.createSubpanelsLayout);
        }

// Finally, add the toggle-able layout to this toggle layout
        this.addComponent(this.toggleLayout);
    },

/**
     * Builds the context needed for the create components
     *
     * @return {Context} the record create context
     * @private
     */
    _buildRecordCreateContext: function() {
        let context = this.context.getChildContext({
            module: this.meta.module,
            forceNew: true,
            create: true
        });
        context.prepare();
        return context;
    },

/**
     * Builds the layout that will be used as the toggle-able layout
     * containing all the components related to creating a record
     *
     * @param {Context} context the context to use for the toggle-able layout
     * @return {Layout} the toggle-able layout
     * @private
     */
    _buildRecordCreateToggleLayout: function(context) {
        return app.view.createLayout({
            context: context,
            type: 'base',
            name: this.TOGGLE_CREATE_LAYOUT,
            module: context.get('module'),
            layout: this
        });
    },

/**
     * Builds the create view that will be used to create the panel's record
     *
     * @param {Context} context the context to use for the create view
     * @return {View} the create view
     * @private
     */
    _buildRecordCreateView: function(context) {
        let createView = app.view.createView({
            context: context,
            type: this.TOGGLE_CREATE,
            module: context.get('module'),
            layout: this.toggleLayout
        });
        createView.meta = this.removeFieldsFromMeta(createView.meta, this.meta);
        createView.enableHeaderButtons = false;

return createView;
    },

/**
     * Builds the subpanels layout that will be used to create records related
     * to the panel's record
     *
     * @param {Context} context the context to use for the subpanels layout
     * @return {Layout} the subpanels layout
     * @private
     */
    _buildRecordCreateSubpanelsLayout: function(context) {
        let createSubpanelsLayout = app.view.createLayout({
            context: context,
            type: 'subpanels-create',
            layout: this.toggleLayout
        });
        createSubpanelsLayout.initComponents(this.subpanelsMeta);
        this._initSubpanelListeners(createSubpanelsLayout);

return createSubpanelsLayout;
    },

/**
     * Initializes listeners for any create subpanels as needed
     *
     * @private
     */
    _initSubpanelListeners: function(subpanelsLayout) {
        // Add listeners to the subpanels as needed
        _.each(subpanelsLayout.context.children, function(childContext) {
            if (childContext.get('isCreateSubpanel')) {
                // Product Catalog listeners for Revenue Line Items subpanels
                if (childContext.get('module') === 'RevenueLineItems') {
                    let convertComponent = this.closestComponent('convert');

// When we open the Product Catalog/Quick Picks previews,
                    // show the "Add" button only if this panel is currently
                    // enabled and open
                    convertComponent.before('productcatalog:preview:add:disable', function() {
                        return !(this.isPanelEnabled() && this.isPanelOpen());
                    }, this);

// When we click a Product on the Product Catalog/Quick Picks
                    // dashlets, add it to this subpanel only if this panel is
                    // currently enabled and opened
                    convertComponent.before('productCatalogDashlet:add:allow', function() {
                        return this.isPanelEnabled() && this.isPanelOpen();
                    }, this);
                }

// If this subpanel is set to copy data, add listeners to copy
                // Lead data to new rows
                let subpanelSettings = childContext.get('settings');
                if (subpanelSettings && subpanelSettings.copyData) {
                    // If the subpanel was initialized with any models, make
                    // sure the Lead data is copied once the Lead is fetched
                    let leadsModel = this.context.get('leadsModel');
                    leadsModel.once('sync', function() {
                        _.each(childContext.get('collection').models, function(subpanelModel) {
                            this.populateSubpanelRecord(subpanelModel);
                        }, this);
                    }, this);

// Whenever subsequent subpanel models are created, copy
                    // data from the Lead as needed
                    this.listenTo(childContext, 'subpanel-list-create:row:added', this.populateSubpanelRecord);
                }
            }
        }, this);
    },

/**
     * Copies attributes from the Lead model to the newly created subpanel model
     * @param {Bean} subpanelModel the newly created subpanel model
     */
    populateSubpanelRecord(subpanelModel) {
        // Get the Lead model we are copying from
        let leadsModel = this.context.get('leadsModel');

// Get the list of fields that can be safely copied
        let copyableAttrs = this._getCopyableAttrs(leadsModel, subpanelModel);

// Copy the fields from the Lead to the subpanel model
        let attrs = {};
        _.each(copyableAttrs, function(value, key) {
            if (leadsModel.has(key) && subpanelModel.get(key) !== value) {
                subpanelModel.setDefault(key, value);
                attrs[key] = value;
            }
        }, this);
        subpanelModel.set(attrs);
    },

/**
     * Filters and returns the attributes of the fromModel that are valied to be copied to the toModel
     * @param {Bean} fromModel the source model to copy attributes from
     * @param {Bean} toModel the destination model to copy attributes to
     * @return {Object} the subset of the source model's attributes that can be copied to the destination model
     * @private
     */
    _getCopyableAttrs(fromModel, toModel) {
        let fromModule = fromModel.module || fromModel.get('_module');
        let toModule = toModel.module || toModel.get('_module');

let fromFieldMeta = app.metadata.getModule(fromModule, 'fields');
        let toFieldMeta = app.metadata.getModule(toModule, 'fields');

return _.pick(fromModel.attributes, function(value, field) {
            return app.acl.hasAccessToModel('edit', toModel, field) &&
                fromFieldMeta[field] &&
                toFieldMeta[field] &&
                fromFieldMeta[field].type === toFieldMeta[field].type &&
                (_.isUndefined(fromFieldMeta[field].duplicate_on_record_copy) ||
                    fromFieldMeta[field].duplicate_on_record_copy !== 'no') &&
                this.shouldSourceValueBeCopied(value);
        }, this);
    },

/**
     * Sets the listeners for changes to the dependent modules.
     */
    addDependencyListeners: function() {
        _.each(this.meta.dependentModules, function(details, module) {
            this.context.on('lead:convert:' + module + ':complete', this.updateFromDependentModuleChanges, this);
            this.context.on('lead:convert:' + module + ':reset', this.resetFromDependentModuleChanges, this);
        }, this);
    },

/**
     * When duplicate results are received (or dupe check did not need to be
     * run) toggle to the appropriate view.
     *
     * If duplicates were found for a required module, auto select the first
     * duplicate.
     */
    dupeCheckComplete: function() {
        if (this.disposed) {
            return;
        }

this.currentState.dupeCount = this.duplicateView.collection.length;
        this.runAutoCompleteCheck();
        if (this.currentState.dupeCount !== 0) {
            this.showComponent(this.TOGGLE_DUPECHECK);
            if (this.meta.required) {
                this.selectFirstDuplicate();
            }
        } else if (!this.toggledOffDupes) {
            this.showComponent(this.TOGGLE_CREATE_LAYOUT);
        }

this.toggledOffDupes = true; //flag so we only toggle once
        this.trigger('lead:convert-dupecheck:complete', this.currentState.dupeCount);
    },

/**
     * Check to see if the panel should be automatically marked as complete
     *
     * Required panels are marked complete when there are no duplicates and
     * the create form passes validation.
     */
    runAutoCompleteCheck: function() {
        //Bail out if we've already completed the check
        if (this.autoCompleteCheckComplete) {
            return;
        }

if (this.autoCompleteEnabled && this.meta.required && this.currentState.dupeCount === 0) {
            this.createView.once('render', this.runAutoCompleteValidation, this);
        } else {
            this.markAutoCompleteCheckComplete();
        }
    },

/**
     * Run validation, mark panel complete if valid without any alerts
     */
    runAutoCompleteValidation: function() {
        var view = this.createView,
            model = view.model;

model.isValidAsync(view.getFields(view.module), _.bind(function(isValid) {
            if (isValid) {
                this.markPanelComplete(model);
            }
            this.markAutoCompleteCheckComplete();
        }, this));
    },

/**
     * Set autocomplete check complete flag and trigger event
     */
    markAutoCompleteCheckComplete: function() {
        this.autoCompleteCheckComplete = true;
        this.trigger('lead:autocomplete-check:complete');
    },

/**
     * Select the first item in the duplicate check list.
     */
    selectFirstDuplicate: function() {
        var list = this.duplicateView.getComponent('dupecheck-list-select');
        if (list) {
            list.once('render', function() {
                var radio = this.$('input[type=radio]:first');
                if (radio) {
                    radio.prop('checked', true);
                    radio.click();
                }
            }, this);
        }
    },

/**
     * Removes fields from the meta and replaces with empty html container
     * based on the modules config option - hiddenFields.
     *
     * Example: Account name drop-down should not be available on contact
     * and opportunity module.
     *
     * @param {Object} meta The original metadata
     * @param {Object} moduleMeta Metadata defining fields to hide
     * @return {Object} The metadata after hidden fields removed
     */
    removeFieldsFromMeta: function(meta, moduleMeta) {
        if (moduleMeta.hiddenFields) {
            _.each(meta.panels, function(panel) {
                _.each(panel.fields, function(field, index, list) {
                    if (_.isString(field)) {
                        field = {name: field};
                    }
                    if (moduleMeta.hiddenFields[field.name]) {
                        field.readonly = true;
                        field.required = false;
                        list[index] = field;
                    }
                });
            }, this);
        }
        return meta;
    },

/**
     * Toggle the accordion body for this panel.
     */
    togglePanel: function() {
        this.$(this.accordionBody).collapse('toggle');
    },

/**
     * When one panel is completed it notifies the next panel to open
     * This function handles that request and will...
     * - wait for auto complete check to finish before doing anything
     * - pass along request to the next if already complete or not enabled
     * - open the panel otherwise
     */
    handleOpenRequest: function() {
        if (this.autoCompleteCheckComplete !== true) {
            this.once('lead:autocomplete-check:complete', this.handleOpenRequest, this);
        } else {
            if (this.currentState.complete || !this.isPanelEnabled()) {
                this.requestNextPanelOpen();
            } else {
                this.openPanel();
            }
        }
    },

/**
     * Check if the the current panel is enabled.
     *
     * @return {boolean}
     */
    isPanelEnabled: function() {
        return this.$(this.accordionHeading).hasClass('enabled');
    },

/**
     * Check if the current panel is open.
     *
     * @return {boolean}
     */
    isPanelOpen: function() {
        return this.$(this.accordionBody).hasClass('show');
    },

/**
     * Open the body of the panel if enabled (and not already open).
     */
    openPanel: function() {
        if (this.isPanelEnabled()) {
            if (this.isPanelOpen()) {
                this.context.trigger('lead:convert:' + this.meta.module + ':shown');
            } else {
                this.$(this.accordionBody).collapse('show');
            }
        }
    },

/**
     * When showing create view, render the view, trigger duplication
     * of fields with special handling (like image fields).
     *
     * @inheritdoc
     */
    showComponent: function(name) {
        this._super('showComponent', [name]);
        if (this.currentToggle === this.TOGGLE_CREATE_LAYOUT) {
            this.createViewRendered = true;
        }
        this.handleShowComponent();
    },

/**
     * Render the create view.
     */
    handleShowComponent: function() {
        if (this.currentToggle === this.TOGGLE_CREATE_LAYOUT &&
            this.createView.meta.useTabsAndPanels &&
            !this.createViewRendered) {
            this.createView.render();
            this.createViewRendered = true;
        }
    },

/**
     * Close the body of the panel (if not already closed)
     */
    closePanel: function() {
        this.$(this.accordionBody).collapse('hide');
    },

/**
     * Handle click of Associate button - running validation if on create view
     * or marking complete if on dupe view.
     *
     * @param {Event} event
     */
    handleAssociateClick: function(event) {
        //ignore clicks if button is disabled
        if (!$(event.currentTarget).hasClass('disabled')) {
            if (this.currentToggle === this.TOGGLE_CREATE_LAYOUT) {
                this.runCreateValidation({
                    valid: _.bind(this.markPanelComplete, this),
                    invalid: _.bind(this.resetPanel, this)
                });
            } else {
                this.markPanelComplete(this.duplicateView.context.get('selection_model'));
            }
        }
        event.stopPropagation();
    },

/**
     * Run validation on the create model and perform specified callbacks based
     * on the validity of the model.
     *
     * @param {Object} callbacks Callbacks to be run after validation is performed.
     * @param {Function} callbacks.valid Run if model is valid.
     * @param {Function} callbacks.invalid Run if model is invalid.
     */
    runCreateValidation: function(callbacks) {
        var view = this.createView,
            model = view.model;

// Validate both the model and any related models in create subpanels, if they exist
        async.parallel([
            _.bind(view.validateModelWaterfall, view),
            _.bind(view.validateSubpanelModelsWaterfall, view)
        ], _.bind(function(hasError) {
            if (hasError) {
                model.trigger('error:validation');
                callbacks.invalid(model);
            } else {
                callbacks.valid(model);
            }
        }, this));
    },

/**
     * Mark the panel as complete, close the panel body, and tell the next panel
     * to open.
     *
     * @param {Data.Bean} model
     */
    markPanelComplete: function(model) {
        this.currentState.associatedName = app.utils.getRecordName(model);
        this.currentState.complete = true;
        this.context.trigger('lead:convert-panel:complete', this.meta.module, model);
        this.trigger('lead:convert-panel:complete', this.currentState.associatedName);

app.alert.dismissAll('error');

//re-run validation if create model changes after completion
        if (!model.id) {
            model.on('change', this.runPostCompletionValidation, this);
        }

//if this panel was open, close & tell the next panel to open
        if (this.isPanelOpen()) {
            this.closePanel();
            this.requestNextPanelOpen();
        }
    },

/**
     * Re-run create model validation after a panel has been marked completed
     */
    runPostCompletionValidation: function() {
        this.runCreateValidation({
            valid: $.noop,
            invalid: _.bind(this.resetPanel, this)
        });
    },

/**
     * Trigger event to open the next panel in the list
     */
    requestNextPanelOpen: function() {
        this.context.trigger('lead:convert:' + (this.meta.moduleNumber + 1) + ':open');
    },

/**
     * When reset button is clicked - reset this panel and open it
     * @param {Event} event
     */
    handleResetClick: function(event) {
        this.resetPanel();
        this.openPanel();
        event.stopPropagation();
    },

/**
     * Reset the panel back to a state the user can modify associated values
     */
    resetPanel: function() {
        this.createView.model.off('change', this.runPostCompletionValidation, this);
        this.currentState.complete = false;
        this.context.trigger('lead:convert-panel:reset', this.meta.module);
        this.trigger('lead:convert-panel:reset');
    },

/**
     * Track when a duplicate has been selected and notify the panel so it can
     * enable the Associate button
     */
    handleDupeSelectedChange: function() {
        this.currentState.dupeSelected = this.duplicateView.context.has('selection_model');
        this.trigger('lead:convert:duplicate-selection:change');
    },

/**
     * Wrapper to check whether to fire the duplicate check event
     */
    triggerDuplicateCheck: function() {
        if (this.shouldDupeCheckBePerformed(this.createView.model)) {
            this.trigger('lead:convert-dupecheck:pending');
            this.duplicateView.context.trigger('dupecheck:fetch:fire', this.createView.model, {
                //Show alerts for this request
                showAlerts: true
            });
        } else {
            this.dupeCheckComplete();
        }
    },

/**
     * Check if duplicate check should be performed
     * dependent on enableDuplicateCheck setting and required dupe check fields
     * @param {Object} model
     */
    shouldDupeCheckBePerformed: function(model) {
        var performDuplicateCheck = this.meta.enableDuplicateCheck;

if (this.meta.duplicateCheckRequiredFields) {
            _.each(this.meta.duplicateCheckRequiredFields, function(field) {
                if (_.isEmpty(model.get(field))) {
                    performDuplicateCheck = false;
                }
            });
        }
        return performDuplicateCheck;
    },

/**
     * Populates the record view from the passed in model and then kick off the
     * dupe check
     *
     * @param {Object} model
     */
    handlePopulateRecords: function(model) {
        var fieldMapping = {};

// if copyData is not set or false, no need to run duplicate check, bail out
        if (!this.meta.copyData) {
            this.dupeCheckComplete();
            return;
        }

if (!_.isEmpty(this.meta.fieldMapping)) {
            fieldMapping = app.utils.deepCopy(this.meta.fieldMapping);
        }
        var sourceFields = app.metadata.getModule(model.attributes._module, 'fields');
        var targetFields = app.metadata.getModule(this.meta.module, 'fields');

_.each(model.attributes, function(fieldValue, fieldName) {
            if (app.acl.hasAccessToModel('edit', this.createView.model, fieldName) &&
                !_.isUndefined(sourceFields[fieldName]) &&
                !_.isUndefined(targetFields[fieldName]) &&
                sourceFields[fieldName].type === targetFields[fieldName].type &&
                (_.isUndefined(sourceFields[fieldName]['duplicate_on_record_copy']) ||
                    sourceFields[fieldName]['duplicate_on_record_copy'] !== 'no') &&
                model.has(fieldName) &&
                model.get(fieldName) !== this.createView.model.get(fieldName) &&
                _.isUndefined(fieldMapping[fieldName])) {
                        fieldMapping[fieldName] = fieldName;
                    }
        }, this);

this.populateRecords(model, fieldMapping);
        if (this.meta.duplicateCheckOnStart) {
            this.triggerDuplicateCheck();
        } else if (!this.meta.dependentModules || this.meta.dependentModules.length == 0) {
            //not waiting on other modules before running dupe check, so mark as complete
            this.dupeCheckComplete();
        }
    },

/**
     * Use the convert metadata to determine how to map the lead fields to
     * module fields
     *
     * @param {Object} model
     * @param {Object} fieldMapping
     * @return {boolean} whether the create view model has changed
     */
    populateRecords: function(model, fieldMapping) {
        var hasChanged = false;

_.each(fieldMapping, function(sourceField, targetField) {
            if (model.has(sourceField) && this.shouldSourceValueBeCopied(model.get(sourceField)) &&
                model.get(sourceField) !== this.createView.model.get(targetField)) {
                    this.createView.model.setDefault(targetField, model.get(sourceField));
                    this.createView.model.set(targetField, model.get(sourceField));
                    hasChanged = true;
            }
        }, this);

//mark the model as copied so that the currency field doesn't set currency_id to user's default value
        if (hasChanged) {
            this.createView.once('render', function() {
                this.createView.model.trigger('duplicate:field', model);
            }, this);

if (model.has('currency_id')) {
                this.createView.model.isCopied = true;
            }
        }

return hasChanged;
    },

/**
     * Enable the panel
     *
     * @param {boolean} isEnabled add/remove the enabled flag on the header
     */
    handleEnablePanel: function(isEnabled) {
        var $header = this.$(this.accordionHeading);
        if (isEnabled) {
            if (!this.currentState.complete) {
                this.triggerDuplicateCheck();
            }
            $header.addClass('enabled');
        } else {
            $header.removeClass('enabled');
        }
    },

/**
     * Updates the attributes on the model based on the changes from dependent
     * modules duplicate view.
     * Uses dependentModules property - fieldMappings
     *
     * @param {string} moduleName
     * @param {Object} model
     */
    updateFromDependentModuleChanges: function(moduleName, model) {
        var dependencies = this.meta.dependentModules,
            modelChanged = false;
        if (dependencies && dependencies[moduleName] && dependencies[moduleName].fieldMapping) {
            modelChanged = this.populateRecords(model, dependencies[moduleName].fieldMapping);
            if (modelChanged) {
                this.triggerDuplicateCheck();
            }
        }
    },

/**
     * Resets the state of the panel based on a dependent module being reset
     */
    resetFromDependentModuleChanges: function(moduleName) {
        var dependencies = this.meta.dependentModules;
        if (dependencies && dependencies[moduleName]) {
            //if dupe check has already been run, reset but don't run again yet - just update status
            if (this.currentState.dupeCount && this.currentState.dupeCount > 0) {
                this.duplicateView.collection.reset();
                this.currentState.dupeCount = 0;
            }
            //undo any dependency field mapping that was done previously
            if (dependencies && dependencies[moduleName] && dependencies[moduleName].fieldMapping) {
                _.each(dependencies[moduleName].fieldMapping, function(sourceField, targetField) {
                    this.createView.model.unset(targetField);
                }, this);
            }
            //make sure if we re-trigger dupe check again we handle as if it never happened before
            this.toggledOffDupes = false;
            this.resetPanel();
        }
    },

/**
     * Resets the model to the default values so that unsaved warning prompt
     * will not be displayed.
     */
    turnOffUnsavedChanges: function() {
        var defaults = _.extend({}, this.createView.model._defaults, this.createView.model.getDefault());

this.createView.model.attributes = defaults;
    },

/**
     * Determine whether to copy the the supplied value when it appears in the Source module during conversion
     */
    shouldSourceValueBeCopied: function(val) {
        return _.isNumber(val) || _.isBoolean(val) || !_.isEmpty(val);
    },

/**
     * Stop listening to events on duplicate view collection
     * @inheritdoc
     */
    _dispose: function() {
        this.createView.model.off('change', this.runPostCompletionValidation, this);
        this.createView.off(null, null, this);
        this.duplicateView.off(null, null, this);
        this.duplicateView.context.off(null, null, this);
        this.duplicateView.collection.off(null, null, this);
        this._super('_dispose');
    }
}) },
"convert-main": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
({
	// Convert-main Layout (base)

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.convertPanels = {};
        this.associatedModels = {};
        this.dependentModules = {};
        this.noAccessRequiredModules = [];

app.view.Layout.prototype.initialize.call(this, options);

this.meta.modules = this.filterModulesByACL(this.meta.modules);

this.initializeOptions(this.meta.modules);

//create and place all the accordion panels
        this.initializePanels(this.meta.modules);

//listen for panel status updates
        this.context.on('lead:convert-panel:complete', this.handlePanelComplete, this);
        this.context.on('lead:convert-panel:reset', this.handlePanelReset, this);

//listen for Save button click in headerpane
        this.context.on('lead:convert:save', this.handleSave, this);

this.before('render', this.checkRequiredAccess);

// Indicates that this view is being opened from Tile View
        this.fromPipeline = this.context.parent && this.context.parent.get('layout') === 'pipeline-records';
    },

/**
     * Create a new object with only modules the user has create access to and
     * build list of required modules the user does not have create access to.
     *
     * @param {Object} modulesMetadata
     * @return {Object}
     */
    filterModulesByACL: function(modulesMetadata) {
        var filteredModulesMetadata = {};

_.each(modulesMetadata, function(moduleMeta, key) {
            //strip out modules that user does not have create access to
            if (app.acl.hasAccess('create', moduleMeta.module)) {
                filteredModulesMetadata[key] = moduleMeta;
            } else if (moduleMeta.required === true) {
                this.noAccessRequiredModules.push(moduleMeta.module);
            }
        }, this);

return filteredModulesMetadata;
    },

/**
     * Create an options section on top of convert panels that presents options
     * when converting a lead (specifically, which modules to copy/move
     * activities to).
     *
     * @param {Object} modulesMetadata
     */
    initializeOptions: function(modulesMetadata) {
        var view,
            convertModuleList = [];

_.each(modulesMetadata, function(moduleMeta) {
            let moduleSingular = this.getModuleSingular(moduleMeta.module);
            let moduleDetails = {
                id: moduleMeta.module,
                text: moduleSingular,
                required: moduleMeta.required
            };

moduleDetails = Object.assign(moduleDetails, {
                enableRlis: moduleMeta.enableRlis,
                requireRlis: moduleMeta.requireRlis,
            });

convertModuleList.push(moduleDetails);
        }, this);

this.context.set('convertModuleList', convertModuleList);
        view = app.view.createView({
            context: this.context,
            layout: this,
            type: 'convert-options',
            platform: this.options.platform
        });

this.addComponent(view);
    },

/**
     * Iterate over the modules defined in convert-main.php
     * Create a convert panel for each module defined there
     *
     * @param {Object} modulesMetadata
     */
    initializePanels: function(modulesMetadata) {
        var moduleNumber = 1;

_.each(modulesMetadata, function(moduleMeta) {
            moduleMeta.moduleNumber = moduleNumber++;
            var view = app.view.createLayout({
                context: this.context,
                type: 'convert-panel',
                layout: this,
                meta: moduleMeta,
                platform: this.options.platform
            });
            view.initComponents();

//This is because backbone injects a wrapper element.
            view.$el.addClass('accordion-group');
            view.$el.data('module', moduleMeta.module);

this.addComponent(view);
            this.convertPanels[moduleMeta.module] = view;
            if (moduleMeta.dependentModules) {
                this.dependentModules[moduleMeta.module] = moduleMeta.dependentModules;
            }
        }, this);
    },

/**
     * Check if user is missing access to any required modules
     * @return {boolean}
     */
    checkRequiredAccess: function() {
        //user is missing access to required modules - kick them out
        if (this.noAccessRequiredModules.length > 0) {
            this.denyUserAccess(this.noAccessRequiredModules);
            return false;
        }
        return true;
    },

/**
     * Close lead convert and notify the user that they are missing required access
     * @param {Array} noAccessRequiredModules
     */
    denyUserAccess: function(noAccessRequiredModules) {
        var translatedModuleNames = [];

_.each(noAccessRequiredModules, function(module) {
            translatedModuleNames.push(this.getModuleSingular(module));
        }, this);

app.alert.show('convert_access_denied', {
            level: 'error',
            messages: app.lang.get(
                'LBL_CONVERT_ACCESS_DENIED',
                this.module,
                {requiredModulesMissing: translatedModuleNames.join(', ')}
            )
        });
        app.drawer.close();
    },

/**
     * Retrieve the translated module name
     * @param {string} module
     * @return {string}
     */
    getModuleSingular: function(module) {
        var modulePlural = app.lang.getAppListStrings('moduleList')[module] || module;
        return (app.lang.getAppListStrings('moduleListSingular')[module] || modulePlural);
    },

_render: function() {
        app.view.Layout.prototype._render.call(this);

//This is because backbone injects a wrapper element.
        this.$el.addClass('accordion');
        this.$el.attr('id', 'convert-accordion');

//apply the accordion to this layout
        this.$('.collapse').collapse({toggle: false, parent: '#convert-accordion'});

//copy lead data down to each module when we get the lead data
        this.context.get('leadsModel').fetch({
            success: _.bind(function(model) {
                if (this.context) {
                    this.context.trigger('lead:convert:populate', model);
                }

this._applyAccorditionEvents();
            }, this)
        });
    },

/**
     * Apply accordition events
     */
    _applyAccorditionEvents: function() {
        this.$('.collapse').on('shown.bs.collapse hidden.bs.collapse', _.bind(this.handlePanelCollapseEvent, this));
    },

/**
     * Catch collapse shown/hidden events and notify the panels via the context
     * @param {Event} event
     */
    handlePanelCollapseEvent: function(event) {
        //only respond to the events directly on the collapse (was getting events from tooltip propagated up
        if (event.target !== event.currentTarget) {
            return;
        }
        var module = $(event.currentTarget).data('module');
        this.context.trigger('lead:convert:' + module + ':' + event.type);
    },

/**
     * When a panel is complete, add the model to the associatedModels array and notify any dependent modules
     * @param {string} module that was completed
     * @param {Data.Bean} model
     */
    handlePanelComplete: function(module, model) {
        this.associatedModels[module] = model;
        this.handlePanelUpdate();
        this.context.trigger('lead:convert:' + module + ':complete', module, model);
    },

/**
     * When a panel is reset, remove the model from the associatedModels array and notify any dependent modules
     * @param {string} module
     */
    handlePanelReset: function(module) {
        delete this.associatedModels[module];
        this.handlePanelUpdate();
        this.context.trigger('lead:convert:' + module + ':reset', module);
    },

/**
     * When a panel has been updated, check if any module's dependencies are met
     * and/or if all required modules have been completed
     */
    handlePanelUpdate: function() {
        this.checkDependentModules();
        this.checkRequired();
    },

/**
     * Check if each module's dependencies are met and enable the panel if they are.
     * Dependencies are defined in the convert-main.php
     */
    checkDependentModules: function() {
        _.each(this.dependentModules, function(dependencies, dependentModuleName) {
            var isEnabled = _.all(dependencies, function(module, moduleName) {
                return (this.associatedModels[moduleName]);
            }, this);
            this.context.trigger('lead:convert:' + dependentModuleName + ':enable', isEnabled);
        }, this);
    },

/**
     * Checks if all required modules have been completed
     * Enables the Save button if all are complete
     */
    checkRequired: function() {
        var showSave = _.all(this.meta.modules, function(module) {
            if (module.required) {
                if (!this.associatedModels[module.module]) {
                    return false;
                }
            }
            return true;
        }, this);

this.context.trigger('lead:convert-save:toggle', showSave);
    },

/**
     * When save button is clicked, call the Lead Convert API
     */
    handleSave: function() {
        // Disable the save button to prevent double click
        this.context.trigger('lead:convert-save:toggle', false);

// Before building the convert model, make sure that if any of the module panels have create subpanels,
        // their subpanel models are added to the save correctly
        _.each(this.convertPanels, function(panel, module) {
            if (panel.createView) {
                panel.createView.addSubpanelCreateModels();
            }
        }, this);

// Build the convert model that will be sent into the convert API
        let convertModel = new Backbone.Model(_.extend(
            {
                'modules': this.parseEditableFields(this.associatedModels),
                'allowBatching': true
            },
            this.getTransferActivitiesAttributes()
        ));

// Set field_duplicateBeanId for fields implementing FieldDuplicate
        _.each(this.convertPanels, function(view, module) {
            if (view && view.createView && convertModel.get('modules')[module]) {
                view.createView.model.trigger('duplicate:field:prepare:save', convertModel.get('modules')[module]);
            }
        }, this);

const leadsModel = this.context.get('leadsModel');
        const convertLeadsCallback = (view) => {
            this.cjFormBatch = view;

// if form batching has to be performed then don't show saving alert
            if (_.isUndefined(this.cjFormBatch)) {
                app.alert.show('processing_convert', {level: 'process', title: app.lang.get('LBL_SAVING')});
            }

// Call the convert API with the convert model
            let myURL = app.api.buildURL('Leads', 'convert', {id: leadsModel.id});

app.api.call('create', myURL, convertModel, {
                success: _.bind(this.convertSuccess, this),
                error: _.bind(this.convertError, this)
            });
        };

app.CJBaseHelper.fetchActiveSmartGuideCount(this.context, this, this.module, leadsModel.id,
            convertLeadsCallback
        );
    },

/**
     * Retrieve the attributes to be added to the convert model to support the
     * transfer activities functionality.
     *
     * @return {Object}
     */
    getTransferActivitiesAttributes: function() {
        var action = app.metadata.getConfig().leadConvActivityOpt,
            optedInToTransfer = this.model.get('transfer_activities');

return {
            transfer_activities_action: (action === 'move' && optedInToTransfer) ? 'move' : 'donothing'
        };
    },

/**
     * Returns only the fields for the models that the user is allowed to edit.
     * This method is run in the sync method of data-manager for creating records.
     *
     * @param {Object} models to get fields from.
     * @return {Object} Hash of models with editable fields.
     */
    parseEditableFields: function(models) {
        var filteredModels = {};
        _.each(models, function(associatedModel, associatedModule) {
            filteredModels[associatedModule] = app.data.getEditableFields(associatedModel);
        }, this);

return filteredModels;
    },

/**
     * Lead was successfully converted
     */
    convertSuccess: function() {
        if (!_.isUndefined(this.cjFormBatch)) {
            const params = {
                record: this.context.get('leadsModel').id,
                module: this.module,
            };

this.cjFormBatch.startBatchingProcess(params);
            this.cjFormBatch = undefined;
        } else {
            this.convertComplete('success', 'LBL_CONVERTLEAD_SUCCESS', true);
        }
    },

/**
     * There was a problem converting the lead
     */
    convertError: function() {
        this.convertComplete('error', 'LBL_CONVERTLEAD_ERROR', false);

if (!_.isUndefined(this.cjFormBatch)) {
            this.cjFormBatch.endBatchingProcess(false, false);
            this.cjFormBatch = undefined;
        }

if (!this.disposed) {
            this.context.trigger('lead:convert-save:toggle', true);
        }
    },

/**
     * Based on success of lead conversion, display the appropriate messages and optionally close the drawer
     * @param {string} level
     * @param {string} message
     * @param {boolean} doClose
     */
    convertComplete: function(level, message, doClose) {
        var leadsModel = this.context.get('leadsModel');
        app.alert.dismiss('processing_convert');
        app.alert.show('convert_complete', {
            level: level,
            messages: app.lang.get(message, this.module, {leadName: app.utils.getRecordName(leadsModel)}),
            autoClose: (level === 'success')
        });
        if (!this.disposed && doClose) {
            this.context.trigger('lead:convert:exit');
            if (this.fromPipeline) {
                app.drawer.close(level === 'success');
            } else {
                app.drawer.close(level === 'success');
                if (this.context.get('doRedirect') !== false) {
                    app.router.record('Leads', leadsModel.id);
                }
            }
        }
    },

/**
     * Clean up the jquery events that were added
     * @private
     */
    _dispose: function() {
        this.$('.collapse').off();
        app.view.Layout.prototype._dispose.call(this);
    }
}) }
}}
,
"datas": {}

},
		"Currencies":{"fieldTemplates": {
"base": {
"actionmenu": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */

({
	// Actionmenu FieldTemplate (base)

extendsFrom: 'ActionmenuField',

/**
     * Binds mass collection events to a record row checkbox.
     *
     * @private
     */
    _bindModelChangeEvents: function() {
        this._super('_bindModelChangeEvents');

this.massCollection.on('reset', function() {
            // force any disabled field to be unchecked
            var field = this.$(this.fieldTag);
            if (field.prop('disabled')) {
                field.attr('checked', false);
            }
        }, this);
    },

/**
     * @inheritdoc
     **/
    _onMassCollectionRemoveResetAll: function() {
        // if default currency exists in collection, remove it
        _.each(this.massCollection.models, function(model, index) {
            if (model.id === '-99') {
                this.massCollection.remove(this.massCollection.models[index], {silent: true});
            }
        }, this);

// force entire property to allow the selected row count alert to display
        if (this.massCollection.length > 0) {
            this.massCollection.entire = true;
        } else {
            this.massCollection.entire = false;
        }

this._super('_onMassCollectionRemoveResetAll');
    },
}) },
"editablelistbutton": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */

({
	// Editablelistbutton FieldTemplate (base)

extendsFrom: 'EditablelistbuttonField',

/**
     * Overriding because Currencies cannot be unlinked nor deleted
     *
     * @inheritdoc
     * @override
     */
    getCustomSaveOptions: function(options) {
        options.complete = function() {};
        return options;
    }
}) },
"text": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */

/**
 * @class View.Fields.Base.CurrenciesTextField
 * @alias App.view.fields.BaseCurrenciesTextField
 * @extends View.Fields.Base.TextField
 */
({
	// Text FieldTemplate (base)

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

// If the ISO 4217 field is changed to a valid code, automatically fill the symbol
        if (this.name === 'symbol') {
            this.model.on('change:iso4217', (model, iso4217) => {
                if (this.action === 'edit' &&
                    iso4217 !== '' &&
                    model.get('id') !== '-99' &&
                    app.lang.getAppListKeys('iso_currency_symbol').includes(iso4217)
                ) {
                    this.model.set(this.name, app.lang.getAppListStrings('iso_currency_symbol')[iso4217]);
                }
            });
        }
    }
}) },
"name": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */

/**
 * @class View.Fields.Base.CurrenciesNameField
 * @alias App.view.fields.BaseCurrenciesNameField
 * @extends View.Fields.Base.NameField
 */
({
	// Name FieldTemplate (base)

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

// If the ISO 4217 field is changed to a valid code, automatically fill the currency name
        this.model.on('change:iso4217', (model, iso4217) => {
            if (this.action === 'edit' &&
                iso4217 !== '' &&
                model.get('id') !== '-99' &&
                app.lang.getAppListKeys('iso_currency_name').includes(iso4217)
            ) {
                this.model.set(this.name, app.lang.getAppListStrings('iso_currency_name')[iso4217]);
            }
        });

// Set the system currency name
        this.listenTo(this.model, 'change:name', (model, name) => {
            if (name !== '' && model.get('id') === '-99') {
                model.set(this.name, app.lang.get('LBL_CURRENCY_DEFAULT', 'Currencies'));
            }
        });
    },

/**
     * @inheritdoc
     */
    _dispose: function() {
        this.stopListening();
        this._super('_dispose');
    }
}) }
}}
,
"views": {
"base": {
"recordlist": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */

/**
 * Currencies Record List.
 *
 * @class View.Views.Base.Currencies.RecordlistView
 * @alias SUGAR.App.view.views.BaseCurrenciesRecordlistView
 * @extends View.Views.Base.RecordlistView
 */
({
	// Recordlist View (base)

extendsFrom: 'RecordlistView',

/**
     * @inheritdoc
     **/
    bindDataChange: function() {
        this.collection.on('data:sync:complete', function() {
            this.collection.each(function(model) {
                if (model.get('id') == app.currency.getBaseCurrencyId()) {
                    model.isDefault = true;
                    let defaultCurrencyName = app.lang.get('LBL_CURRENCY_DEFAULT', 'Currencies');
                    if (defaultCurrencyName) {
                        model.set('name', defaultCurrencyName);
                    }
                }
            }, this);

this.render();
        }, this);

// call the parent
        this._super('bindDataChange');
    },

/**
     * Disable double click to edit for the base currency
     * @inheritdoc
     */
    doubleClickEdit: function(event) {
        let row = this.$(event.target).parents('tr');
        if (row.attr('name') !== 'Currencies_-99') {
            this._super('doubleClickEdit', [event]);
        }
    },

/**
     * @inheritdoc
     **/
    _render: function() {
        this._super('_render');

let $tableRow = this.$('tr[name="Currencies_-99"]');
        let $rowCheckBox = $tableRow.find('input[name="check"]');
        let $rowActionDropdown = $tableRow.find('[data-bs-toggle="dropdown"');
        let $defaultCurrencyLabel = $tableRow.find('[data-type="name"] div.ellipsis_inline');

// Add the default currency class to the default currency row
        if ($defaultCurrencyLabel.length) {
            $defaultCurrencyLabel.addClass('defaultCurrencyLabel');
        }

// disable the checkbox
        if ($rowCheckBox.length) {
            $rowCheckBox.prop('disabled', true);
        }

// remove actions
        if ($rowActionDropdown.length) {
            $rowActionDropdown.closest('span.overflow-visible').css('justify-content', 'left').css('left', '0');
            $rowActionDropdown.remove();
        }
    }
}) },
"dashablerecord": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */

/**
 * @class View.Views.Base.Currencies.DashablerecordView
 * @alias SUGAR.App.view.views.BaseCurrenciesDashablerecordView
 * @extends View.Views.Base.DashablerecordView
 */
({
	// Dashablerecord View (base)

extendsFrom: 'DashablerecordView',
    isBase: false,

/**
     * @inheritdoc
     */
    _setReadonlyFields: function() {
        this.isBaseCurrency(this.model);
        this._super('_setReadonlyFields');
    },

/**
     * Checks to see if the model is the base currency
     * @param model
     */
    isBaseCurrency: function(model) {
        if (model && model.get('id') === app.currency.getBaseCurrencyId()) {
            this.isBase = true;
        } else {
            this.isBase = false;
        }
    }
}) },
"preview-header": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Currencies.PreviewHeaderView
 * @alias SUGAR.App.view.views.BaseCurrenciesPreviewHeaderView
 * @extends View.Views.Base.PreviewHeaderView
 */
({
	// Preview-header View (base)

extends: 'PreviewHeaderView',
    isBase: false,

/**
     * @inheritdoc
     * @override
     */
    triggerEdit: function() {
        //If this isn't the base currency, go ahead and display the edit view
        if (!this.isBase) {
            this._super('triggerEdit');
        }
    },

/**
     * Checks to see if the model is the base currency
     * @param model
     */
    isBaseCurrency: function(model) {
        if (model && _.isFunction(model.get) && model.get('id') === app.currency.getBaseCurrencyId()) {
            this.isBase = true;
        } else {
            this.isBase = false;
        }
    },

/**
     *  @inheritdoc
     */
    _render: function() {
        this.isBaseCurrency(this.context.get('model'));

this._super('_render');
    }
}) },
"record": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */

({
	// Record View (base)

extendsFrom: 'RecordView',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._checkIfBaseCurrency(options);
        this._super('initialize', [options]);
    },

/**
     * Checks to see if the currency is the base currency
     * @param options
     * @private
     */
    _checkIfBaseCurrency: function(options) {
        if (options.context.get('modelId') == app.currency.getBaseCurrencyId()) {
            var mainDropdownBtn = this._findButton(options.meta.buttons, 'main_dropdown');

//disable edit
            if (mainDropdownBtn) {
                // disable the edit button
                var editBtn = this._findButton(mainDropdownBtn.buttons, 'edit_button');
                if (editBtn) {
                    editBtn.css_class = editBtn.css_class || '';
                    editBtn.css_class += ' disabled';
                }
            }
            //set fields to read only.
            _.each(options.meta.panels, function(panel) {
                _.each(panel.fields, function(field) {
                    field.readonly = true;
                }, this);
            }, this);
        }
    },

/**
     * Finds buttons of a given type
     *
     * @param buttons
     * @param name
     * @return {*}
     * @private
     */
    _findButton: function(buttons, name) {
        return _.find(buttons, function(btn) {
            return btn.name === name;
        });
    }

}) },
"preview": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Currencies.PreviewView
 * @alias SUGAR.App.view.views.BaseCurrenciesPreviewView
 * @extends View.Views.Base.PreviewView
 */
({
	// Preview View (base)

extendsFrom: 'PreviewView',

/**
     * @inheritdoc
     */
    hasUnsavedChanges: function() {
        if (!_.isUndefined(this.model) && this.model.get('id') === app.currency.getBaseCurrencyId()) {
            return false;
        }

return this._super('hasUnsavedChanges');
    }
}) },
"activity-card-header": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Basic.ActivityCardHeaderView
 * @alias SUGAR.App.view.views.BaseBasicActivityCardHeaderView
 * @extends View.Views.Base.ActivityCardHeaderView
 */
({
	// Activity-card-header View (base)

extendsFrom: 'ActivityCardHeaderView',

this.hasAvatarUser = !!this.userField;
    }
}) }
}}
,
"layouts": {
"base": {
"filterpanel": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */

({
	// Filterpanel Layout (base)

extendsFrom: 'FilterpanelLayout',

/**
     * @inheritdoc
     */
    initialize: function(options) {

this._super('initialize', [options]);

if (this.context.get('layout') === 'record') {
            this.before('render', function() {
                return false;
            }, this);

this.template = app.template.empty;
            this.$el.html(this.template());
        }
    }
}) }
}}
,
"datas": {}

},
		"Contracts":{"fieldTemplates": {}
,
"views": {
"base": {
"filter-filter-dropdown": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */

({
	// Filter-filter-dropdown View (base)

extendsFrom: 'FilterFilterDropdownView',

/**
     * @inheritdoc
     */
    getFilterList: function() {
        var list = this._super('getFilterList').filter(function(obj) {
            if (obj.id == 'favorites') {
                return false;
            }

return true;
        });

return list;
    }
}) },
"activity-card-header": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Contracts.ActivityCardHeaderView
 * @alias SUGAR.App.view.views.BaseContractsActivityCardHeaderView
 * @extends View.Views.Base.ActivityCardHeaderView
 */
({
	// Activity-card-header View (base)

extendsFrom: 'ActivityCardHeaderView',

/**
     * @inheritdoc
     */
    setUsersFields: function() {
        const panel = this.getUsersPanel();

this.userField = _.find(panel.fields, function(field) {
            return field.name === 'assigned_user_name';
        });

this.hasAvatarUser = !!this.userField;
    }
}) }
}}
,
"layouts": {}
,
"datas": {}

},
		"Quotes":{"fieldTemplates": {
"base": {
"badge": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.BadgeField
 * @alias SUGAR.App.view.fields.BaseBadgeField
 * @extends View.Fields.Base.BaseField
 */
({
	// Badge FieldTemplate (base)

/**
     * Hash map of the possible labels for the badge
     */
    badgeLabelMap: undefined,

/**
     * Hash map of the possible CSS Classes for the badge
     */
    cssClassMap: undefined,

/**
     * The current CSS Class to add to the badge
     */
    currentCSSClass: undefined,

/**
     * The current Label to use for the badge
     */
    currentLabel: undefined,

/**
     * The field name to check for the badge
     */
    badgeFieldName: undefined,

/**
     * The current state of the field
     */
    state: undefined,

/**
     * @inheritdoc
     *
     * This field doesn't support `showNoData`.
     */
    showNoData: false,

/**
     * @inheritdoc
     *
     * The badge is always a readonly field.
     */
    initialize: function(options) {
        options.def.readonly = true;
        this._initOptionMaps(options);

this._super('initialize', [options]);

this._setState();
    },

/**
     * Sets up any class hashes defined in metadata
     *
     * @param {Object} options The field def options from metadata
     * @private
     */
    _initOptionMaps: function(options) {
        this.cssClassMap = options.def.css_class_map;
        this.badgeLabelMap = options.def.badge_label_map;
    },

/**
     * Sets the state of the field, field name, label, css classes, etc
     *
     * @private
     */
    _setState: function() {
        this.badgeFieldName = this.def.related_fields && _.first(this.def.related_fields) || this.name;

var val = this.model.get(this.badgeFieldName);
        switch (this.def.badge_compare.comparison) {
            case 'notEq':
                this.state = val != this.def.badge_compare.value;
                break;
            case 'eq':
                this.state = val == this.def.badge_compare.value;
                break;
            case 'notEmpty':
                this.state = !_.isUndefined(val) && !_.isEmpty(val.toString());
                break;
            case 'empty':
                this.state = !_.isUndefined(val) && _.isEmpty(val.toString());
                break;
        }

this.currentLabel = app.lang.get(this.badgeLabelMap[this.state], this.module);
        this.currentCSSClass = this.cssClassMap[this.state];
    },

/**
     * @inheritdoc
     */
    bindDataChange: function() {
        this.model.on('change:' + this.badgeFieldName, function() {
            if (!this.disposed) {
                this._setState();
                this.render();
            }
        }, this);
    }
}) },
"currency": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Quotes.CurrencyField
 * @alias SUGAR.App.view.fields.BaseQuotesCurrencyField
 * @extends View.Fields.Base.CurrencyField
 */
({
	// Currency FieldTemplate (base)

extendsFrom: 'CurrencyField',

/**
     * The field's value in Percent
     */
    valuePercent: undefined,

/**
     * @inheritdoc
     */
    bindDataChange: function() {
        this._super('bindDataChange');

if (this.name === 'deal_tot' && this.view.name === 'quote-data-grand-totals-header') {
            this.model.on('change:deal_tot_discount_percentage', function() {
                this._updateDiscountPercent();
            }, this);

if (this.context.get('create')) {
                // if this is deal_tot and on the create view, update the discount percent
                this._updateDiscountPercent();
            }
        }
    },

/**
     * Needed to override loadTemplate to check field permissions for Quotes header and footer views
     *
     * @inheritdoc
     */
    _loadTemplate: function() {
        var viewName = this.view.name;
        if ((viewName === 'quote-data-grand-totals-header' || viewName === 'quote-data-grand-totals-footer') &&
            !this._checkAccessToAction('list')) {
            // set the action to noaccess so the field template will get the right class
            this.action = 'noaccess';
            // if this is a header or footer currency field and there's no access, show noaccess
            this.tplName = 'noaccess-' + viewName;
            this.template = app.template.getField('currency', this.tplName, this.module);
        } else {
            this._super('_loadTemplate');
        }
    },

/**
     * Updates `this.valuePercent` for the deal_tot field in the quote-data-grand-totals-header view.
     *
     * @private
     */
    _updateDiscountPercent: function() {
        var percent = this.model.get('deal_tot_discount_percentage');

if (!_.isUndefined(percent)) {
            //clean up precision
            percent = app.utils.formatNumber(
                percent,
                false,
                app.user.getPreference('decimal_precision'),
                app.user.getPreference('number_grouping_separator'),
                app.user.getPreference('decimal_separator')
            );

if (app.lang.direction === 'rtl') {
                this.valuePercent = '%' + percent;
            } else {
                this.valuePercent =  percent + '%';
            }

// re-render after update
            this.render();
        }
    },

/**
     * Check is transaction value is equal to value and returns answer.
     *
     * @return {boolean} True if the values are equal or false if not
     * @private
     */
    isTransactionValueEqualToValue: function() {
        return this.transactionValue === this.value;
    },
}) },
"quote-data-actiondropdown": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Quotes.QuoteDataActiondropdownField
 * @alias SUGAR.App.view.fields.BaseQuotesQuoteDataActiondropdownField
 * @extends View.Fields.Base.BaseActiondropdownField
 */
({
	// Quote-data-actiondropdown FieldTemplate (base)

/**
     * @inheritdoc
     */
    extendsFrom: 'BaseActiondropdownField',

/**
     * @inheritdoc
     */
    className: 'quote-data-actiondropdown'
}) },
"quote-footer-currency": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Quotes.QuoteFooterCurrency
 * @alias SUGAR.App.view.fields.BaseQuotesQuoteFooterCurrency
 * @extends View.Fields.Base.CurrencyField
 */
({
	// Quote-footer-currency FieldTemplate (base)

extendsFrom: 'CurrencyField',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        var isCreate = options.context.isCreate();
        options.viewName = isCreate ? 'edit' : 'detail';

this._super('initialize', [options]);

if (!isCreate) {
            // only add this event on record view
            this.events = _.extend({
                'click .currency-field': '_toggleFieldToEdit'
            }, this.events);
        }

this.model.addValidationTask(
            'isNumeric_validator_' + this.cid,
            _.bind(this._doValidateIsNumeric, this)
        );

this.action = isCreate ? 'edit' : 'detail';

this.context.trigger('quotes:editableFields:add', this);
    },

/**
     * Needed to override loadTemplate to check field permissions for Quotes footer views
     *
     * @inheritdoc
     */
    _loadTemplate: function() {
        if (!this._checkAccessToAction('list')) {
            // set the action to noaccess so the field template will get the right class
            this.action = 'noaccess';
            // if this is a header or footer currency field and there's no access, show noaccess
            this.tplName = 'noaccess';
            this.template = app.template.getField('quote-footer-currency', this.tplName, this.module);
        } else {
            this._super('_loadTemplate');
        }
    },

/**
     * Toggles the field to edit if it not in edit
     *
     * @param {jQuery.Event} evt jQuery click event
     * @private
     */
    _toggleFieldToEdit: function(evt) {
        var record;

if (!this.$el.hasClass('edit')) {
            this.action = 'edit';
            this.tplName = 'detail';

// if this isn't already in edit, toggle to edit
            record = this.closestComponent('record');
            if (record) {
                record.context.trigger('editable:handleEdit', evt);
            }
        }
    },

/**
     * Validation function to check to see if a value is numeric.
     *
     * @param {Array} fields
     * @param {Array} errors
     * @param {Function} callback
     * @private
     */
    _doValidateIsNumeric: function(fields, errors, callback) {
        var value = this.model.get(this.name);
        if (!$.isNumeric(value)) {
            errors[this.name] = app.lang.get('ERROR_NUMBER');
        }
        callback(null, fields, errors);
    },

/**
      * Extending to remove the custom validation task for this field
      *
      * @inheritdoc
      * @private
      */
    _dispose: function() {
        this.model.removeValidationTask('isNumeric_validator_' + this.cid);
        this._super('_dispose');
    }
}) },
"editablelistbutton": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Quotes.EditablelistbuttonField
 * @alias SUGAR.App.view.fields.BaseQuotesEditablelistbuttonField
 * @extends View.Fields.EditablelistbuttonField
 */
({
	// Editablelistbutton FieldTemplate (base)

extendsFrom: 'EditablelistbuttonField',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['QuotesConversionRateLocking']);
        this._super('initialize', [options]);
    },

/**
     * @inheritdoc
     */
    _save: function() {
        this.checkConversionRateLock(() => {
            this._super('_save');
        });
    }
}) },
"currency-type-dropdown": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Quotes.CurrencyTypeDropdownField
 * @alias SUGAR.App.view.fields.BaseQuotesCurrencyTypeDropdownField
 * @extends View.Fields.Base.EnumField
 */
({
	// Currency-type-dropdown FieldTemplate (base)

extendsFrom: 'EnumField',

/**
     * Holds the compiled currencies templates with symbol/iso by currencyID key
     * @type {Object}
     */
    currenciesTpls: undefined,

/**
     * The currency ID field name to use on the model when changing currency ID
     * Defaults to 'currency_id' if no currency_field exists in metadata
     * @type {string}
     */
    currencyIdFieldName: undefined,

/**
     * The base rate field name to use on the model
     * Defaults to 'base_rate' if no base_rate_field exists in metadata
     * @type {string}
     */
    baseRateFieldName: undefined,

/**
     * The last known record currency id
     * @type {string}
     */
    _lastCurrencyId: undefined,

/**
     * @inheritdoc
     */
    initialize: function(options) {
        // get the currencies and run them through the template
        this.currenciesTpls = app.currency.getCurrenciesSelector(Handlebars.compile('{{symbol}} ({{iso4217}})'));

// Type should be enum to use the enum templates
        options.def.type = 'enum';
        // update options defs the currencies templates
        options.def.options = options.def.options || this.currenciesTpls;

// get the default field names from metadata
        this.currencyIdFieldName = options.def.currency_field || 'currency_id';
        this.baseRateFieldName = options.def.base_rate_field || 'base_rate';

this._super('initialize', [options]);

// check to make sure this is a new model or currency_id has not been set, and the model is not a copy
        // so we don't overwrite the models previously entered values
        if ((this.model.isNew() && !this.model.isCopy())) {
            var currencyFieldValue = app.user.getPreference('currency_id');
            var baseRateFieldValue = app.metadata.getCurrency(currencyFieldValue).conversion_rate;

// set the currency_id to the user's preferred currency
            this.model.set(this.currencyIdFieldName, currencyFieldValue);

// set the base_rate to the preferred currency conversion_rate
            this.model.set(this.baseRateFieldName, baseRateFieldValue);

// if this.name is not the same as the currency ID field, also set this.name on the model
            if (this.name !== this.currencyIdFieldName) {
                this.model.set(this.name, currencyFieldValue);
            }

// Modules such as `Forecasts` uses models that aren't `Data.Bean`
            if (_.isFunction(this.model.setDefault)) {
                var defaults = {};
                defaults[this.currencyIdFieldName] = currencyFieldValue;
                defaults[this.baseRateFieldName] = baseRateFieldValue;
                this.model.setDefault(defaults);
            }
        }

// track the last currency id to convert the value on change
        this._lastCurrencyId = this.model.get(this.currencyIdFieldName);
    }
}) },
"quote-footer-input": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Quotes.QuoteFooterInputField
 * @alias SUGAR.App.view.fields.BaseQuotesQuoteFooterInputField
 * @extends View.Fields.Base.Field
 */
({
	// Quote-footer-input FieldTemplate (base)

/**
     * The value dollar amount
     */
    value_amount: undefined,

/**
     * The value percent amount
     */
    value_percent: undefined,

/**
     * @inheritdoc
     */
    format: function(value) {
        if (!value) {
            this.value_amount = app.currency.formatAmountLocale('0');
            this.value_percent = '0%';
        }
    }
}) },
"datetimecombo": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Quotes.DatetimecomboField
 * @alias SUGAR.App.view.fields.BaseQuotesDatetimecomboField
 * @extends View.Fields.Base.DatetimecomboField
 */
({
	// Datetimecombo FieldTemplate (base)

extendsFrom: 'DatetimecomboField',

/**
     * @inheritdoc
     */
    _dispose: function() {
        // FIXME: this is a bad "fix" added -- when SC-2395 gets done to upgrade bootstrap we need to remove this
        if (this._hasTimePicker) {
            this.$(this.secondaryFieldTag).timepicker('remove');
        }

if (this._hasDatePicker && this.$(this.fieldTag).data('datepicker')) {
            $(window).off('resize', this.$(this.fieldTag).data('datepicker').place);
        }

this._hasTimePicker = false;
        this._hasDatePicker = false;

this._super('_dispose');
    }
}) },
"copy": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Quotes.CopyField
 * @alias SUGAR.App.view.fields.BaseQuotesCopyField
 * @extends View.Fields.Base.CopyField
 */
({
	// Copy FieldTemplate (base)

extendsFrom: 'CopyField',

/**
     * If this field is on a view that is converting from a "Ship To" Subpanel
     */
    isConvertingFromShipping: undefined,

/**
     * If this is a Quote Record Copy
     */
    isCopy: undefined,

/**
     * Is this the first time the Copy field has run
     */
    firstRun: undefined,

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

this.firstRun = true;
        this.isCopy = this.context.get('copy') || false;
        this.isConvertingFromShipping = this.view.isConvertFromShippingOrBilling === 'shipping';
    },

/**
     * Extending to set Shipping Account Name field editable after copy
     *
     * @inheritdoc
     */
    sync: function(enable) {
        var shippingAcctNameField;
        var isChecked = this._isChecked();

// do not sync field mappings if this is a quote record copy
        if (this.isCopy) {
            enable = false;
        }

this._super('sync', [enable]);

// do not sync field mappings if this is a quote record copy
        if (this.firstRun) {
            this.firstRun = false;
        }

// if this is coming from a Ship To subpanel and the Copy Billing to Shipping box
        // is not checked then re-enable the Shipping Account Name field so it can be canceled
        if (!isChecked) {
            shippingAcctNameField = this.getField('shipping_account_name');
            if (shippingAcctNameField) {
                shippingAcctNameField.setDisabled(false);
            }
        }
    },

/**
     * @inheritdoc
     * Overwriting the copy method so that the billing and shipping details are correct when a quote is created from
     * Accounts Quotes Bill-to or Ship-to subpanel
     */
    copy: function(from, to) {
        var _link = this.context.get('fromLink');
        var _fromModule = this.context.previous('parentModel') ?
            this.context.previous('parentModel').get('_module') :
            '';

// came from Accounts Quote Bill-To
        if (_link === 'quotes' && this.firstRun === true && _fromModule === 'Accounts') {
            var billingAccounts = this.model.get('billing_accounts');

if (!this.model.has(from)) {
                return;
            }

if (_.isUndefined(this._initialValues[to])) {
                this._initialValues[to] = this.model.get(to);
            }

if (to === 'shipping_account_name') {
                this.model.set(to, billingAccounts.name);
            } else if (to === 'shipping_account_id') {
                this.model.set(to, billingAccounts.id);
            } else if (app.acl.hasAccessToModel('edit', this.model, to)) {
                this.model.set(to, billingAccounts[to]);
            }

} else if (_link === 'quotes_shipto' && this.firstRun === true && _fromModule === 'Accounts') { // came from
            // Accounts Quote Ship-To
            var shippingAccounts = this.model.get('shipping_accounts');

if (_.isUndefined(this._initialValues[to])) {
                this._initialValues[to] = this.model.get(to);
            }

if (to === 'shipping_account_name') {
                this.model.set(from, shippingAccounts.name);
            } else if (to === 'shipping_account_id') {
                this.model.set(from, shippingAccounts.id);
            } else if (app.acl.hasAccessToModel('edit', this.model, from)) {
                this.model.set(from, shippingAccounts[from]);
            }
        } else {
            this._super('copy', [from, to]);
        }
    },

/**
     * Extending to add the model value condition in pre-rendered versions of the field
     *
     * @inheritdoc
     */
    toggle: function() {
        this.sync(this._isChecked());
    },

/**
     * Pulling this out to a function that can be checked from multiple places if the field
     * is checked or if the field does not exist yet (pre-render) then use the model value
     *
     * @return {boolean} True if the field is checked or false if not
     * @private
     */
    _isChecked: function() {
        return this.$fieldTag ? this.$fieldTag.is(':checked') : this.model.get(this.name);
    },

/**
     * Extending to check if we need to add sync events or not
     *
     * @inheritdoc
     */
    syncCopy: function(enable) {
        if ((!this.isConvertingFromShipping && !_.isUndefined(this._isChecked())) ||
            (this.isConvertingFromShipping && this._isChecked())) {
            // if this view is not coming from a Ship To convert subpanel,
            // or if it IS but the user specifically checked the Copy Billing to Shipping checkbox
            this._super('syncCopy', [enable]);
        } else {
            // set _inSync to be false so that sync() will work properly
            this._inSync = false;

if (!enable) {
                // remove sync events from the model
                this.model.off(null, this.copyChanged, this);
                return;
            }
        }
    }
}) },
"date": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Quotes.DateField
 * @alias SUGAR.App.view.fields.BaseQuotesDateField
 * @extends View.Fields.Base.DateField
 */
({
	// Date FieldTemplate (base)

extendsFrom: 'DateField',

/**
     * @inheritdoc
     */
    _dispose: function() {
        // FIXME: this is a bad "fix" added -- when SC-2395 gets done to upgrade bootstrap we need to remove this
        if (this._hasDatePicker && this.$(this.fieldTag).data('datepicker')) {
            $(window).off('resize', this.$(this.fieldTag).data('datepicker').place);
        }
        this._hasDatePicker = false;

this._super('_dispose');
    }
}) },
"fieldset": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Quotes.FieldsetField
 * @alias SUGAR.App.view.fields.BaseQuotesFieldsetField
 * @extends View.Fields.Base.FieldsetField
 */
({
	// Fieldset FieldTemplate (base)

extendsFrom: 'FieldsetField',

/**
     * The currency field name to use on the model
     */
    currencyField: 'currency_id',

/**
     * The base rate field name to use on the model
     */
    baseRateField: 'base_rate',

/**
     * The closed statuses of Quotes stage
     */
    closedStatuses: ['Closed Accepted', 'Closed Dead', 'Closed Lost'],

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);
        this.listenTo(this.model, `change:${this.currencyField}`, this.updateBaseRate);
    },

/**
     * Updates the base rate field based on the currency_id field
     */
    updateBaseRate: function() {
        if (this.name === 'conversion_rate_lock' &&
            !_.includes(this.closedStatuses, this.model.get('quote_stage')) &&
            !this.model.get('lock_conversion_rates')
        ) {
            let currencyId = this.model.get(this.currencyField);
            let lockedRates = this.model.get('locked_currency_rates') || {};
            let baseRate = lockedRates[currencyId];
            let currencyRate = baseRate || app.metadata.getCurrency(currencyId).conversion_rate;
            this.model.set(this.baseRateField, currencyRate);
            this._render();
        }
    }
}) },
"taxrate": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Quotes.TaxrateField
 * @alias SUGAR.App.view.fields.BaseQuotesTaxrateField
 * @extends View.Fields.Base.EnumField
 */
({
	// Taxrate FieldTemplate (base)

extendsFrom: 'RelateField',

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

// If the field is on the Quotes create view, try to get a default tax rate
        if (options.view.name === 'create') {
            this.getDefaultTaxRate();
        }
    },

/**
     * Get the lowest order active tax rate the user can access
     */
    getDefaultTaxRate: function() {
        let taxRateCollection = app.data.createBeanCollection('TaxRates');
        taxRateCollection.fetch({
            fields: ['id', 'name', 'status', 'list_order', 'value'],
            filter: [
                {'status': {'$in': ['Active']}}
            ],
            params: {
                order_by: 'list_order:asc',
            },
            limit: 1,
            success: data => {
                if (data.models.length === 0 || !this.model) {
                    return;
                }
                let taxRate = data.models[0];
                this.setValue({
                    id: taxRate.get('id'),
                    name: taxRate.get('name'),
                    value: taxRate.get('value')
                });
                this.view.defaultTaxRateValues = {
                    taxrate_id: taxRate.get('id'),
                    taxrate_name: taxRate.get('name'),
                    taxrate_value: taxRate.get('value')
                };
            }
        });
    },

/**
     * @inheritdoc
     */
    bindDataChange: function() {
        this._super('bindDataChange');

this.model.on('change:taxrate_value', this._onTaxRateChange, this);
    },

/**
     * Sets a new "tax" value when the taxrate changes
     *
     * @param {Data.Bean} model The changed model
     * @param {string} taxrateValue The new taxrate value "8.25", "!0", etc
     * @private
     */
    _onTaxRateChange: function(model, taxrateValue) {
        taxrateValue = taxrateValue || '0';

var taxratePercent = app.math.div(taxrateValue, '100');
        var newTax = app.math.mul(this.model.get('taxable_subtotal'), taxratePercent);

this.model.set('tax', newTax);
    },

/**
     * Extending to add taxrate_value to the id/name values
     *
     * @inheritdoc
     */
    _onSelect2Change: function(e) {
        var plugin = $(e.target).data('select2');
        var id = e.val;
        var value;
        var collection;
        var attributes = {};

if (_.isUndefined(id)) {
            return;
        }

value = (id) ? plugin.selection.find('span').text() : $(this).data('rname');
        collection = plugin.context;

if (collection && !_.isEmpty(id)) {
            // if we have search results use that to set new values
            var model = collection.get(id);
            attributes.id = model.id;
            attributes.value = model.get('value');
            attributes.name = model.get('name');
            _.each(model.attributes, function(value, field) {
                if (app.acl.hasAccessToModel('view', model, field)) {
                    attributes[field] = attributes[field] || model.get(field);
                }
            });
        } else if (e.currentTarget.value && value) {
            // if we have previous values keep them
            attributes.id = value;
            attributes.name = e.currentTarget.value;
            attributes.value = value;
        } else {
            // default to empty
            attributes.id = '';
            attributes.name = '';
            attributes.value = '';
        }

this.setValue(attributes);
    },

/**
     * Extending to add taxrate_value to the id/name values
     *
     * @inheritdoc
     */
    setValue: function(models) {
        if (!models) {
            return;
        }
        var updateRelatedFields = true;
        var values = {
            taxrate_id: models.id,
            taxrate_name: models.name,
            taxrate_value: models.value
        };

if (_.isArray(models)) {
            // Does not make sense to update related fields if we selected
            // multiple models
            updateRelatedFields = false;
        }

this.model.set(values);

if (updateRelatedFields) {
            // TODO: move this to SidecarExpressionContext
            // check if link field is currently populated
            if (this.model.get(this.fieldDefs.link)) {
                // unset values of related bean fields in order to make the model load
                // the values corresponding to the currently selected bean
                this.model.unset(this.fieldDefs.link);
            } else {
                // unsetting what is not set won't trigger "change" event,
                // we need to trigger it manually in order to notify subscribers
                // that another related bean has been chosen.
                // the actual data will then come asynchronously
                this.model.trigger('change:' + this.fieldDefs.link);
            }
        }
    }
}) },
"quote-data-actionmenu": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Quotes.QuoteDataActionmenuField
 * @alias SUGAR.App.view.fields.BaseQuotesQuoteDataActionmenuField
 * @extends View.Fields.Base.BaseActionmenuField
 */
({
	// Quote-data-actionmenu FieldTemplate (base)

/**
     * @inheritdoc
     */
    extendsFrom: 'BaseActionmenuField',

/**
     * Skipping ActionmenuField's override, just returning this.def.buttons
     *
     * @inheritdoc
     */
    _getChildFieldsMeta: function() {
        return app.utils.deepCopy(this.def.buttons);
    }
}) },
"tristate-checkbox": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Quotes.TristateCheckboxField
 * @alias SUGAR.App.view.fields.BaseQuotesTristateCheckboxField
 * @extends View.Fields.Base.BaseField
 */
({
	// Tristate-checkbox FieldTemplate (base)

/**
     * @inheritdoc
     */
    events: {
        'click .checkbox': 'onCheckboxClicked'
    },

/**
     * The list of possible states the field can be in
     * @type Object
     */
    statesData: undefined,

/**
     * The previous state's state data
     * @type Object
     */
    previousState: undefined,

/**
     * The name of the previous state
     * @type string
     */
    previousStateName: undefined,

/**
     * The current state's state data
     * @type Object
     */
    currentState: undefined,

/**
     * The name of the current state
     * @type string
     */
    currentStateName: undefined,

/**
     * If the field is required by other fields
     * @type boolean
     */
    isRequired: undefined,

/**
     * Text for the field's tooltip
     * @type string
     */
    tooltipText: undefined,

/**
     * List of any dependent fields
     * @type Object
     */
    dependentFields: undefined,

/**
     * Stored version of the app lang tooltip label
     */
    tooltipLabel: undefined,

/**
     * Service related fields
     * @type Array
     */
    serviceRelatedFieldArr: undefined,

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

this.dependentFields = _.clone(this.def.dependentFields) || {};

this.statesData = this._getStatesData();

this.isRequired = this.def.required || false;

// if current state is not defined the get the initial state
        this.changeState(options.viewDefs && options.viewDefs.currentState ?
            options.viewDefs.currentState : this._getInitialState());

this.serviceRelatedFieldArr = [
            'service_start_date',
            'service_end_date',
            'renewable',
            'service_duration',
            'service',
        ];

this.tooltipLabel = app.lang.get('LBL_CONFIG_TOOLTIP_FIELD_REQUIRED_BY', this.module);
        if (this.name === 'service_duration') {
            //See if the Service Duration column is added to the worksheet columns
            var hasServiceDurationCol = _.find(this.context.get('worksheet_columns'), function(col) {
                return col.name === 'service_duration';
            });

//If the service duration column exists in worksheet columns
            //Mark it as checked in the howto panels
            if (!_.isUndefined(hasServiceDurationCol)) {
                this.changeState('checked');
            }
        }
    },

/**
     * @inheritdoc
     */
    bindDataChange: function() {
        this._super('bindDataChange');
        this.context.on(
            'config:' + this.def.eventViewName + ':' + this.name + ':related:toggle',
            this._onToggleRelatedField,
            this
        );
        this.context.on('config:fields:' + this.def.eventViewName + ':reset', this._onFieldsReset, this);
    },

/**
     * @inheritdoc
     */
    bindDomChange: function() {
    },

/**
     * Handles changing from the current state to the next state
     *
     * @param {string} nextState The next state to transition to
     */
    changeState: function(nextState) {
        this.previousState = this.currentState;
        this.previousStateName = this.currentStateName;

this.currentStateName = nextState;
        this.currentState = this.statesData[this.currentStateName];

this.render();
    },

/**
     * @inheritdoc
     */
    render: function() {
        this._updateTooltipText();

this._super('render');

if (this.currentState.isIndeterminate) {
            this.$('.checkbox').prop('indeterminate', true);
        }
    },

/**
     * Returns if this is a required field or not
     *
     * @return {Object} If required was sent in from the field def or false
     * @protected
     */
    _getIsRequired: function() {
        return this.def.required || false;
    },

/**
     * Returns the possible states data for the field
     *
     * @return {Object}
     * @protected
     */
    _getStatesData: function() {
        return {
            unchecked: {
                ariaState: 'false',
                checked: false,
                nextState: 'checked',
                nextStateIfRequired: 'checked', // filled
                isIndeterminate: false
            },
            checked: {
                ariaState: 'true',
                checked: true,
                nextState: 'unchecked', // filled
                nextStateIfRequired: 'filled',
                isIndeterminate: false
            },
            filled: {
                ariaState: 'mixed',
                checked: false,
                nextState: 'unchecked',
                nextStateIfRequired: 'checked',
                isIndeterminate: true
            }
        };
    },

/**
     * Toggles field's inclusion in dependentFields to be ready for updating tooltip text
     *
     * @param {Object|Array} relatedFields Related fields that are dependent upon this field
     * @param {boolean} toggleFieldOn True if we're toggling fields on
     * @private
     */
    _onToggleRelatedField: function(relatedFields, toggleFieldOn) {
        if (!_.isArray(relatedFields)) {
            // make sure related fields is an array
            relatedFields = [relatedFields];
        }

if (toggleFieldOn) {
            _.each(relatedFields, function(relatedField) {
                //If service field is toggled on
                //Add all the other service related fields to the dependent fields as they are all co-dependent
                if (_.contains(this.serviceRelatedFieldArr, relatedField.name)) {
                    _.each(this.serviceRelatedFieldArr, function(serviceRelatedField) {
                        this.dependentFields[serviceRelatedField] = {
                            module: relatedField.def.labelModule,
                            field: serviceRelatedField,
                            reason: 'related_fields'
                        };
                    }, this);
                } else {
                    this.dependentFields[relatedField.name] = {
                        module: relatedField.def.labelModule,
                        field: relatedField.name,
                        reason: 'related_fields'
                    };
                }
            }, this);

this.isRequired = true;

if (this.currentStateName === 'unchecked') {
                // if we haven't changed this field from unchecked yet
                // change to the related state
                if (_.contains(this.serviceRelatedFieldArr, this.name)) {
                    // if this is a service field, change the state of all its related field to checked
                    this.changeState('checked');
                } else {
                    this.changeState('filled');
                }
            }
        } else {
            _.each(relatedFields, function(relatedField) {
                if (_.contains(this.serviceRelatedFieldArr, relatedField.name)) {
                    // if one service field is deleted from the dependentFields list,
                    // remove all the service related fields from it as well
                    _.each(this.serviceRelatedFieldArr, function(serviceRelatedField) {
                        delete this.dependentFields[serviceRelatedField];
                    }, this);
                } else {
                    delete this.dependentFields[relatedField.name];
                }
            }, this);

if (_.isEmpty(this.dependentFields)) {
                // Removing related fields that are not required by any displayed fields and is not checked
                if (this.currentStateName === 'filled') {
                    this.changeState('unchecked');
                }

if (this.currentStateName === 'checked' && _.contains(this.serviceRelatedFieldArr, this.name)) {
                    // removing all the service related fields if even one is not checked and is not being displayed
                    this.changeState('unchecked');
                }
                this.isRequired = false;
            }
        }

// bubble up the related fields
        if (this.def.relatedFields) {
            if (toggleFieldOn ||
                (!toggleFieldOn && !this.isRequired && this.currentStateName === 'unchecked')) {
                // only add this field when we're toggling fields on,
                // or when toggling them off and this field is no longer required
                // and this field is unchecked
                relatedFields.push(this);
            }
            _.each(this.def.relatedFields, function(fieldName) {
                // If the toggled field is a service field
                // Don't trigger the related toggle listener for service related fields
                // else it results in an infinite loop
                if (!_.contains(this.serviceRelatedFieldArr, fieldName)) {
                    this.context.trigger(
                        'config:' + this.def.eventViewName + ':' + fieldName + ':related:toggle',
                        relatedFields,
                        toggleFieldOn
                    );
                }
            }, this);
        }

this.render();
    },

/**
     * Handles when the Restore Defaults link is clicked in config-columns
     *
     * @protected
     */
    _onFieldsReset: function(defaultFieldList) {
        // reset dependent fields back
        this.dependentFields = _.clone(this.def.dependentFields) || {};
        this.isRequired = !_.isEmpty(this.dependentFields);

if (!_.contains(defaultFieldList, this.name)) {
            if (this.def.initialState === 'checked' && !this.isRequired) {
                this.def.initialState = 'unchecked';
            } else if (this.def.initialState === 'unchecked' && this.isRequired) {
                this.def.initialState = 'checked';
            } else if (this.def.initialState === 'checked' && this.isRequired &&
                _.intersection(defaultFieldList, this.dependentFields).length === 0) {
                this.def.initialState = 'unchecked';
                this.def.dependentFields = {};
            }
        } else {
            // Making sure default fields are checked.
            this.def.initialState = 'checked';
        }

this.changeState(this._getInitialState());
    },

/**
     * Handles when a user clicks on the field input
     *
     * @param {Event} evt The click event object
     */
    onCheckboxClicked: function(evt) {
        var nextState = this.isRequired ? this.currentState.nextStateIfRequired : this.currentState.nextState;
        var summaryColumns = this.view.model.get('summary_columns');
        evt.preventDefault();

if (this.def.eventViewName === 'summary_columns' && summaryColumns && summaryColumns.length >= 6 &&
            nextState === 'checked') {
            app.alert.show('max_summaryColumns_reached', {
                level: 'warning',
                messages: app.lang.get('LBL_SUMMARY_WORKSHEET_COLUMNS_MAX_WARNING', this.module),
                autoclose: true
            }, this);

nextState = 'unchecked';
            this._onCheckboxClicked(this.currentStateName, nextState);
            this.changeState(nextState);
        } else {
            this._onCheckboxClicked(this.currentStateName, nextState);
            // if the nextState for any service related field is 'filled', set the nextState to 'unchecked'
            // this only happens while unchecking any service field
            if (_.contains(this.serviceRelatedFieldArr, this.name) && nextState === 'filled') {
                nextState = 'unchecked';
            }
            this.changeState(nextState);
        }
    },

/**
     * Handle any other events or actions that need to happen
     * when the checkbox is clicked, but before we change state.
     *
     * @param {string} currentState The name of the current state
     * @param {string} nextState The name of the next state
     * @protected
     */
    _onCheckboxClicked: function(currentState, nextState) {
        this.context.trigger(
            'config:' + this.def.eventViewName + ':field:change',
            this,
            currentState,
            nextState
        );
    },

/**
     * @inheritdoc
     */
    _updateTooltipText: function() {
        var text;
        var isLTR = app.lang.direction === 'ltr';
        this.tooltipText = '';

if (!_.isEmpty(this.dependentFields)) {
            this.tooltipText = '<div class="tristate-checkbox-config-tooltip">' + this.tooltipLabel + '<ul>';

_.each(this.dependentFields, function(field) {
                text = isLTR ? field.module + ' - ' + field.field : field.field + ' - ' + field.module;
                this.tooltipText += '<li>' + text + '</li>';
            }, this);
            this.tooltipText += '</ul></div>';
        }
    },

/**
     * Returns the initial state for the field
     *
     * @return {string} The initial state for the field
     * @protected
     */
    _getInitialState: function() {
        return this.def.initialState || 'unchecked';
    }
}) },
"convert-to-opportunity": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */

/**
 * @class View.Fields.Base.Quotes.ConvertToOpportunity
 * @alias SUGAR.App.view.fields.BaseQuotesConvertToOpportunity
 * @extends View.Fields.Base.RowactionField
 */
({
	// Convert-to-opportunity FieldTemplate (base)

extendsFrom: 'RowactionField',

/**
     * @inheritdoc
     *
     * @param {Object} options
     */
    initialize: function(options) {
        this._super('initialize', [options]);
        this.type = 'rowaction';

this.context.on('button:convert_to_opportunity:click', this._onCreateOppFromQuoteClicked, this);
    },

/**
     * @inheritdoc
     */
    bindDataChange: function() {
        this.model.on('sync', this._toggleDisable, this);
        this.model.on('change:opportunity_id', this._toggleDisable, this);
    },

/**
     * Handler for when "Create Opp from Quote" is clicked
     * @private
     */
    _onCreateOppFromQuoteClicked: function() {
        var id = this.model.get('id');
        var url = app.api.buildURL('Quotes/' + id + '/opportunity');

app.alert.show('convert_to_opp', {
            level: 'info',
            title: app.lang.get('LBL_QUOTE_TO_OPPORTUNITY_STATUS'),
            messages: ['']
        });

app.api.call(
            'create',
            url,
            null,
            {
                success: this._onCreateOppFromQuoteCallback,
                error: this._onCreateOppFromQuoteError
            });
    },

/**
     * Success callback for Create Opp From Quote
     * @param data Data from the server
     * @private
     */
    _onCreateOppFromQuoteCallback: function(data) {
        var id = data.record.id;
        var url = 'Opportunities/' + id;
        app.alert.dismiss('convert_to_opp');
        app.router.navigate(url, {trigger: true});
    },

/**
     * Error callback for Create Opp From Quote
     * @param data
     * @private
     */
    _onCreateOppFromQuoteError: function(data) {
        app.alert.dismiss('convert_to_opp');
        app.alert.show('error_convert', {
            level: 'error',
            title: app.lang.get('LBL_ERROR'),
            messages: [data.message]
        });
    },

/**
     * Reusable method for the event actions
     *
     * @private
     */
    _toggleDisable: function() {
        if (this.disposed || _.isUndefined(this.model) || _.isNull(this.model)) {
            return;
        }
        var opportunityId = this.model.get('opportunity_id');
        this.setDisabled(!(_.isUndefined(opportunityId) || _.isEmpty(opportunityId)));
    },

/**
     * @inheritdoc
     */
    isAllowedDropdownButton: function() {
        // Filter logic for when it's on a dashlet
        return this.view.name !== 'dashlet-toolbar';
    }
}) },
"textarea": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Fields.Base.Quotes.TextareaField
 * @alias SUGAR.App.view.fields.BaseQuotesTextareaField
 * @extends View.Fields.Base.TextareaField
 */
({
	// Textarea FieldTemplate (base)

extendsFrom: 'BaseTextareaField',

/**
     * @inheritdoc
     *
     * Format the value to a string.
     * Return an empty string for undefined, null and object types.
     * Convert boolean to 1 or 0.
     * Convert array, int and other types to a string.
     *
     * @param {mixed} value to format
     * @return {string} the formatted value
     */
    format: function(value) {
        if (_.isString(value)) {
            if (this.tplName !== 'edit') {
                let shortComment = value;
                var max = this.tplName === 'quote-data-grand-totals-header' ? 20 : this._settings.max_display_chars;
                value = {
                    long: this.getDescription(value, false),
                    defaultValue: value,
                };

if (value.long && value.long.string.length > max) {
                    value.short = this.getDescription(shortComment, true);
                }
            }

return value;
        }

if (_.isUndefined(value) ||
            _.isNull(value) ||
            (_.isObject(value) && !_.isArray(value))
        ) {
            return '';
        }

if (_.isBoolean(value)) {
            return value === true ? '1' : '0';
        }

return value.toString();
    }
}) }
}}
,
"views": {
"base": {
"quote-data-grand-totals-header": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Quotes.QuoteDataGrandTotalsHeaderView
 * @alias SUGAR.App.view.views.BaseQuotesQuoteDataGrandTotalsHeaderView
 * @extends View.Views.Base.View
 */
({
	// Quote-data-grand-totals-header View (base)

/**
     * @inheritdoc
     */
    events: {
        'click [name="create_qli_button"]': '_onCreateQLIBtnClicked',
        'click [name="create_comment_button"]': '_onCreateCommentBtnClicked',
        'click [name="create_group_button"]': '_onCreateGroupBtnClicked'
    },

/**
     * @inheritdoc
     */
    className: 'quote-data-grand-totals-header-wrapper quote-totals-row border-[--border-base] border-y flex h-11',

/**
     * Handles when the create Quoted Line Item button is clicked
     *
     * @param {MouseEvent} evt The mouse click event
     * @private
     */
    _onCreateQLIBtnClicked: function(evt) {
        this.context.trigger('quotes:defaultGroup:create', 'qli');
    },

/**
     * Handles when the create Comment button is clicked
     *
     * @param {MouseEvent} evt The mouse click event
     * @private
     */
    _onCreateCommentBtnClicked: function(evt) {
        this.context.trigger('quotes:defaultGroup:create', 'note');
    },

/**
     * Handles when the create Group button is clicked
     *
     * @param {MouseEvent} evt The mouse click event
     * @private
     */
    _onCreateGroupBtnClicked: function(evt) {
        this.context.trigger('quotes:group:create');
    }
}) },
"config-totals-footer-rows": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Quotes.ConfigTotalsFooterRowsView
 * @alias SUGAR.App.view.views.BaseQuotesConfigTotalsFooterRowsView
 * @extends View.Views.Base.View
 */
({
	// Config-totals-footer-rows View (base)

/**
     * CSS Class for Totals fields
     */
    sortableFieldsContainerClass: 'totals-fields',

/**
     * CSS Class for Grand Totals fields
     */
    sortableGrandTotalFieldsContainerClass: 'grand-total-fields',

/**
     * Array to hold the Totals fields objects
     */
    footerFields: undefined,

/**
     * Array to hold the Grand Totals fields objects
     */
    footerGrandTotalFields: undefined,

/**
     * Data attribute key to use for Totals fields
     */
    fieldTotalKey: 'total',

/**
     * Data attribute key to use for Grand Totals fields
     */
    fieldGrandTotalKey: 'grand-total',

/**
     * Array to hold the server synced fields objects
     */
    syncedFields: undefined,

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

this.footerFields = [];
        this.footerGrandTotalFields = [];
        this.syncedFields = [];
    },

/**
     * Sets an array of fields into the footer rows
     *
     * @param {Array} footerFields The array of footer fields to set in the footer rows view
     */
    setFooterRowFields: function(footerFields) {
        this.syncedFields = _.clone(footerFields);
        this.footerFields = [];
        this.footerGrandTotalFields = [];

this.model.set(this.options.eventViewName, this.syncedFields);

_.each(this.syncedFields, function(field) {
            field.syncedType = field.type;
            field.type = 'currency';

field.syncedCssClass = field.syncedCssClass || field.css_class || '';
            field.css_class = '';

if (field.syncedCssClass.indexOf('grand-total') === -1) {
                this.footerFields.push(field);
            } else {
                this.footerGrandTotalFields.push(field);
            }
        }, this);

this.render();
    },

/**
     * Adds a field to the list of footer rows
     *
     * @param {Object} field The field defs of the field to add
     */
    addFooterRowField: function(field) {
        var newFieldsArr;

// add field to top of footerFields
        this.footerFields.unshift(field);

// rebuild the fields array for the model
        newFieldsArr = this._parseFieldsForModel();

// save and render the new fields state
        this.model.set(this.options.eventViewName, newFieldsArr);
        this.render();
    },

/**
     * Removes a field from the list of footer rows
     *
     * @param {Object} field The field defs of the field to remove
     */
    removeFooterRowField: function(field) {
        var newFieldsArr;

// remove field from wherever it exists
        this.footerFields = _.reject(this.footerFields, function(f) {
            return f.name === field.name;
        });

this.footerGrandTotalFields = _.reject(this.footerGrandTotalFields, function(f) {
            return f.name === field.name;
        });

// rebuild the fields array for the model
        newFieldsArr = this._parseFieldsForModel();

// save and render the new fields state
        this.model.set(this.options.eventViewName, newFieldsArr);
        this.render();
    },

/**
     * @inheritdoc
     */
    render: function() {
        this._super('render');

this.$('.connected-containers').sortable({
            // the items to make sortable
            items: '.sortable-item',
            // adds a slow animation when "dropping" a group, removing this causes the row
            // to immediately snap into place wherever it's sorted
            revert: true,
            // connect all connected-containers with each other
            connectWith: '.connected-containers',
            // allow drag to only go in Y axis direction
            axis: 'y',
            // the CSS class to apply to the placeholder underneath the helper clone the user is dragging
            placeholder: 'ui-state-highlight',
            // the cursor to use when dragging
            cursor: 'move',
            // handler for when dragging stops; the "drop" event
            stop: _.bind(this._onDragStop, this)
        }).disableSelection();

this.$('.connected-containers').droppable({
            accept: '.sortable-item',
            stop: _.bind(this._onDragStop, this)
        });
    },

/**
     * Handles when a user drops a dragged item into a sortable/droppable container
     *
     * @param {jQuery.Event} evt The jQuery drag stop event
     * @param {Object} ui The jQuery Sortable UI Object
     * @private
     */
    _onDragStop: function(evt, ui) {
        var $el = $(ui.item || ui.draggable);
        var fieldName = $el.data('fieldName');
        var fieldType = $el.data('fieldType');
        var groupType = $el.parent().data('groupType');
        var sortableTotalItemsCssSelector = '.' + this.sortableFieldsContainerClass + ' .sortable-item';
        var sortableGrandTotalItemsCssSelector = '.' + this.sortableGrandTotalFieldsContainerClass + ' .sortable-item';
        var newFieldsArr;

if (fieldType !== groupType) {
            // the field has changed groups
            if (fieldType === this.fieldTotalKey && groupType === this.fieldGrandTotalKey) {
                // was total, now grand-total

this._moveFieldToNewPosition(
                    fieldName,
                    this.footerFields,
                    this.footerGrandTotalFields,
                    sortableGrandTotalItemsCssSelector
                );

} else if (fieldType === this.fieldGrandTotalKey && groupType === this.fieldTotalKey) {
                // was grand-total, now total

this._moveFieldToNewPosition(
                    fieldName,
                    this.footerGrandTotalFields,
                    this.footerFields,
                    sortableTotalItemsCssSelector
                );
            }

// set the new group type onto the field
            $el.data('fieldType', groupType);
        } else {
            // field stayed in same group

if (groupType === 'total') {
                this._moveFieldToNewPosition(
                    fieldName,
                    this.footerFields,
                    this.footerFields,
                    sortableTotalItemsCssSelector
                );
            } else {
                this._moveFieldToNewPosition(
                    fieldName,
                    this.footerGrandTotalFields,
                    this.footerGrandTotalFields,
                    sortableGrandTotalItemsCssSelector
                );
            }
        }

newFieldsArr = this._parseFieldsForModel();

this.model.set(this.options.eventViewName, newFieldsArr);

this.render();
    },

/**
     * Parses footerFields and footerGrandTotalFields cleaning up CSS classes and merging them into one array
     *
     * @return {Array} The merged, processed array from footerFields and footerGrandTotalFields
     * @private
     */
    _parseFieldsForModel: function() {
        var newFieldsArr = [];
        var cssArr;
        var tmpField;

_.each(this.footerFields, function(field) {
            cssArr = [];
            tmpField = _.clone(field);

if (tmpField.syncedCssClass) {
                cssArr = cssArr.concat(tmpField.syncedCssClass.split(' '));
            }
            if (tmpField.css_class) {
                cssArr = cssArr.concat(tmpField.css_class.split(' '));
            }
            if (tmpField.syncedType) {
                tmpField.type = tmpField.syncedType;
            }
            if (cssArr.length) {
                cssArr = _.chain(cssArr)
                // only unique classes
                    .uniq()
                    // remove any grand-total css class since this is not in the grand total section
                    .without(this.fieldGrandTotalKey)
                    .value();
                tmpField.css_class = cssArr.join(' ');
            }
            newFieldsArr.push(_.pick(tmpField, 'name', 'type', 'label', 'css_class', 'default'));
        }, this);

_.each(this.footerGrandTotalFields, function(field) {
            cssArr = [];
            tmpField = _.clone(field);

// make sure the grand total items have the grand total class
            cssArr.push(this.fieldGrandTotalKey);

if (cssArr.length) {
                tmpField.css_class = _.uniq(cssArr).join(' ');
            }
            newFieldsArr.push(_.pick(tmpField, 'name', 'type', 'label', 'css_class', 'default'));
        }, this);

return newFieldsArr;
    },

/**
     * Moves a field to a new group and position if oldGroup and newGroup are different.
     * If oldGroup and newGroup are the same, it just moves a field to a new position
     * inside the same group.
     *
     * @param {string} fieldName The name of the field being moved
     * @param {Array} oldGroup The old group's array of fields
     * @param {Array} newGroup The new group's array of fields
     * @param {string} newGroupSelector The css selector for the new group
     * @private
     */
    _moveFieldToNewPosition: function(fieldName, oldGroup, newGroup, newGroupSelector) {
        var tmpField;
        var tmpFieldIndex;
        var $newGroupElements;

// find the index of the item in the old group
        tmpFieldIndex = _.findIndex(oldGroup, function(row) {
            return row.name === fieldName;
        }, this);

// remove the field from the old group
        tmpField = oldGroup.splice(tmpFieldIndex, 1)[0];

// get the elements inside the new group
        $newGroupElements = this.$(newGroupSelector);

// get the index of the field in the new group
        tmpFieldIndex = _.findIndex($newGroupElements, function(el) {
            return $(el).data('fieldName') === fieldName;
        }, this);

// add the moved field into the new group
        newGroup.splice(tmpFieldIndex, 0, tmpField);
    }
}) },
"product-catalog-dashlet": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Quotes.ProductCatalogDashletView
 * @alias SUGAR.App.view.views.QuotesProductCatalogDashletView
 * @extends View.Views.Base.ProductCatalogDashletView
 * @deprecated Use {@link View.Views.Base.ProductCatalogDashletView} instead
 */
({
	// Product-catalog-dashlet View (base)

extendsFrom: 'ProductCatalogDashletView',

initialize: function(options) {
        app.logger.warn('View.Views.Base.Quotes.ProductCatalogDashletView is deprecated. Use ' +
            'View.Views.Base.ProductCatalogDashletView instead');
        this._super('initialize', [options]);
    }
}) },
"massupdate": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Quotes.MassupdateView
 * @alias SUGAR.App.view.views.BaseQuotesMassupdateView
 * @extends View.Views.Base.MassupdateView
 */
({
	// Massupdate View (base)

extendsFrom: 'MassupdateView',

/**
     * @inheritdoc
     *
     * Extends parent function to add confirmation regarding conversion rate locking
     */
    handleValidationSuccess: function(massUpdate, validate) {
        let attributes = validate.attributes || this.getAttributes();
        if (_.has(attributes, 'lock_conversion_rates')) {
            let label = attributes.lock_conversion_rates ? 'LBL_QUOTES_CONVERSION_LOCK_MASSUPDATE_CONFIRM' :
                'LBL_QUOTES_CONVERSION_UNLOCK_MASSUPDATE_CONFIRM';
            let message = app.lang.get(label, 'Quotes', {
                lockConversionRatesName: app.lang.get(this._getLockFieldLabel(), 'Quotes')
            });
            app.alert.show('quote_confirm_lock_change', {
                level: 'confirmation',
                messages: message,
                onConfirm: () => {
                    this._super('handleValidationSuccess', [massUpdate, validate]);
                }
            });
        } else {
            this._super('handleValidationSuccess', [massUpdate, validate]);
        }
    }
}) },
"config-footer": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Quotes.ConfigFooterView
 * @alias SUGAR.App.view.views.BaseQuotesConfigFooterView
 * @extends View.Views.Base.Quotes.ConfigFooterView
 */
({
	// Config-footer View (base)

/**
     * @inheritdoc
     */
    extendsFrom: 'QuotesConfigPanelView',

/**
     * @inheritdoc
     */
    events: {
        'click .restore-defaults-btn': 'onClickRestoreDefaultsBtn'
    },

/**
     * The default list of field names for the Quotes worksheet columns
     */
    listDefaultFieldNames: [
        'new_sub',
        'tax',
        'shipping',
        'total'
    ],

/**
     * The Label names from each of the default fields
     */
    listDefaultFieldNameLabels: undefined,

/**
     * The list header view
     * @type {View.Views.Base.Quotes.ConfigTotalsFooterRowsView}
     */
    footerRowsView: undefined,

/**
     * Contains an array of all the default fields to reset the list header
     */
    defaultFields: [{
        name: 'new_sub',
        type: 'currency'
    }, {
        name: 'tax',
        type: 'currency',
        related_fields: ['taxrate_value']
    }, {
        name: 'shipping',
        type: 'quote-footer-currency',
        css_class: 'quote-footer-currency',
        default: '0.00'
    }, {
        name: 'total',
        label: 'LBL_LIST_GRAND_TOTAL',
        type: 'currency',
        css_class: 'grand-total',
        convertToBase: false
    }],

/**
     * Contains an array of all the current fields in the list header
     */
    footerRowFields: undefined,

/**
     * @inheritdoc
     */
    initialize: function(options) {
        var namesLen = this.listDefaultFieldNames.length;
        var quoteGrandTotalFooterListMeta = app.metadata.getView('Quotes', 'quote-data-grand-totals-footer');
        var field;
        var fieldLabels = [];
        var fieldLabel;
        var fieldLabelModule;

this._super('initialize', [options]);

this.quotesFieldMeta = app.metadata.getModule('Quotes', 'fields');

// pluck all the fields arrays from panels and flatten into one array
        this.footerRowFields = _.flatten(_.pluck(quoteGrandTotalFooterListMeta.panels, 'fields'));

_.each(this.footerRowFields, function(field) {
            field.labelModule = this._getFieldLabelModule(field);
        }, this);

// build the list header labels and defaultFields
        this.listDefaultFieldNameLabels = [];
        for (var i = 0; i < namesLen; i++) {
            // try to get view defs from the quote-data-group-list meta
            field = _.find(this.footerRowFields, function(headerField) {
                return this.listDefaultFieldNames[i] === headerField.name;
            }, this);

if (!field) {
                // if the field didn't exist in the group list meta, use the field vardef
                field = this.quotesFieldMeta[this.listDefaultFieldNames[i]];
            }

// use either label (viewdefs) or vname (vardefs)
            if (field && (field.label || field.vname)) {
                fieldLabel = field.label || field.vname;
                fieldLabelModule = 'Quotes';

fieldLabels.push(app.lang.get(fieldLabel, fieldLabelModule));
            }
        }

this.listDefaultFieldNameLabels = fieldLabels.join(', ');
    },

/**
     * @inheritdoc
     */
    _getEventViewName: function() {
        return 'footer_rows';
    },

/**
     * Returns the module to use for the label if no label module is given
     *
     * @param {Object} field
     * @return {string}
     * @private
     */
    _getFieldLabelModule: function(field) {
        return field.labelModule || 'Quotes';
    },

/**
     * @inheritdoc
     *
     * Only return currency type fields from the Quotes module for the Footer view
     */
    _getPanelFields: function() {
        var fields = [];
        _.each(this.context.get('quotesFields'), function(f, key) {
            if (f.type === 'currency') {
                fields.push(_.extend({
                    name: key
                }, f));
            }
        }, this);

return fields;
    },

/**
     * @inheritdoc
     */
    _getPanelFieldsModule: function() {
        return 'Quotes';
    },

/**
     * @inheritdoc
     */
    onConfigPanelShow: function() {
        if (this.dependentFields) {
            this.context.trigger('config:fields:change', this.eventViewName, this.panelFields);
        }
    },

/**
     * @inheritdoc
     */
    _onDependentFieldsChange: function(context, fieldDeps) {
        var pFieldDeps;
        var pRelatedFields;
        var pRelatedField;
        var pDependentField;
        var tmpRelatedFields;
        var relatedFieldsList = [];
        var tmpField;

this._super('_onDependentFieldsChange', [context, fieldDeps]);

pFieldDeps = this.dependentFields.Quotes;
        pRelatedFields = this.relatedFields.Quotes;

_.each(this.panelFields, function(field) {
            pDependentField = pFieldDeps[field.name];
            pRelatedField = pRelatedFields[field.name];

if (pDependentField) {
                tmpRelatedFields = _.extend({}, pDependentField.locked, pDependentField.related);

if (!_.isEmpty(tmpRelatedFields)) {
                    field.dependentFields = tmpRelatedFields;
                    field.required = true;
                }

if (field.required && !field.initialState) {
                    field.initialState = 'filled';
                    relatedFieldsList.push(field.name);
                }
            }

if (pRelatedField) {
                tmpRelatedFields = _.extend({}, pRelatedField.locked, pRelatedField.related);

if (!_.isEmpty(tmpRelatedFields)) {
                    field.relatedFields = field.relatedFields || [];

_.each(tmpRelatedFields, function(relField, relFieldName) {
                        field.relatedFields.push(relFieldName);
                    }, this);
                }
            }

tmpField = _.find(this.footerRowFields, function(headerField) {
                return headerField.name === field.name;
            });
            if (tmpField) {
                // if this panelField exists in footerRowFields, set to visible
                field.initialState = 'checked';
            }
        }, this);

this.model.set(this.eventViewName + '_related_fields', relatedFieldsList);

// Signal to the layout that the fields for this panel are loaded
        this.layout.trigger('config:panel:fields:loaded', this);
    },

/**
     * @inheritdoc
     */
    _onConfigFieldChange: function(field, oldState, newState) {
        var fieldVarDef = this.quotesFieldMeta[field.name];
        var fieldViewDef;
        var wasVisible = oldState === 'checked';
        var isNowVisible = newState === 'checked';
        var isUnchecked = newState === 'unchecked';
        var columnChanged = false;
        var toggleRelatedFields;

if (!wasVisible && isNowVisible) {
            // field was not visible, but now is visible
            fieldViewDef = {
                name: fieldVarDef.name,
                type: fieldVarDef.type,
                label: fieldVarDef.vname || fieldVarDef.label
            };
            fieldViewDef.labelModule = this._getFieldLabelModule(field);

// add the column to header fields
            this.footerRowsView.addFooterRowField(fieldViewDef);

toggleRelatedFields = false;
            columnChanged = true;
        } else if (!wasVisible && !isNowVisible && isUnchecked) {
            columnChanged = true;
            toggleRelatedFields = false;
        }

if (columnChanged) {
            if (!_.isUndefined(toggleRelatedFields) && field.def.relatedFields) {
                _.each(field.def.relatedFields, function(fieldName) {
                    this.context.trigger(
                        'config:' + this.eventViewName + ':' + fieldName + ':related:toggle',
                        field,
                        toggleRelatedFields
                    );
                }, this);
            }
        }
    },

/**
     * @inheritdoc
     */
    render: function() {
        this._super('render');

this.footerRowsView = app.view.createView({
            context: this.context,
            eventViewName: this.eventViewName,
            type: 'config-totals-footer-rows',
            layout: this,
            model: this.model
        });

this.$('.quote-footer-rows').append(this.footerRowsView.el);

// set the column header fields and render
        this.footerRowsView.setFooterRowFields(this.footerRowFields);
    },

/**
     * @inheritdoc
     */
    _customFieldDef: function(def) {
        def.eventViewName = this.eventViewName;

return def;
    },

/**
     * Handles the click event when user clicks to Restore Default fields
     *
     * @param {jQuery.Event} evt The jQuery click event
     */
    onClickRestoreDefaultsBtn: function(evt) {
        var fieldList = _.pluck(this.defaultFields, 'name');
        this.footerRowsView.setFooterRowFields(this.defaultFields);
        this.context.trigger('config:fields:' + this.eventViewName + ':reset', fieldList);
    }
}) },
"config-list-header-columns": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Quotes.ConfigListHeaderColumnsView
 * @alias SUGAR.App.view.views.BaseQuotesConfigListHeaderColumnsView
 * @extends View.Views.Base.FlexListView
 */
({
	// Config-list-header-columns View (base)

/**
     * @inheritdoc
     */
    extendsFrom: 'FlexListView',

/**
     * @inheritdoc
     */
    plugins: [
        'MassCollection',
        'ReorderableColumns'
    ],

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

this.massCollection = this.collection;
        this.leftColumns = [];

this.addMultiSelectionAction();
        this.template = app.template.getView('config-list-header-columns', 'Quotes');
    },

/**
     * @inheritdoc
     */
    bindDataChange: function() {
        this._super('bindDataChange');

this.on('list:reorder:columns', this.onSheetColumnsOrderChanged, this);
    },

/**
     * Handles when there's a change in the order of list header columns
     *
     * @param {Object} fields The fields object sent from ReorderableColumns plugin
     * @param {Array} newFieldNameOrder The new order of field names
     */
    onSheetColumnsOrderChanged: function(fields, newFieldNameOrder) {
        var newFieldOrder = [];
        var headerFields = this.model.get(this.options.eventViewName);

_.each(newFieldNameOrder, function(fieldName) {
            newFieldOrder.push(_.find(headerFields, function(field) {
                return field.name === fieldName;
            }));
        }, this);

this.model.set(this.options.eventViewName, newFieldOrder);
    },

/**
     * Add multi selection field to left column using Quote data fields
     *
     * @override
     */
    addMultiSelectionAction: function() {
        var buttons = [];
        var disableSelectAllAlert = !!this.meta.selection.disable_select_all_alert;

if (this.layout && this.layout.name === 'config-summary') {
            var _generateMeta = function(buttons, disableSelectAllAlert) {
                return {
                    name: '',
                    type: 'button',
                    icon: 'sicon-plus',
                    value: false,
                    sortable: false
                };
            };

this.leftColumns.push(_generateMeta(buttons, disableSelectAllAlert));
        } else {
            var _generateMeta = function(buttons, disableSelectAllAlert) {
                return {
                    name: 'quote-data-mass-actions',
                    type: 'fieldset',
                    fields: [
                        {
                            type: 'quote-data-actionmenu',
                            buttons: buttons || [],
                            disable_select_all_alert: !!disableSelectAllAlert
                        }
                    ],
                    value: false,
                    sortable: false
                };
            };

buttons = this.meta.selection.actions;
            this.leftColumns.push(_generateMeta(buttons, disableSelectAllAlert));
        }
    },

/**
     * @inheritdoc
     */
    render: function() {
        var groupBtn;
        var massDeleteBtn;

this._super('render');

groupBtn = _.find(this.nestedFields, function(field) {
            return field.name === 'group_button';
        });
        massDeleteBtn = _.find(this.nestedFields, function(field) {
            return field.name === 'massdelete_button';
        });

if (groupBtn) {
            groupBtn.setDisabled(true);
        }
        if (massDeleteBtn) {
            massDeleteBtn.setDisabled(true);
        }
    },

/**
     * Sets the List Header column field names and re-renders
     *
     * @param {Array} headerFieldList The list of field
     */
    setColumnHeaderFields: function(headerFieldList) {
        headerFieldList = _.clone(headerFieldList);
        this.meta.panels = [
            {
                fields: headerFieldList
            }];
        this.model.set(this.options.eventViewName, headerFieldList);

this._fields = this.parseFields();

this.render();
    },

/**
     * Adds a column header to the list columns
     *
     * @param {Object} field The field defs of the field to add
     */
    addColumnHeaderField: function(field) {
        var columns = this.model.get(this.options.eventViewName);
        columns.unshift(field);

this.meta.panels[0].fields = columns;
        this.model.set(this.options.eventViewName, columns);
        this._fields = this.parseFields();

this.render();
    },

/**
     * Removes a column header from the list columns
     *
     * @param {Object} field The field defs of the field to remove
     */
    removeColumnHeaderField: function(field) {
        var fields = this.meta.panels[0].fields;
        fields = _.reject(fields, function(headerField) {
            return headerField.name === field.name;
        });
        this.meta.panels[0].fields = fields;

this.model.set(this.options.eventViewName, fields);
        this._fields = this.parseFields();

this.render();
    }
}) },
"config-panel": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Quotes.ConfigPanelView
 * @alias SUGAR.App.view.views.BaseQuotesConfigPanelView
 * @extends View.Views.Base.ConfigPanelView
 */
({
	// Config-panel View (base)

/**
     * @inheritdoc
     */
    extendsFrom: 'BaseConfigPanelView',

/**
     * Holds an array of field names for the panel
     */
    panelFieldNameList: undefined,

/**
     * Holds an array of field viewdefs for the panel
     */
    panelFields: undefined,

/**
     * Contains the map of all related field dependencies
     */
    dependentFields: undefined,

/**
     * Contains the map of all dependencies for each field
     */
    relatedFields: undefined,

/**
     * The view name ID to use in events
     */
    eventViewName: undefined,

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this._super('initialize', [options]);

this.eventViewName = this._getEventViewName();

this.getPanelFieldNamesList();

var helpUrl = {
            more_info_url: '<a href="' + app.help.getMoreInfoHelpURL('config', 'QuotesConfig') + '" target="_blank">',
            more_info_url_close: '</a>',
        };
        var viewQuotesObj = app.help.get('Quotes', 'config_opps', helpUrl);
        this.quotesDocumentation = app.template.getView('config-panel.help', this.module)(viewQuotesObj);
    },

/**
     * @inheritdoc
     */
    bindDataChange: function() {
        this._super('bindDataChange');

this.context.once('change:dependentFields', this._onDependentFieldsChange, this);
        this.context.on('config:' + this.eventViewName + ':field:change', this._onConfigFieldChange, this);
    },

/**
     * Returns the event and view name for this config panel.
     * Should be overridden by child views.
     *
     * @return {string}
     * @private
     */
    _getEventViewName: function() {
        return 'config_panel';
    },

/**
     * Handles when the field dependencies list comes back from the config endpoint.
     * Should be extended in child classes to include anything specific views need to do
     * with the field dependencies list.
     *
     * @param {Core.Context} context
     * @param {Object} fieldDeps Dependent Fields
     * @protected
     */
    _onDependentFieldsChange: function(context, fieldDeps) {
        this.dependentFields = _.clone(fieldDeps);
        this.relatedFields = _.clone(this.context.get('relatedFields'));
        this.panelFields = this._buildPanelFieldsList();
    },

/**
     * Handles when a checkbox on the RHS gets toggled
     *
     * @param {View.Fields.Base.TristateCheckboxField} field The field that was toggled
     * @param {string} oldState The old state for the field
     * @param {string} newState The new state for the field
     * @protected
     */
    _onConfigFieldChange: function(field, oldState, newState) {
    },

/**
     * Returns an Array of field names to be used by the panel fields
     *
     * @return {Array}
     */
    getPanelFieldNamesList: function() {
        this.panelFieldNameList = [];
    },

/**
     * Returns an Array of field names to be used by the panel fields
     *
     * @param {Array} fields The array of fields to use for panelFields
     * @return {Array}
     * @protected
     */
    _buildPanelFieldsList: function() {
        var fields = this._getPanelFields();
        var moduleName = this._getPanelFieldsModule();

// convert fieldsObj to an array then sort the array by name
        if (!_.isArray(fields)) {
            var tmpArray = [];
            _.each(fields, function(value, key) {
                tmpArray.push(_.extend(value, {
                    name: key
                }));
            }, this);
            fields = tmpArray;
        }

// apply any additional sorting to the fields
        fields = this._customFieldsSorting(fields);

// return an array of the objects that pass the criteria
        fields = this._customFieldsProcessing(fields);

fields = _.map(fields, function(field) {
            var def = {
                name: field.name,
                label: app.lang.get(field.label, moduleName),
                type: 'tristate-checkbox',
                labelModule: moduleName,
                locked: field.locked,
                related: field.related
            };

return this._customFieldDef(def);
        }, this);

return fields;
    },

/**
     * Extensible function to get the fields array to be used in buildPanelFieldsList
     *
     * @private
     */
    _getPanelFields: function() {
        return [];
    },

/**
     * Extensible function to get the module name for the buildPanelFieldsList
     *
     * @private
     */
    _getPanelFieldsModule: function() {
        return this.module;
    },

/**
     * Handles any custom changes to the field defs a child view might need to make
     *
     * @param {Object} def The field def
     * @return {Object}
     * @protected
     */
    _customFieldDef: function(def) {
        return def;
    },

/**
     * Handles any custom field sorting that child classes might need to do.
     * By default, sort by the name field
     *
     * @param {Array} arr The fields array
     * @return {Array}
     * @protected
     */
    _customFieldsSorting: function(arr) {
        return _.sortBy(arr, 'name');
    },

/**
     * Handles any custom field processing, array manipulation, or changes
     * that child classes might need to do
     *
     * @param {Array} arr The fields array
     * @return {Array}
     * @protected
     */
    _customFieldsProcessing: function(arr) {
        return arr;
    }
}) },
"record": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Quotes.RecordView
 * @alias SUGAR.App.view.views.BaseQuotesRecordView
 * @extends View.Views.Base.RecordView
 */
({
	// Record View (base)

extendsFrom: 'RecordView',

/**
     * Track the calculated fields from the model to be used when checking for unsaved changes
     *
     * @type {Array}
     */
    calculatedFields: [],

/**
     * registers additional editable fields from supporting quotes views
     */
    additionalEditableFields: [],

/**
     * Track the number of items in edit mode.
     * @type {number}
     */
    editCount: 0,

/**
     * Hashtable to keep track of id's in edit mode
     * @type {Object}
     */
    editIds: {},

/**
     * @inheritdoc
     */
    initialize: function(options) {
        this.plugins = _.union(this.plugins || [], ['HistoricalSummary', 'QuotesViewSaveHelper',
            'QuotesConversionRateLocking']);
        this._super('initialize', [options]);

// get all the calculated fields from the model
        this.calculatedFields = _.chain(this.model.fields)
            .where({calculated: true})
            .pluck('name')
            .value();
        this.additionalEditableFields = [];
    },

/**
     * @inheritdoc
     */
    bindDataChange: function() {
        this._super('bindDataChange');

this.context.on('editable:handleEdit', this._handleEditShippingField, this);

this.context.on('quotes:editableFields:add', function(field) {
            this.additionalEditableFields.push(field);
            this.editableFields.push(field);
        }, this);

this.context.on('quotes:item:toggle', this._handleItemToggled, this);
    },

/**
     * @inheritdoc
     */
    setEditableFields: function() {
        this._super('setEditableFields');

if (this.editableFields) {
            _.each(this.additionalEditableFields, function(field) {
                this.editableFields.push(field);
            }, this);
        }
    },

/**
     * @inheritdoc
     *
     * Overrides the existing record duplicateClicked to handle the unique
     * Quotes->ProductBundles->Products|ProductBundleNotes data structure
     */
    duplicateClicked: function() {
        var bundles;
        var loadViewObj;
        var bundleModels = [];
        // create an empty Quote Bean
        var quoteModelCopy;
        var quoteContextCollection;
        var mainDropdownBtn;
        var copyItemCount = 0;

if (this.editCount) {
            app.alert.show('quotes_qli_editmode', {
                level: 'error',
                title: '',
                messages: [app.lang.get('LBL_COPY_LINE_ITEMS', 'Quotes')]
            });

return;
        }

// get the Edit dropdown button
        mainDropdownBtn = this.getField('main_dropdown');
        // close the dropdown menu
        mainDropdownBtn.$el.removeClass('open');

bundles = this.model.get('bundles');
        quoteModelCopy = app.data.createBean(this.model.module);
        quoteContextCollection = this.context.get('collection');

quoteModelCopy.copy(this.model);

_.each(bundles.models, function(bundle) {
            var items = [];
            var bundleData = bundle.toJSON();
            var pbItems = bundle.get('product_bundle_items');

// re-set pbItems (if it exists and if pbItems.models exists) to be pbItems.models
            pbItems = pbItems && pbItems.models;

// loop over the product bundle items
            _.each(pbItems, function(pbItem) {
                var tmpItem = pbItem.toJSON();
                var newBean;

// get rid of an item's id and quote_id
                delete tmpItem.id;
                delete tmpItem.quote_id;

if (_.isEmpty(tmpItem.product_template_name)) {
                    // if product_template_name is empty, use the QLI's name
                    tmpItem.product_template_name = tmpItem.name;
                } else {
                    // if product_template_name is not empty, set that to the QLI's name
                    tmpItem.name = tmpItem.product_template_name;
                }

newBean = app.data.createBean(tmpItem._module, tmpItem);

// set isCopied on the bean for currency fields to be set properly
                newBean.isCopied = true;

copyItemCount++;

// creates a Bean and pushes the individual Products|ProductBundleNotes to the array
                items.push(newBean);
            }, this);

// remove any id or sugarlogic entries from the bundle data
            delete bundleData.id;
            delete bundleData['_products-rel_exp_values'];
            // remove any leftover create/delete arrays
            delete bundleData.products;

// set items array onto the bundleData
            bundleData.product_bundle_items = items;

bundleModels.push(bundleData);
        }, this);

// get rid of the existing bundles data on the model
        quoteModelCopy.unset('bundles');

// set the model onto the context->collection
        quoteContextCollection.reset(quoteModelCopy);

loadViewObj = {
            action: 'edit',
            collection: quoteContextCollection,
            copy: true,
            create: true,
            layout: 'create',
            model: quoteModelCopy,
            module: 'Quotes',
            relatedRecords: bundleModels,
            copyItemCount: copyItemCount
        };

// lead the Quotes create layout
        app.controller.loadView(loadViewObj);
        // update the browser URL with the proper
        app.router.navigate('#Quotes/create', {trigger: false});
    },

/**
     * handles keeping track how many items are in edit mode.
     * @param {boolean} isEdit
     * @param {number} id id of the row being toggled
     * @private
     */
    _handleItemToggled: function(isEdit, id) {
        if (isEdit) {
            if (_.isUndefined(this.editIds[id])) {
                this.editIds[id] = true;
                this.editCount++;
            }
        } else if (!isEdit && this.editCount > 0) {
            delete this.editIds[id];
            this.editCount--;
        }
    },

/**
     * Override the save clicked function to check if things are in edit mode before saving.
     *
     * @inheritdoc
     */
    saveClicked: function() {
        //if we don't have any qlis in edit mode, save.  If we do, show a warning.
        if (this.editCount == 0) {
            this._super('saveClicked');
        } else {
            app.alert.show('quotes_qli_editmode', {
                level: 'error',
                title: '',
                messages: [app.lang.get('LBL_SAVE_LINE_ITEMS', 'Quotes')]
            });
        }
    },

/**
     * Override the cancel clicked function to retrigger sugarlogic.
     *
     * @inheritdoc
     */
    cancelClicked: function() {
        this._super('cancelClicked');
        this.context.trigger('list:editrow:fire');
    },

/**
     * This is only when the Shipping field is clicked to handle toggling
     * it to Edit mode since it's outside of this view's element. This is
     * exactly the same as record.handleEdit except it grabs the jQuery
     * event target from the full page instead of this.el and also uses the
     * `this.editableFields` instead of this.getField to find the shipping field.
     *
     * @param {jQuery.Event} e The jQuery Click Event
     * @private
     */
    _handleEditShippingField: function(e) {
        var $target;
        var cellData;
        var field;
        var cell;

if (e) {
            // having to open this to full page $ instead of this.$
            $target = $(e.target);
            cell = $target.parents('.record-cell');
        }

cellData = cell.data();
        field = _.find(this.editableFields, function(field) {
            return field.name === cellData.name;
        });

// Set Editing mode to on.
        this.inlineEditMode = true;

this.setButtonStates(this.STATE.EDIT);

this.toggleField(field);

if (cell.closest('.headerpane').length > 0) {
            this.toggleViewButtons(true);
            this.adjustHeaderpaneFields();
        }
    },

/**
     * Extracts the field names from the metadata for directly related views/panels.
     * @param {string} [module] Module name.
     */
    _getDataFields: function() {
        return _.union(this._super('_getDataFields'), ['locked_currency_rates']);
    },

/**
     * @inheritdoc
     */
    getCustomSaveOptions: function(options) {
        options = options || {};
        var returnObject = {};

// get the value that the server sent back
        var syncedValue = this.model.getSynced('currency_id');

// has the currency_id changed?
        if (this.model.get('currency_id') !== syncedValue) {
            // make copy of original function we are extending
            var origSuccess = options.success;
            // only do this if the currency_id field actually changes
            returnObject = {
                success: _.bind(function() {
                    if (_.isFunction(origSuccess)) {
                        origSuccess.apply(this, arguments);
                    }
                    // create the payload
                    var bulkSaveRequests = this._createBulkBundlesPayload();
                    // send the payload
                    this._sendBulkBundlesUpdate(bulkSaveRequests);
                }, this)
            };
        }

return returnObject;
    },

/**
     * Utility method to create the payload that will be send to the server via the bulk api call
     * to update all the product bundles currencies
     * @private
     */
    _createBulkBundlesPayload: function() {
        // loop over all the bundles and create the requests
        const quoteModel = this.model;
        var bundles = this.model.get('bundles');
        var bulkSaveRequests = [];
        var url;
        bundles.each(function(bundle) {
            // if the bundle is new, don't try and save it
            if (!bundle.isNew()) {
                // create the update url
                url = app.api.buildURL(bundle.module, 'update', {
                    id: bundle.get('id')
                });

// save the request with the two fields that need to be updated
                // on the product bundle
                bulkSaveRequests.unshift({
                    url: url.substr(4),
                    method: 'PUT',
                    data: {
                        currency_id: quoteModel.get('currency_id'),
                        base_rate: quoteModel.get('base_rate')
                    }
                });
            }
        });

return bulkSaveRequests;
    },

/**
     * Send the payload via the bulk api
     * @param {Array} bulkSaveRequests
     * @private
     */
    _sendBulkBundlesUpdate: function(bulkSaveRequests) {
        if (!_.isEmpty(bulkSaveRequests)) {
            app.api.call(
                'create',
                app.api.buildURL(null, 'bulk'),
                {
                    requests: bulkSaveRequests
                },
                {
                    success: _.bind(this._onBulkBundlesUpdateSuccess, this)
                }
            );
        }
    },

/**
     * Update the bundles when the results from the bulk api call
     * @param {Array} bulkResponses
     * @private
     */
    _onBulkBundlesUpdateSuccess: function(bulkResponses) {
        var bundles = this.model.get('bundles');
        var bundle;
        _.each(bulkResponses, function(record) {
            bundle = bundles.get(record.contents.id);
            if (bundle) {
                bundle.setSyncedAttributes(record.contents);
                bundle.set(record.contents);
            }
        }, this);
    },

/**
     * @inheritdoc
     */
    hasUnsavedChanges: function() {
        return this.hasUnsavedQuoteChanges();
    },

/**
     * @inheritdoc
     */
    handleSave: function() {
        this.checkConversionRateLock(() => {
            this._super('handleSave');
        });
    }
}) },
"config-header-buttons": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Quotes.ConfigHeaderButtonsView
 * @alias SUGAR.App.view.views.BaseQuotesConfigHeaderButtonsView
 * @extends  View.View.Base.ConfigHeaderButtonsView
 */
({
	// Config-header-buttons View (base)

/**
     * @inheritdoc
     */
    extendsFrom: 'BaseConfigHeaderButtonsView',

/**
     * @inheritdoc
     */
    _getSaveConfigAttributes: function() {
        _.each(this.model.get('worksheet_columns'), function(column) {
            if (column.name === 'service_duration') {
                column.fields = column.fields || [
                    {
                        'name': 'service_duration_value',
                        'label': 'LBL_SERVICE_DURATION_VALUE'
                    },
                    {
                        'name': 'service_duration_unit',
                        'label': 'LBL_SERVICE_DURATION_UNIT'
                    },
                ];
                column.css_class = 'service-duration-field';
                column.inline = true;
            }
            if (column.name === 'discount_field') {
                column.css_class += ' discount-field quote-discount-percent';
                column.fields = [{
                    name: 'discount_amount',
                    label: 'LBL_DISCOUNT_AMOUNT',
                    type: 'discount-amount',
                    discountFieldName: 'discount_select',
                    related_fields: ['currency_id'],
                    convertToBase: true,
                    base_rate_field: 'base_rate',
                    showTransactionalAmount: true
                }, {
                    name: 'discount_select',
                    type: 'discount-select',
                    options: [],
                }];
            }
        }, this);
        var saveObj = this.model.toJSON();
        var lineNum;
        var footerRows = [];
        var quotesMeta = app.metadata.getModule('Quotes', 'fields');
        // make sure related_fields contains description, currency_id, base_rate, quote_id, name, and
        // product_template_name & _id fields
        var requiredRelatedFields = [
            'service_duration_value',
            'service_duration_unit',
            'catalog_service_duration_value',
            'catalog_service_duration_unit',
            'subtotal',
            'description',
            'currency_id',
            'base_rate',
            'account_id',
            'quote_id',
            'name',
            'position',
            'product_template_id',
            'product_template_name'
        ];
        // make sure line_num field exists in worksheet_columns
        lineNum = _.find(saveObj.worksheet_columns, function(col) {
            return col.name === 'line_num';
        }, this);

if (!lineNum) {
            saveObj.worksheet_columns.unshift({
                name: 'line_num',
                label: null,
                widthClass: 'cell-xsmall',
                css_class: 'line_num text-center',
                type: 'line-num',
                readonly: true
            });
        }

// tweak any worksheet columns fields
        _.each(saveObj.worksheet_columns, function(col) {
            if (col.name === 'product_template_name') {
                // force product_template_name to be required if it exists
                col.required = true;
            }

if (col.type === 'image') {
                col.readonly = true;
            }

if (col.label === 'LBL_DISCOUNT_AMOUNT' && col.name === 'discount_amount') {
                col.label = 'LBL_DISCOUNT_AMOUNT_VALUE';
            }

if (col.type === 'relate') {
                requiredRelatedFields.push(col.id_name);
            }
            if (col.type === 'parent') {
                requiredRelatedFields.push(col.id_name);
                requiredRelatedFields.push(col.type_name);
            }

if (col.name === 'service_duration') {
                _.each(col.fields, function(field) {
                    requiredRelatedFields.push(field.name);
                }, this);
            }
        }, this);

_.each(requiredRelatedFields, function(field) {
            if (!_.contains(saveObj.worksheet_columns_related_fields, field)) {
                saveObj.worksheet_columns_related_fields.push(field);
            }
        });

_.each(saveObj.footer_rows, function(row) {
            var obj = {
                name: row.name,
                type: row.syncedType || row.type
            };
            if (row.syncedCssClass || row.css_class) {
                obj.css_class = row.syncedCssClass || row.css_class;
            }
            if (row.hasOwnProperty('default')) {
                obj.default = row.default;
            }
            if (quotesMeta[row.name] && !quotesMeta[row.name].formula) {
                obj.type = 'quote-footer-currency';
                obj.default = '0.00';
                if (!obj.css_class || (row.css_class && row.css_class.indexOf('quote-footer-currency') === -1)) {
                    obj.css_class = 'quote-footer-currency';
                }
            }

footerRows.push(obj);
        }, this);

saveObj.footer_rows = footerRows;

return saveObj;
    }
}) },
"config-columns": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Quotes.ConfigColumnsView
 * @alias SUGAR.App.view.views.BaseQuotesConfigColumnsView
 * @extends View.Views.Base.Quotes.ConfigPanelView
 */
({
	// Config-columns View (base)

/**
     * @inheritdoc
     */
    extendsFrom: 'QuotesConfigPanelView',

/**
     * @inheritdoc
     */
    events: {
        'click .restore-defaults-btn': 'onClickRestoreDefaultsBtn'
    },

/**
     * The default list of field names for the Quotes worksheet columns
     */
    listDefaultFieldNames: [
        'quantity',
        'product_template_name',
        'mft_part_num',
        'discount_price',
        'discount_field',
        'total_amount'
    ],

/**
     * The Label names from each of the default fields
     */
    listDefaultFieldNameLabels: undefined,

/**
     * The list header view
     * @type {View.Views.Base.Quotes.ConfigListHeaderColumnsView}
     */
    listHeaderView: undefined,

/**
     * Contains an array of all the default fields to reset the list header
     */
    defaultFields: undefined,

/**
     * Contains an array of all the current fields in the list header
     */
    listHeaderFields: undefined,

/**
     * Products Module vardefs
     */
    productsFieldMeta: undefined,

/**
     * @inheritdoc
     */
    initialize: function(options) {
        var productListMeta = app.metadata.getView('Products', 'quote-data-group-list');

this._super('initialize', [options]);

this.productsFieldMeta = app.metadata.getModule('Products', 'fields');

//If service duration value and unit exists
        //Add a custom service_duration field in the productsFieldMeta
        if (!_.isUndefined(this.productsFieldMeta.service_duration_value) &&
            !_.isUndefined(this.productsFieldMeta.service_duration_unit)) {

var durationField = {
                'name': 'service_duration',
                'type': 'fieldset',
                'css_class': 'service-duration-field',
                'label': 'LBL_SERVICE_DURATION',
                'inline': true,
                'show_child_labels': false,
                'fields': [
                    this.productsFieldMeta.service_duration_value,
                    this.productsFieldMeta.service_duration_unit,
                ],
                'related_fields': [
                    'service_start_date',
                    'service_end_date',
                    'renewable',
                    'service',
                ],
            };
            this.productsFieldMeta.service_duration = durationField;
        }

this.defaultFields = [];

// pluck all the fields arrays from panels and flatten into one array
        this.listHeaderFields = _.flatten(_.pluck(productListMeta.panels, 'fields'));
        // exclude the line_num field
        this.listHeaderFields = _.reject(this.listHeaderFields, function(field) {
            return field.name === 'line_num';
        });

_.each(this.listHeaderFields, function(field) {
            field.labelModule = this._getFieldLabelModule(field);
        }, this);

this.model.set(this.eventViewName, this.listHeaderFields);
    },

/**
     * @inheritdoc
     */
    _getEventViewName: function() {
        return 'worksheet_columns';
    },

/**
     * Returns the module to use for the label if no label module is given
     *
     * @param {Object} field
     * @return {string}
     * @private
     */
    _getFieldLabelModule: function(field) {
        var label = field.label || field.vname;
        var labelModule = field.labelModule || 'Products';
        var tmpLabel = app.lang.get(label, labelModule);

if (tmpLabel.indexOf('LBL_') !== -1) {
            labelModule = 'Quotes';
        }

return labelModule;
    },

this._super('_onDependentFieldsChange', [context, fieldDeps]);

pFieldDeps = this.dependentFields.Products;
        pRelatedFields = this.relatedFields.Products;

// build default fields
        var defaultWorksheetColumns = this.context.get('defaultWorksheetColumns');

// pluck all the fields arrays from panels and flatten into one array
        this.defaultFields = _.flatten(_.pluck(defaultWorksheetColumns.panels, 'fields'));
        // exclude the line_num field
        this.defaultFields = _.reject(this.defaultFields, function(field) {
            return field.name === 'line_num';
        });

// building Default Fields
        this.buildDefaultFields();

_.each(this.panelFields, function(field) {
            pDependentField = pFieldDeps[field.name];
            pRelatedField = pRelatedFields[field.name];

if (pDependentField) {
                tmpRelatedFields = _.extend({}, pDependentField.locked, pDependentField.related);

if (!_.isEmpty(tmpRelatedFields)) {
                    field.dependentFields = tmpRelatedFields;
                    field.required = true;
                }

if (field.required && !field.initialState) {
                    field.initialState = 'filled';
                    relatedFieldsList.push(field.name);
                }
            }

if (pRelatedField) {
                tmpRelatedFields = _.extend({}, pRelatedField.locked, pRelatedField.related);

if (!_.isEmpty(tmpRelatedFields)) {
                    field.relatedFields = field.relatedFields || [];

_.each(tmpRelatedFields, function(relField, relFieldName) {
                        field.relatedFields.push(relFieldName);
                    }, this);
                }
            }

tmpField = _.find(this.listHeaderFields, function(headerField) {
                return headerField.name === field.name;
            });
            if (tmpField) {
                // if this panelField exists in listHeaderFields, set to visible
                field.initialState = 'checked';
            }
        }, this);

this.model.set(this.eventViewName + '_related_fields', relatedFieldsList);

// Signal to the layout that the fields for this panel are loaded
        this.layout.trigger('config:panel:fields:loaded', this);
    },

/**
     *
     */
    buildDefaultFields: function() {
        var field;
        var fieldLabel;
        var fieldLabels = [];
        var fieldLabelModule;
        var tmpField;
        var _defaultFields = this.defaultFields;

this.listDefaultFieldNameLabels = _.pluck(_defaultFields, 'name');
        var namesLen = this.listDefaultFieldNameLabels.length;

// build the list header labels and defaultFields
        this.listDefaultFieldNameLabels = [];
        this.defaultFields = [];

for (var i = 0; i < namesLen; i++) {
            // try to get view defs from the quote-data-group-list meta
            field = _.find(this.listHeaderFields, function(headerField) {
                return this.listDefaultFieldNames[i] === headerField.name;
            }, this);

if (!field) {
                // if the field didn't exist in the group list meta, use the field vardef
                field = _.find(_defaultFields, {name: this.listDefaultFieldNames[i]}) ||
                this.productsFieldMeta[this.listDefaultFieldNames[i]];
            }

// use either label (viewdefs) or vname (vardefs)
            if (field && (field.label || field.vname)) {
                fieldLabel = field.label || field.vname;

// check Products strings first
                fieldLabel = app.lang.get(fieldLabel, 'Products');
                fieldLabelModule = 'Products';

if (fieldLabel.indexOf('LBL_') !== -1) {
                    // if Products label just returned LBL_ string, check Quotes
                    fieldLabel = app.lang.get(fieldLabel, 'Quotes');
                    fieldLabelModule = 'Quotes';
                }

fieldLabels.push(fieldLabel);

tmpField = {
                    name: field.name,
                    label: fieldLabel,
                    labelModule: fieldLabelModule,
                    widthClass: field.widthClass,
                    css_class: field.css_class || field.cssClass || ''
                };
                if (field.name === 'product_template_name') {
                    tmpField.type = 'quote-data-relate';
                    tmpField.required = true;
                }
                if (field.type === 'currency') {
                    tmpField.convertToBase = true;
                    tmpField.showTransactionalAmount = true;
                    tmpField.related_fields = ['currency_id', 'base_rate'];
                }
                if (field.name === 'discount_field') {
                    tmpField.type = 'fieldset';
                    tmpField.css_class += ' discount-field quote-discount-percent';
                    tmpField.fields = [{
                        name: 'discount_amount',
                        label: 'LBL_DISCOUNT_AMOUNT',
                        type: 'discount-amount',
                        discountFieldName: 'discount_select',
                        related_fields: ['currency_id'],
                        convertToBase: true,
                        base_rate_field: 'base_rate',
                        showTransactionalAmount: true
                    }, {
                        name: 'discount_select',
                        type: 'discount-select',
                        options: [],
                    }];
                }

// push the fieldDefs to default fields
                this.defaultFields.push(tmpField);
            }
        }

this.listDefaultFieldNameLabels = fieldLabels.join(', ');
    },

/**
     * @inheritdoc
     */
    _onConfigFieldChange: function(field, oldState, newState) {
        var fieldVarDef = _.find(this.defaultFields, {name: field.name}) ?
            _.find(this.defaultFields, {name: field.name}) :
            this.productsFieldMeta[field.name];
        var fieldViewDef;
        var wasVisible = oldState === 'checked';
        var isNowVisible = newState === 'checked';
        var isUnchecked = newState === 'unchecked';
        var columnChanged = false;
        var toggleRelatedFields;
        var serviceRelatedFieldsArr = [
            'service_duration',
            'service_start_date',
            'service_end_date',
            'renewable',
            'service'
        ];

if (fieldVarDef.type === 'relate') {
                fieldViewDef.id_name = fieldVarDef.id_name;
            }
            if (fieldVarDef.type === 'parent') {
                fieldViewDef.id_name = fieldVarDef.id_name;
                fieldViewDef.type_name = fieldVarDef.type_name;
            }

fieldViewDef.name === 'discount_amount' ?
                (fieldViewDef.label = app.lang.get('LBL_DISCOUNT_AMOUNT_VALUE', 'Products')) :
                fieldViewDef.label;

if (fieldViewDef.name === 'discount') {
                fieldViewDef = fieldVarDef;
            }

fieldViewDef.labelModule = this._getFieldLabelModule(field);

// add the column to header fields
            this.listHeaderView.addColumnHeaderField(fieldViewDef);

// if a service field is added, then add all its related fields to the worksheet column as well
            if (_.intersection(fieldVarDef.related_fields, serviceRelatedFieldsArr).length > 0) {
                _.each(fieldVarDef.related_fields, function(relField) {
                    var relatedFieldVarDef = this.productsFieldMeta[relField];
                    fieldViewDef = {};
                    fieldViewDef = {
                        name: relatedFieldVarDef.name,
                        type: relatedFieldVarDef.type,
                        label: relatedFieldVarDef.vname || relatedFieldVarDef.label
                    };
                    fieldViewDef.labelModule = this._getFieldLabelModule(relatedFieldVarDef);
                    this.listHeaderView.addColumnHeaderField(fieldViewDef);
                }, this);
            }

toggleRelatedFields = true;
            columnChanged = true;
        } else if (wasVisible && !isNowVisible) {
            // field was visible, but now is not visible, so remove from columns
            // remove the column from header fields
            this.listHeaderView.removeColumnHeaderField(fieldVarDef);
            // if a service field is removed, then remove all its related fields to the worksheet column as well
            if (_.intersection(fieldVarDef.related_fields, serviceRelatedFieldsArr).length > 0) {
                _.each(fieldVarDef.related_fields, function(relField) {
                    var relatedFieldVarDef = this.productsFieldMeta[relField];
                    this.listHeaderView.removeColumnHeaderField(relatedFieldVarDef);
                }, this);
            }

/**
     * @inheritdoc
     */
    _getPanelFields: function() {
        return this.context.get('productsFields');
    },

/**
     * @inheritdoc
     */
    _getPanelFieldsModule: function() {
        return 'Products';
    },

/**
     * @inheritdoc
     */
    render: function() {
        this._super('render');

this.listHeaderView = app.view.createView({
            context: this.context,
            eventViewName: this.eventViewName,
            type: 'config-list-header-columns',
            layout: this,
            model: this.model
        });

this.$('.quote-data-list-table').append(this.listHeaderView.el);

// set the column header fields and render
        this.listHeaderView.setColumnHeaderFields(this.listHeaderFields);
    },

/**
     * @inheritdoc
     */
    onConfigPanelShow: function() {
        if (this.dependentFields) {
            //picking the service duration value and unit
            //these will be reinserted in the panelFields as a single fieldset
            var durationValueField =
                _.find(this.panelFields, function(field) { return field.name === 'service_duration_value'; });
            var durationUnitField =
                _.find(this.panelFields, function(field) { return field.name === 'service_duration_unit'; });

//If service duration value and unit exists, don't add these to the howto panel columns
            //instead, add a custom service_duration field that ecapsulates both
            if (!_.isUndefined(durationValueField) && !_.isUndefined(durationUnitField)) {
                //removing the service duration unit and value fields from the howto panel
                this.panelFields = _.without(this.panelFields, durationUnitField, durationValueField);

/**
     * @inheritdoc
     */
    _customFieldDef: function(def) {
        def.name === 'discount_amount' ?
            (def.label = app.lang.get('LBL_DISCOUNT_AMOUNT_VALUE', 'Products')) :
            def.label;
        def.eventViewName = this.eventViewName;

return def;
    },

/**
     * @inheritdoc
     */
    _dispose: function() {
        if (this.listHeaderView) {
            this.listHeaderView.dispose();
            this.listHeaderView = null;
        }

this._super('_dispose');
    }
}) },
"config-summary": {"controller": /*
 * Your installation or use of this SugarCRM file is subject to the applicable
 * terms available at
 * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
 * If you do not agree to all of the applicable terms or do not have the
 * authority to bind the entity as an authorized representative, then do not
 * install or use this SugarCRM file.
 *
 * Copyright (C) SugarCRM Inc. All rights reserved.
 */
/**
 * @class View.Views.Base.Quotes.ConfigSummaryView
 * @alias SUGAR.App.view.views.BaseQuotesConfigSummaryView
 * @extends View.Views.Base.Quotes.ConfigPanelView
 */
({
	// Config-summary View (base)

/**
     * @inheritdoc
     */
    extendsFrom: 'QuotesConfigPanelView',

/**
     * @inheritdoc
     */
    events: {
        'click .restore-defaults-btn': 'onClickRestoreDefaultsBtn'
    },

/**
     * The default list of field names for the Quotes summary columns
     */
    listDefaultFieldNames: [
        'deal_tot',
        'new_sub',
        'tax',
        'shipping',
        'total'
    ],

/**
     * The Label names from each of the default fields
     */
    listDefaultFieldNameLabels: undefined,

/**
     * The list header view
     * @type {View.Views.Base.Quotes.ConfigListHeaderColumnsView}
     */
    listHeaderView: undefined,

/**
     * Contains an array of all the default fields to reset the list header
     */
    defaultFields: undefined,

/**
     * Contains an array of all the current fields in the list header
     */
    listHeaderFields: undefined,

/**
     * @inheritdoc
     */
    initialize: function(options) {
        var namesLen = this.listDefaultFieldNames.length;
        var quoteGrandTotalHeaderListMeta = app.metadata.getView('Quotes', 'quote-data-grand-totals-header');
        var field;
        var fieldLabels = [];
        var fieldLabel;
        var fieldLabelModule;
        var tmpField;

this._super('initialize', [options]);

this.quotesFieldMeta = app.metadata.getModule('Quotes', 'fields');

this.defaultFields = [];

// pluck all the fields arrays from panels and flatten into one array
        this.listHeaderFields = _.flatten(_.pluck(quoteGrandTotalHeaderListMeta.panels, 'fields'));

_.each(this.listHeaderFields, function(field) {
            field.labelModule = this._getFieldLabelModule(field);
        }, this);

// build the list header labels and defaultFields
        this.listDefaultFieldNameLabels = [];
        for (var i = 0; i < namesLen; i++) {
            // try to get view defs from the quote-data-group-list meta
            field = _.find(this.listHeaderFields, function(headerField) {
                return this.listDefaultFieldNames[i] === headerField.name;
            }, this);

if (!field) {
                // if the field didn't exist in the group list meta, use the field vardef
                field = this.quotesFieldMeta[this.listDefaultFieldNames[i]];
            }

// use either label (viewdefs) or vname (vardefs)
            if (field && (field.label || field.vname)) {
                fieldLabel = field.label || field.vname;

// check Products strings first
                fieldLabel = app.lang.get(fieldLabel, 'Quotes');
                fieldLabelModule = 'Quotes';

fieldLabels.push(fieldLabel);

tmpField = {
                    name: field.name,
                    label: fieldLabel,
                    labelModule: fieldLabelModule,
                    widthClass: field.widthClass,
                    css_class: field.css_class || field.cssClass || ''
                };

// push the fieldDefs to default fields
                this.defaultFields.push(tmpField);
            }
        }

this.listDefaultFieldNameLabels = fieldLabels.join(', ');

this.model.set(this.eventViewName, this.listHeaderFields);
    },

/**
     * @inheritdoc
     */
    _getEventViewName: function() {
        return 'summary_columns';
    },

/**
     * @inheritdoc
     */
    _getPanelFields: function() {
        var fields = [];
        _.each(this.context.get('quotesFields'), function(f, key) {
            if (f.type !== 'collection' && key.indexOf('_id') === -1) {
                fields.push(_.extend({
                    name: key
                }, f));
            }
        }, this);