ldc-sbv/wp-content/plugins/ninja-forms/assets/js/min/front-end.js
2021-09-21 15:01:08 +02:00

6254 lines
212 KiB
JavaScript

(function () {
/**
* @license almond 0.3.1 Copyright (c) 2011-2014, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/almond for details
*/
//Going sloppy to avoid 'use strict' string cost, but strict practices should
//be followed.
/*jslint sloppy: true */
/*global setTimeout: false */
var requirejs, require, define;
(function (undef) {
var main, req, makeMap, handlers,
defined = {},
waiting = {},
config = {},
defining = {},
hasOwn = Object.prototype.hasOwnProperty,
aps = [].slice,
jsSuffixRegExp = /\.js$/;
function hasProp(obj, prop) {
return hasOwn.call(obj, prop);
}
/**
* Given a relative module name, like ./something, normalize it to
* a real name that can be mapped to a path.
* @param {String} name the relative name
* @param {String} baseName a real name that the name arg is relative
* to.
* @returns {String} normalized name
*/
function normalize(name, baseName) {
var nameParts, nameSegment, mapValue, foundMap, lastIndex,
foundI, foundStarMap, starI, i, j, part,
baseParts = baseName && baseName.split("/"),
map = config.map,
starMap = (map && map['*']) || {};
//Adjust any relative paths.
if (name && name.charAt(0) === ".") {
//If have a base name, try to normalize against it,
//otherwise, assume it is a top-level require that will
//be relative to baseUrl in the end.
if (baseName) {
name = name.split('/');
lastIndex = name.length - 1;
// Node .js allowance:
if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
}
//Lop off the last part of baseParts, so that . matches the
//"directory" and not name of the baseName's module. For instance,
//baseName of "one/two/three", maps to "one/two/three.js", but we
//want the directory, "one/two" for this normalization.
name = baseParts.slice(0, baseParts.length - 1).concat(name);
//start trimDots
for (i = 0; i < name.length; i += 1) {
part = name[i];
if (part === ".") {
name.splice(i, 1);
i -= 1;
} else if (part === "..") {
if (i === 1 && (name[2] === '..' || name[0] === '..')) {
//End of the line. Keep at least one non-dot
//path segment at the front so it can be mapped
//correctly to disk. Otherwise, there is likely
//no path mapping for a path starting with '..'.
//This can still fail, but catches the most reasonable
//uses of ..
break;
} else if (i > 0) {
name.splice(i - 1, 2);
i -= 2;
}
}
}
//end trimDots
name = name.join("/");
} else if (name.indexOf('./') === 0) {
// No baseName, so this is ID is resolved relative
// to baseUrl, pull off the leading dot.
name = name.substring(2);
}
}
//Apply map config if available.
if ((baseParts || starMap) && map) {
nameParts = name.split('/');
for (i = nameParts.length; i > 0; i -= 1) {
nameSegment = nameParts.slice(0, i).join("/");
if (baseParts) {
//Find the longest baseName segment match in the config.
//So, do joins on the biggest to smallest lengths of baseParts.
for (j = baseParts.length; j > 0; j -= 1) {
mapValue = map[baseParts.slice(0, j).join('/')];
//baseName segment has config, find if it has one for
//this name.
if (mapValue) {
mapValue = mapValue[nameSegment];
if (mapValue) {
//Match, update name to the new value.
foundMap = mapValue;
foundI = i;
break;
}
}
}
}
if (foundMap) {
break;
}
//Check for a star map match, but just hold on to it,
//if there is a shorter segment match later in a matching
//config, then favor over this star map.
if (!foundStarMap && starMap && starMap[nameSegment]) {
foundStarMap = starMap[nameSegment];
starI = i;
}
}
if (!foundMap && foundStarMap) {
foundMap = foundStarMap;
foundI = starI;
}
if (foundMap) {
nameParts.splice(0, foundI, foundMap);
name = nameParts.join('/');
}
}
return name;
}
function makeRequire(relName, forceSync) {
return function () {
//A version of a require function that passes a moduleName
//value for items that may need to
//look up paths relative to the moduleName
var args = aps.call(arguments, 0);
//If first arg is not require('string'), and there is only
//one arg, it is the array form without a callback. Insert
//a null so that the following concat is correct.
if (typeof args[0] !== 'string' && args.length === 1) {
args.push(null);
}
return req.apply(undef, args.concat([relName, forceSync]));
};
}
function makeNormalize(relName) {
return function (name) {
return normalize(name, relName);
};
}
function makeLoad(depName) {
return function (value) {
defined[depName] = value;
};
}
function callDep(name) {
if (hasProp(waiting, name)) {
var args = waiting[name];
delete waiting[name];
defining[name] = true;
main.apply(undef, args);
}
if (!hasProp(defined, name) && !hasProp(defining, name)) {
throw new Error('No ' + name);
}
return defined[name];
}
//Turns a plugin!resource to [plugin, resource]
//with the plugin being undefined if the name
//did not have a plugin prefix.
function splitPrefix(name) {
var prefix,
index = name ? name.indexOf('!') : -1;
if (index > -1) {
prefix = name.substring(0, index);
name = name.substring(index + 1, name.length);
}
return [prefix, name];
}
/**
* Makes a name map, normalizing the name, and using a plugin
* for normalization if necessary. Grabs a ref to plugin
* too, as an optimization.
*/
makeMap = function (name, relName) {
var plugin,
parts = splitPrefix(name),
prefix = parts[0];
name = parts[1];
if (prefix) {
prefix = normalize(prefix, relName);
plugin = callDep(prefix);
}
//Normalize according
if (prefix) {
if (plugin && plugin.normalize) {
name = plugin.normalize(name, makeNormalize(relName));
} else {
name = normalize(name, relName);
}
} else {
name = normalize(name, relName);
parts = splitPrefix(name);
prefix = parts[0];
name = parts[1];
if (prefix) {
plugin = callDep(prefix);
}
}
//Using ridiculous property names for space reasons
return {
f: prefix ? prefix + '!' + name : name, //fullName
n: name,
pr: prefix,
p: plugin
};
};
function makeConfig(name) {
return function () {
return (config && config.config && config.config[name]) || {};
};
}
handlers = {
require: function (name) {
return makeRequire(name);
},
exports: function (name) {
var e = defined[name];
if (typeof e !== 'undefined') {
return e;
} else {
return (defined[name] = {});
}
},
module: function (name) {
return {
id: name,
uri: '',
exports: defined[name],
config: makeConfig(name)
};
}
};
main = function (name, deps, callback, relName) {
var cjsModule, depName, ret, map, i,
args = [],
callbackType = typeof callback,
usingExports;
//Use name if no relName
relName = relName || name;
//Call the callback to define the module, if necessary.
if (callbackType === 'undefined' || callbackType === 'function') {
//Pull out the defined dependencies and pass the ordered
//values to the callback.
//Default to [require, exports, module] if no deps
deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps;
for (i = 0; i < deps.length; i += 1) {
map = makeMap(deps[i], relName);
depName = map.f;
//Fast path CommonJS standard dependencies.
if (depName === "require") {
args[i] = handlers.require(name);
} else if (depName === "exports") {
//CommonJS module spec 1.1
args[i] = handlers.exports(name);
usingExports = true;
} else if (depName === "module") {
//CommonJS module spec 1.1
cjsModule = args[i] = handlers.module(name);
} else if (hasProp(defined, depName) ||
hasProp(waiting, depName) ||
hasProp(defining, depName)) {
args[i] = callDep(depName);
} else if (map.p) {
map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {});
args[i] = defined[depName];
} else {
throw new Error(name + ' missing ' + depName);
}
}
ret = callback ? callback.apply(defined[name], args) : undefined;
if (name) {
//If setting exports via "module" is in play,
//favor that over return value and exports. After that,
//favor a non-undefined return value over exports use.
if (cjsModule && cjsModule.exports !== undef &&
cjsModule.exports !== defined[name]) {
defined[name] = cjsModule.exports;
} else if (ret !== undef || !usingExports) {
//Use the return value from the function.
defined[name] = ret;
}
}
} else if (name) {
//May just be an object definition for the module. Only
//worry about defining if have a module name.
defined[name] = callback;
}
};
requirejs = require = req = function (deps, callback, relName, forceSync, alt) {
if (typeof deps === "string") {
if (handlers[deps]) {
//callback in this case is really relName
return handlers[deps](callback);
}
//Just return the module wanted. In this scenario, the
//deps arg is the module name, and second arg (if passed)
//is just the relName.
//Normalize module name, if it contains . or ..
return callDep(makeMap(deps, callback).f);
} else if (!deps.splice) {
//deps is a config object, not an array.
config = deps;
if (config.deps) {
req(config.deps, config.callback);
}
if (!callback) {
return;
}
if (callback.splice) {
//callback is an array, which means it is a dependency list.
//Adjust args if there are dependencies
deps = callback;
callback = relName;
relName = null;
} else {
deps = undef;
}
}
//Support require(['a'])
callback = callback || function () {};
//If relName is a function, it is an errback handler,
//so remove it.
if (typeof relName === 'function') {
relName = forceSync;
forceSync = alt;
}
//Simulate async callback;
if (forceSync) {
main(undef, deps, callback, relName);
} else {
//Using a non-zero value because of concern for what old browsers
//do, and latest browsers "upgrade" to 4 if lower value is used:
//http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout:
//If want a value immediately, use require('id') instead -- something
//that works in almond on the global level, but not guaranteed and
//unlikely to work in other AMD implementations.
setTimeout(function () {
main(undef, deps, callback, relName);
}, 4);
}
return req;
};
/**
* Just drops the config on the floor, but returns req in case
* the config return value is used.
*/
req.config = function (cfg) {
return req(cfg);
};
/**
* Expose module registry for debugging and tooling
*/
requirejs._defined = defined;
define = function (name, deps, callback) {
if (typeof name !== 'string') {
throw new Error('See almond README: incorrect module build, no module name');
}
//This module may not have dependencies
if (!deps.splice) {
//deps is not an array, so probably means
//an object literal or factory function for
//the value. Adjust args.
callback = deps;
deps = [];
}
if (!hasProp(defined, name) && !hasProp(waiting, name)) {
waiting[name] = [name, deps, callback];
}
};
define.amd = {
jQuery: true
};
}());
define("../lib/almond", function(){});
define( 'models/fieldErrorModel',[], function() {
var model = Backbone.Model.extend( {
} );
return model;
} );
define( 'models/fieldErrorCollection',['models/fieldErrorModel'], function( errorModel ) {
var collection = Backbone.Collection.extend( {
model: errorModel
} );
return collection;
} );
define( 'models/fieldModel',['models/fieldErrorCollection'], function( fieldErrorCollection ) {
var model = Backbone.Model.extend( {
defaults: {
placeholder: '',
value: '',
label_pos: '',
classes: 'ninja-forms-field',
reRender: false,
mirror_field: false,
confirm_field: false,
clean: true,
disabled: '',
visible: true,
invalid: false
},
initialize: function() {
var type = this.get('type');
this.set( 'formID', this.collection.options.formModel.get( 'id' ) );
this.listenTo( nfRadio.channel( 'form-' + this.get( 'formID' ) ), 'reset', this.resetModel );
this.bind( 'change', this.changeModel, this );
this.bind( 'change:value', this.changeValue, this );
this.set( 'errors', new fieldErrorCollection() );
if (type === 'listimage') {
this.get = this.listimageGet;
this.set = this.listimageSet;
}
/*
* Trigger an init event on two channels:
*
* fields
* field-type
*
* This lets specific field types modify model attributes before anything uses them.
*/
nfRadio.channel( 'fields' ).trigger( 'init:model', this );
nfRadio.channel( this.get( 'type' ) ).trigger( 'init:model', this );
nfRadio.channel( 'fields-' + this.get( 'type' ) ).trigger( 'init:model', this );
if( 'undefined' != typeof this.get( 'parentType' ) ){
nfRadio.channel( this.get( 'parentType' ) ).trigger( 'init:model', this );
}
/*
* When we load our form, fire another event for this field.
*/
this.listenTo( nfRadio.channel( 'form-' + this.get( 'formID' ) ), 'loaded', this.formLoaded );
/*
* Before we submit our form, send out a message so that this field can be modified if necessary.
*/
this.listenTo( nfRadio.channel( 'form-' + this.get( 'formID' ) ), 'before:submit', this.beforeSubmit );
},
listimageGet: function(attr) {
if(attr === 'options') {
attr = 'image_options';
}
return Backbone.Model.prototype.get.call(this, attr);
},
listimageSet: function(attributes, options) {
if ('options' === attributes) {
attributes = 'image_options';
}
return Backbone.Model.prototype.set.call(this, attributes, options);
},
changeModel: function() {
nfRadio.channel( 'field-' + this.get( 'id' ) ).trigger( 'change:model', this );
nfRadio.channel( this.get( 'type' ) ).trigger( 'change:model', this );
nfRadio.channel( 'fields' ).trigger( 'change:model', this );
},
changeValue: function() {
nfRadio.channel( 'field-' + this.get( 'id' ) ).trigger( 'change:modelValue', this );
nfRadio.channel( this.get( 'type' ) ).trigger( 'change:modelValue', this );
nfRadio.channel( 'fields' ).trigger( 'change:modelValue', this );
},
addWrapperClass: function( cl ) {
this.set( 'addWrapperClass', cl );
},
removeWrapperClass: function( cl ) {
this.set( 'removeWrapperClass', cl );
},
setInvalid: function( invalid ) {
this.set( 'invalid', invalid );
},
formLoaded: function() {
nfRadio.channel( 'fields' ).trigger( 'formLoaded', this );
nfRadio.channel( 'fields-' + this.get( 'type' ) ).trigger( 'formLoaded', this );
},
beforeSubmit: function( formModel ) {
nfRadio.channel( this.get( 'type' ) ).trigger( 'before:submit', this );
nfRadio.channel( 'fields' ).trigger( 'before:submit', this );
},
/**
* Return the value of this field.
* This method exists so that more complex fields can return more than just the field value.
* Those advanced fields should create their own method with this name.
*
* @since 3.5
* @return {string} Value of this field.
*/
getValue: function() {
return this.get( 'value' );
}
} );
return model;
} );
define( 'models/fieldCollection',['models/fieldModel'], function( fieldModel ) {
var collection = Backbone.Collection.extend( {
model: fieldModel,
comparator: 'order',
initialize: function( models, options ) {
this.options = options;
this.on( 'reset', function( fieldCollection ){
nfRadio.channel( 'fields' ).trigger( 'reset:collection', fieldCollection );
}, this );
},
validateFields: function() {
_.each( this.models, function( fieldModel ) {
// added here for help with multi-part part validation
fieldModel.set( 'clean', false );
nfRadio.channel( 'submit' ).trigger( 'validate:field', fieldModel );
}, this );
},
showFields: function() {
this.invoke( 'set', { visible: true } );
this.invoke( function() {
this.trigger( 'change:value', this );
});
},
hideFields: function() {
this.invoke( 'set', { visible: false } );
this.invoke( function() {
this.trigger( 'change:value', this );
});
}
} );
return collection;
} );
define( 'models/formErrorModel',[], function() {
var model = Backbone.Model.extend( {
} );
return model;
} );
define( 'models/formErrorCollection',['models/formErrorModel'], function( errorModel ) {
var collection = Backbone.Collection.extend( {
model: errorModel
} );
return collection;
} );
define( 'models/formModel',[
'models/fieldCollection',
'models/formErrorCollection'
], function(
FieldCollection,
ErrorCollection
) {
var model = Backbone.Model.extend({
defaults: {
beforeForm: '',
afterForm: '',
beforeFields: '',
afterFields: '',
wrapper_class: '',
element_class: '',
hp: '',
fieldErrors: {},
extra: {}
},
initialize: function() {
// Loop over settings and map to attributes
_.each( this.get( 'settings' ), function( value, setting ) {
this.set( setting, value );
}, this );
this.set( 'loadedFields', this.get( 'fields' ) );
this.set( 'fields', new FieldCollection( this.get( 'fields' ), { formModel: this } ) );
this.set( 'errors', new ErrorCollection() );
/*
* Send out a radio message so that anyone who wants to filter our content data can register their filters.
*/
nfRadio.channel( 'form' ).trigger( 'before:filterData', this );
/*
* Set our formContentData to our form setting 'formContentData'
*/
var formContentData = this.get( 'formContentData' );
/*
* The formContentData variable used to be fieldContentsData.
* If we don't have a 'formContentData' setting, check to see if we have an old 'fieldContentsData'.
*
* TODO: This is for backwards compatibility and should be removed eventually.
*/
if ( ! formContentData ) {
formContentData = this.get( 'fieldContentsData' );
}
var formContentLoadFilters = nfRadio.channel( 'formContent' ).request( 'get:loadFilters' );
/*
* Get our first filter, this will be the one with the highest priority.
*/
var sortedArray = _.without( formContentLoadFilters, undefined );
var callback = _.first( sortedArray );
formContentData = callback( formContentData, this, this );
this.set( 'formContentData', formContentData );
nfRadio.channel( 'forms' ).trigger( 'init:model', this );
nfRadio.channel( 'form-' + this.get( 'id' ) ).trigger( 'init:model', this );
// Fields
nfRadio.channel( 'form-' + this.get( 'id' ) ).reply( 'get:fieldByKey', this.getFieldByKey, this );
// Form Errors
nfRadio.channel( 'form-' + this.get( 'id' ) ).reply( 'add:error', this.addError, this );
nfRadio.channel( 'form-' + this.get( 'id' ) ).reply( 'remove:error', this.removeError, this );
// Extra Data
nfRadio.channel( 'form-' + this.get( 'id' ) ).reply( 'get:extra', this.getExtra, this );
nfRadio.channel( 'form-' + this.get( 'id' ) ).reply( 'add:extra', this.addExtra, this );
nfRadio.channel( 'form-' + this.get( 'id' ) ).reply( 'remove:extra', this.removeExtra, this );
// Respond to requests to get this model.
nfRadio.channel( 'form-' + this.get( 'id' ) ).reply( 'get:form', this.getForm, this );
nfRadio.channel( 'form' ).trigger( 'loaded', this );
nfRadio.channel( 'form' ).trigger( 'after:loaded', this );
nfRadio.channel( 'form-' + this.get( 'id' ) ).trigger( 'loaded', this );
},
/*
|--------------------------------------------------------------------------
| Fields
|--------------------------------------------------------------------------
*/
getFieldByKey: function( key ) {
return this.get( 'fields' ).findWhere( { key: key } );
},
/*
|--------------------------------------------------------------------------
| Form Errors
|--------------------------------------------------------------------------
*/
addError: function( id, msg ) {
var errors = this.get( 'errors' );
errors.add( { id: id, msg: msg } );
nfRadio.channel( 'form-' + this.get( 'id' ) ).trigger( 'add:error', this, id, msg );
},
removeError: function( id ) {
var errors = this.get( 'errors' );
var errorModel = errors.get( id );
errors.remove( errorModel );
nfRadio.channel( 'form-' + this.get( 'id' ) ).trigger( 'remove:error', this, id );
},
/*
|--------------------------------------------------------------------------
| Extra Data
|--------------------------------------------------------------------------
*/
getExtra: function( key ) {
var extraData = this.get( 'extra' );
if( 'undefined' == typeof key ) return extraData;
return extraData[ key ];
},
addExtra: function( key, value ) {
var extraData = this.get( 'extra' );
extraData[ key ] = value;
nfRadio.channel( 'form-' + this.get( 'id' ) ).trigger( 'add:extra', this, key, value );
},
removeExtra: function( key ) {
var extraData = this.get( 'extra' );
delete extraData[ key ];
nfRadio.channel( 'form-' + this.get( 'id' ) ).trigger( 'remove:extra', this, key );
},
/*
|--------------------------------------------------------------------------
| Get this form
|--------------------------------------------------------------------------
*/
getForm: function() {
return this;
}
} );
return model;
} );
define( 'models/formCollection',['models/formModel'], function( formModel ) {
var collection = Backbone.Collection.extend( {
model: formModel
} );
return collection;
} );
/*
* Handles setting up our form.
*
* Holds a collection of our fields.
* Replies to requests for field data.
* Updates field models.
*/
define('controllers/formData',['models/formModel', 'models/formCollection', 'models/fieldCollection', 'models/formErrorCollection'], function( FormModel, FormCollection, FieldCollection, ErrorCollection ) {
var controller = Marionette.Object.extend( {
initialize: function() {
/*
* Setup our field collections.
*/
var that = this;
/*
* Initialize our form collection (incase we have multiple forms on the page)
*/
this.collection = new FormCollection( nfForms );
nfRadio.channel( 'forms' ).trigger( 'loaded', this.collection );
nfRadio.channel( 'app' ).trigger( 'forms:loaded', this.collection );
nfRadio.channel( 'app' ).reply( 'get:form', this.getForm, this );
nfRadio.channel( 'app' ).reply( 'get:forms', this.getForms, this );
nfRadio.channel( 'fields' ).reply( 'get:field', this.getField, this );
},
getForm: function( id ) {
return this.collection.get( id );
},
getForms: function() {
return this.collection;
},
getField: function( id ) {
var model = false;
_.each( this.collection.models, function( form ) {
if ( ! model ) {
model = form.get( 'fields' ).get( id );
}
} );
if(typeof model == "undefined"){
model = nfRadio.channel( "field-repeater" ).request( 'get:repeaterFieldById', id );
}
return model;
}
});
return controller;
} );
define('controllers/fieldError',['models/fieldErrorModel'], function( fieldErrorModel ) {
var controller = Marionette.Object.extend( {
initialize: function() {
nfRadio.channel( 'fields' ).reply( 'add:error', this.addError );
nfRadio.channel( 'fields' ).reply( 'remove:error', this.removeError );
nfRadio.channel( 'fields' ).reply( 'get:error', this.getError );
},
addError: function( targetID, id, msg ) {
var model = nfRadio.channel( 'fields' ).request( 'get:field', targetID );
if( 'undefined' == typeof model ) return;
var errors = model.get( 'errors' );
errors.add( { 'id': id, 'msg' : msg } );
model.set( 'errors', errors );
model.trigger( 'change:errors', model );
model.set( 'clean', false );
nfRadio.channel( 'fields' ).trigger( 'add:error', model, id, msg );
},
removeError: function( targetID, id ) {
var model = nfRadio.channel( 'fields' ).request( 'get:field', targetID );
if( 'undefined' == typeof model ) return;
var errors = model.get( 'errors' );
var targetError = errors.get( id );
if ( 'undefined' != typeof targetError ) {
errors.remove( targetError );
model.set( 'errors', errors );
model.trigger( 'change:errors', model );
nfRadio.channel( 'fields' ).trigger( 'remove:error', model, id );
}
},
getError: function( targetID, id ) {
var model = nfRadio.channel( 'fields' ).request( 'get:field', targetID );
var errors = model.get( 'errors' );
var targetError = errors.get( id );
if ( 'undefined' != targetError ) {
return targetError;
} else {
return false;
}
}
});
return controller;
} );
/**
* Controller responsible for replying to a Radio request stating that a field has been changed.
*
* This controller sends out a message to the field-specific channel, the field type channel,
* and the public fields channel so that the data model can be updated.
*/
define('controllers/changeField',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
/*
* Reply to our request for changing a field.
*/
nfRadio.channel( 'nfAdmin' ).reply( 'change:field', this.changeField );
/*
* If we blur our field, set the model attribute of 'clean' to false.
* 'clean' tracks whether or not the user has every interacted with this element.
* Some validation, like required, uses this to decide whether or not to add an error.
*/
this.listenTo( nfRadio.channel( 'fields' ), 'blur:field', this.blurField );
},
changeField: function( el, model ) {
// Get our current value.
var value = nfRadio.channel( model.get( 'type' ) ).request( 'before:updateField', el, model );
value = ( 'undefined' != typeof value ) ? value : nfRadio.channel( model.get( 'parentType' ) ).request( 'before:updateField', el, model );
value = ( 'undefined' != typeof value ) ? value : jQuery( el ).val();
// Set our 'isUpdated' flag to false.
model.set( 'isUpdated', false );
// Set our 'clean' flag to false.
model.set( 'clean', false );
/*
* Send out a message saying that we've changed a field.
* The first channel is field id/key specific.
* The second channel is the field type, i.e. text, email, radio
* The third channel is a generic 'field' channel.
*
* If the submitted value you wish to store in the data model isn't the same as the value received above,
* you can set that model in the actions below and set the 'isUpdated' model attribute to true.
* i.e. model.set( 'isUpdated', true );
*/
nfRadio.channel( 'field-' + model.get( 'id' ) ).trigger( 'change:field', el, model );
nfRadio.channel( model.get( 'type' ) ).trigger( 'change:field', el, model );
nfRadio.channel( 'fields' ).trigger( 'change:field', el, model );
/*
* Send a request out on our nfAdmin channel to update our field model.
* If the field model has a 'isUpdated' property of false, nothing will be updated.
*/
nfRadio.channel( 'nfAdmin' ).request( 'update:field', model, value );
},
blurField: function( el, model ) {
// Set our 'clean' flag to false.
model.set( 'clean', false );
}
});
return controller;
} );
define('controllers/changeEmail',[], function() {
var radioChannel = nfRadio.channel( 'email' );
// var emailReg = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i;
var emailReg = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
var errorID = 'invalid-email';
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( radioChannel, 'change:modelValue', this.onChangeModelValue );
this.listenTo( radioChannel, 'keyup:field', this.emailKeyup );
this.listenTo( radioChannel, 'blur:field', this.onBlurField );
},
onChangeModelValue: function( model ) {
var value = model.get( 'value' );
var fieldID = model.get( 'id' );
this.emailChange( value, fieldID );
},
onBlurField: function( el, model ) {
var value = jQuery( el ).val();
var fieldID = model.get( 'id' );
this.emailChange( value, fieldID );
},
emailChange: function( value, fieldID ) {
if ( 0 < value.length ) {
if( emailReg.test( value ) ) {
nfRadio.channel( 'fields' ).request( 'remove:error', fieldID, errorID );
} else {
var fieldModel = nfRadio.channel( 'fields' ).request( 'get:field', fieldID );
var formModel = nfRadio.channel( 'app' ).request( 'get:form', fieldModel.get( 'formID' ) );
nfRadio.channel( 'fields' ).request( 'add:error', fieldID, errorID, formModel.get( 'settings' ).changeEmailErrorMsg );
}
} else {
nfRadio.channel( 'fields' ).request( 'remove:error', fieldID, errorID );
}
},
/**
* When a user types inside of an email field, track their keypresses and add the appropriate class.
* If the value validates as an email, add a class of nf-pass
* If the value does not validate as email, add a class of nf-fail
*
* @since 3.0
* @param {object} el Element that triggered the keyup event.
* @param {object} model Model connected to the element that triggered the event
* @return {void}
*/
emailKeyup: function( el, model, keyCode ) {
/*
* If we pressed the 'tab' key to get to this field, return false.
*/
if ( 9 == keyCode ) {
return false;
}
/*
* Get the current value from our element.
*/
var value = jQuery( el ).val();
/*
* Get our current ID
*/
var fieldID = model.get( 'id' );
/*
* Check our value to see if it is a valid email.
*/
if ( 0 == value.length ) {
nfRadio.channel( 'fields' ).request( 'remove:error', fieldID, errorID );
} else if ( ! emailReg.test( value ) && ! model.get( 'clean' ) ) {
var fieldModel = nfRadio.channel( 'fields' ).request( 'get:field', fieldID );
var formModel = nfRadio.channel( 'app' ).request( 'get:form', fieldModel.get( 'formID' ) );
nfRadio.channel( 'fields' ).request( 'add:error', fieldID, errorID, formModel.get( 'settings' ).changeEmailErrorMsg );
model.removeWrapperClass( 'nf-pass' );
} else if ( emailReg.test( value ) ) {
nfRadio.channel( 'fields' ).request( 'remove:error', fieldID, errorID );
/*
* Add nf-pass class to the wrapper.
*/
model.addWrapperClass( 'nf-pass' );
model.set( 'clean', false );
}
}
});
return controller;
} );
define('controllers/changeDate',[], function() {
var radioChannel = nfRadio.channel( 'date' );
var errorID = 'invalid-date';
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( radioChannel, 'change:modelValue', this.onChangeModelValue );
this.listenTo( radioChannel, 'keyup:field', this.dateKeyup );
this.listenTo( radioChannel, 'blur:field', this.onBlurField );
this.listenTo( radioChannel, 'change:extra', this.changeHoursMinutes, this)
},
onChangeModelValue: function( model ) {
this.dateChange( model );
},
onBlurField: function( el, model ) {
this.dateChange( model );
},
dateChange: function( model ) {
var fieldID = model.get( 'id' );
var value = model.get( 'value' );
var format = model.get( 'date_format' );
if( 'default' === format) {
format = nfi18n.dateFormat;
}
// If we are dealing with purely a time field, bail early.
if ( 'time_only' == model.get( 'date_mode' ) ) {
return false;
}
if ( 0 < value.length ) {
// use moment's isValid to check against the fields format setting
if( moment( value, format ).isValid() ) {
nfRadio.channel( 'fields' ).request( 'remove:error', fieldID, errorID );
} else {
var fieldModel = nfRadio.channel( 'fields' ).request( 'get:field', fieldID );
var formModel = nfRadio.channel( 'app' ).request( 'get:form', fieldModel.get( 'formID' ) );
nfRadio.channel( 'fields' ).request( 'add:error', fieldID, errorID, formModel.get( 'settings' ).changeDateErrorMsg );
}
} else {
nfRadio.channel( 'fields' ).request( 'remove:error', fieldID, errorID );
}
},
/**
* When a user types inside of an dat field, track their keypresses
* and add the appropriate class.
* If the value validates as an date, add a class of nf-pass
* If the value does not validate as date, add a class of nf-fail
*
* @since 3.0
* @param {object} el Element that triggered the keyup event.
* @param {object} model Model connected to the element that triggered the event
* @return {void}
*/
dateKeyup: function( el, model, keyCode ) {
/*
* If we pressed the 'tab' key to get to this field, return false.
*/
if ( 9 == keyCode ) {
return false;
}
/*
* Get the current value from our element.
*/
var value = jQuery( el ).val();
/*
* Get our current ID
*/
var fieldID = model.get( 'id' );
/*
* Get our current date format
*/
var format = model.get( 'date_format' );
if( 'default' === format) {
format = nfi18n.dateFormat;
}
/*
* Check our value to see if it is a valid email.
*/
if ( 0 == value.length ) {
nfRadio.channel( 'fields' ).request( 'remove:error', fieldID, errorID );
}
// use moment's isValid to check against the fields format setting
else if ( ! moment( value, format ).isValid() && ! model.get( 'clean' ) ) {
var fieldModel = nfRadio.channel( 'fields' ).request( 'get:field', fieldID );
var formModel = nfRadio.channel( 'app' ).request( 'get:form', fieldModel.get( 'formID' ) );
nfRadio.channel( 'fields' ).request( 'add:error', fieldID, errorID, formModel.get( 'settings' ).changeDateErrorMsg );
model.removeWrapperClass( 'nf-pass' );
}
// use moment's isValid to check against the fields format setting
else if ( moment( value, format ).isValid() ) {
nfRadio.channel( 'fields' ).request( 'remove:error', fieldID, errorID );
/*
* Add nf-pass class to the wrapper.
*/
model.addWrapperClass( 'nf-pass' );
model.set( 'clean', false );
}
},
changeHoursMinutes: function( e, fieldModel ) {
let type = '';
let container = jQuery( e.target ).closest( '.nf-field-element' );
// Set our hour, minute, and ampm
let selected_hour = jQuery( container ).find( '.hour' ).val();
let selected_minute = jQuery( container ).find( '.minute' ).val();
let selected_ampm = jQuery( container ).find( '.ampm' ).val();
fieldModel.set( 'selected_hour', selected_hour );
fieldModel.set( 'selected_minute', selected_minute );
fieldModel.set( 'selected_ampm', selected_ampm );
// Trigger a change on our model.
fieldModel.trigger( 'change:value', fieldModel );
}
});
return controller;
} );
define('controllers/fieldCheckbox',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
/*
* When we init our checkbox model, register our renderClasses() function
*/
this.listenTo( nfRadio.channel( 'checkbox' ), 'init:model', this.registerRenderClasses );
nfRadio.channel( 'checkbox' ).reply( 'validate:required', this.validateRequired );
nfRadio.channel( 'checkbox' ).reply( 'validate:modelData', this.validateModelData );
nfRadio.channel( 'checkbox' ).reply( 'before:updateField', this.beforeUpdateField, this );
nfRadio.channel( 'checkbox' ).reply( 'get:calcValue', this.getCalcValue, this );
},
beforeUpdateField: function( el, model ) {
var checked = jQuery( el ).prop( 'checked' );
if ( checked ) {
var value = 1;
jQuery( el ).addClass( 'nf-checked' );
jQuery( el ).closest( '.field-wrap' ).find( 'label[for="' + jQuery( el ).prop( 'id' ) + '"]' ).addClass( 'nf-checked-label' );
} else {
var value = 0;
jQuery( el ).removeClass( 'nf-checked' );
jQuery( el ).closest( '.field-wrap' ).find( 'label[for="' + jQuery( el ).prop( 'id' ) + '"]' ).removeClass( 'nf-checked-label' );
}
return value;
},
validateRequired: function( el, model ) {
return el[0].checked;
},
validateModelData: function( model ) {
return model.get( 'value' ) != 0;
},
getCalcValue: function( fieldModel ) {
if ( 1 == fieldModel.get( 'value' ) ) {
calcValue = fieldModel.get( 'checked_calc_value' );
} else {
calcValue = fieldModel.get( 'unchecked_calc_value' );
}
return calcValue;
},
registerRenderClasses: function( model ) {
if ( 'checked' == model.get( 'default_value' ) ) {
model.set( 'value', 1 );
} else {
model.set( 'value', 0 );
}
model.set( 'customClasses', this.customClasses );
model.set( 'customLabelClasses', this.customLabelClasses );
model.set( 'maybeChecked', this.maybeChecked );
},
customClasses: function( classes ) {
if ( 1 == this.value || ( this.clean && 'undefined' != typeof this.default_value && 'checked' == this.default_value ) ) {
classes += ' nf-checked';
} else {
classes.replace( 'nf-checked', '' );
}
return classes;
},
customLabelClasses: function( classes ) {
if ( 1 == this.value || ( this.clean && 'undefined' != typeof this.default_value && 'checked' == this.default_value ) ) {
classes += ' nf-checked-label';
} else {
classes.replace( 'nf-checked-label', '' );
}
return classes;
},
maybeChecked: function() {
if ( 1 == this.value || ( this.clean && 'undefined' != typeof this.default_value && 'checked' == this.default_value ) ) {
return ' checked';
} else {
return '';
}
}
});
return controller;
} );
define('controllers/fieldCheckboxList',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'listcheckbox' ), 'init:model', this.register );
this.listenTo( nfRadio.channel( 'terms' ), 'init:model', this.register );
nfRadio.channel( 'listcheckbox' ).reply( 'before:updateField', this.beforeUpdateField, this );
nfRadio.channel( 'terms' ).reply( 'before:updateField', this.beforeUpdateField, this );
nfRadio.channel( 'listcheckbox' ).reply( 'get:calcValue', this.getCalcValue, this );
nfRadio.channel( 'terms' ).reply( 'get:calcValue', this.getCalcValue, this );
},
register: function( model ) {
model.set( 'renderOptions', this.renderOptions );
model.set( 'renderOtherText', this.renderOtherText );
model.set( 'selected', [] );
/*
* When we init a model, we need to set our 'value' to the selected option's value.
* This is the list equivalent of a 'default value'.
*/
if ( 0 != model.get( 'options' ).length ) {
var selected = _.filter( model.get( 'options' ), function( opt ) { return 1 == opt.selected } );
selected = _.map( selected, function( opt ) { return opt.value } );
}
/*
* This part is re-worked to take into account custom user-meta
* values for fields.
*/
var savedVal = model.get( 'value' );
if( 'undefined' !== typeof savedVal && Array.isArray( savedVal ) ) {
model.set( 'value', savedVal );
} else if ( 'undefined' != typeof selected ) {
model.set( 'value', selected );
}
},
renderOptions: function() {
var html = '';
if ( '' == this.value || ( Array.isArray( this.value ) && 0 < this.value.length )
|| 0 < this.value.length ) {
var valueFound = true;
} else {
var valueFound = false;
}
_.each( this.options, function( option, index ) {
if( Array.isArray( this.value ) ) {
if( Array.isArray( this.value[ 0 ] ) && -1 !== _.indexOf( this.value[ 0 ], option.value ) ) {
valueFound = true;
}
else if( _.indexOf( this.value, option.value ) ) {
valueFound = true;
}
}
if ( option.value == this.value ) {
valueFound = true;
}
/*
* TODO: This is a bandaid fix for making sure that each option has a "visible" property.
* This should be moved to creation so that when an option is added, it has a visible property by default.
*/
if ( 'undefined' == typeof option.visible ) {
option.visible = true;
}
option.fieldID = this.id;
option.classes = this.classes;
option.index = index;
var selected = false;
/*
* This part has been re-worked to account for values passed in
* via custom user-meta ( a la User Mgmt add-on)
*/
if( Array.isArray( this.value ) && 0 < this.value.length ) {
if ( -1 !== _.indexOf( this.value[ 0 ].split( ',' ), option.value )
|| -1 !== _.indexOf( this.value, option.value ) ) {
selected = true;
}
} else if ( ! _.isArray( this.value ) && option.value == this.value ) {
selected = true;
} else if ( ( 1 == option.selected && this.clean ) && 'undefined' === typeof this.value ) {
selected = true;
}
// else if( ( option.selected && "0" != option.selected ) && this.clean ){
// isSelected = true;
// } else {
// var testValues = _.map( this.value, function( value ) {
// return value.toString();
// } );
//
// option.isSelected = ( -1 != testValues.indexOf( option.value.toString() ) );
// }
option.selected = selected;
option.isSelected = selected;
option.required = this.required;
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-field-listcheckbox-option' );
html += template( option );
}, this );
if ( 1 == this.show_other ) {
if ( 'nf-other' == this.value ) {
valueFound = false;
}
var data = {
fieldID: this.id,
classes: this.classes,
currentValue: this.value,
renderOtherText: this.renderOtherText,
valueFound: valueFound
};
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-field-listcheckbox-other' );
html += template( data );
}
return html;
},
renderOtherText: function() {
if ( 'nf-other' == this.currentValue || ! this.valueFound ) {
if ( 'nf-other' == this.currentValue ) {
this.currentValue = '';
}
var data = {
fieldID: this.fieldID,
classes: this.classes,
currentValue: this.currentValue
};
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-field-listcheckbox-other-text' );
return template( data );
}
},
getCalcValue: function( fieldModel ) {
var calc_value = 0;
var options = fieldModel.get( 'options' );
if ( 0 != options.length ) {
_.each( fieldModel.get( 'value' ), function( val ) {
var tmp_opt = _.find( options, function( opt ) { return opt.value == val } );
calc_value = Number( calc_value ) + Number( tmp_opt.calc );
} );
}
return calc_value;
},
beforeUpdateField: function( el, model ) {
var selected = model.get( 'value' ) || [];
if ( typeof selected == 'string' ) selected = [ selected ];
var value = jQuery( el ).val();
var checked = jQuery( el ).prop( 'checked' );
if ( checked ) {
selected.push( value );
jQuery( el ).addClass( 'nf-checked' );
jQuery( el ).parent().find( 'label[for="' + jQuery( el ).prop( 'id' ) + '"]' ).addClass( 'nf-checked-label' );
} else {
jQuery( el ).removeClass( 'nf-checked' );
jQuery( el ).parent().find( 'label[for="' + jQuery( el ).prop( 'id' ) + '"]' ).removeClass( 'nf-checked-label' );
var i = selected.indexOf( value );
if( -1 != i ){
selected.splice( i, 1 );
} else if ( Array.isArray( selected ) ) {
var optionArray = selected[0].split( ',' );
var valueIndex = optionArray.indexOf( value );
if( -1 !== valueIndex) {
optionArray.splice( valueIndex, 1 );
}
selected = optionArray.join( ',' );
}
}
// if ( 1 == model.get( 'show_other' ) ) {
// model.set( 'reRender', true );
// }
return _.clone( selected );
}
});
return controller;
} );
define('controllers/fieldImageList',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'listimage' ), 'init:model', this.register );
nfRadio.channel( 'listimage' ).reply( 'before:updateField', this.beforeUpdateField, this );
nfRadio.channel( 'listimage' ).reply( 'get:calcValue', this.getCalcValue, this );
},
register: function( model ) {
model.set( 'renderOptions', this.renderOptions );
model.set( 'renderOtherText', this.renderOtherText );
model.set( 'selected', [] );
/*
* When we init a model, we need to set our 'value' to the selected option's value.
* This is the list equivalent of a 'default value'.
*/
if ( 0 != model.get( 'image_options' ).length ) {
var selected = _.filter( model.get( 'image_options' ), function( opt ) { return 1 == opt.selected } );
selected = _.map( selected, function( opt ) { return opt.value } );
}
/*
* This part is re-worked to take into account custom user-meta
* values for fields.
*/
var savedVal = model.get( 'value' );
if( 'undefined' !== typeof savedVal && Array.isArray( savedVal ) ) {
model.set( 'value', savedVal );
} else if ( 'undefined' != typeof selected ) {
model.set( 'value', selected );
}
},
renderOptions: function() {
var html = '';
if ( '' == this.value || ( Array.isArray( this.value ) && 0 < this.value.length )
|| 0 < this.value.length ) {
var valueFound = true;
} else {
var valueFound = false;
}
if (this.allow_multi_select === 1) {
this.old_classname = 'list-checkbox';
this.image_type = 'checkbox';
} else {
this.image_type = 'radio';
}
if(this.list_orientation === 'horizontal') {
this.flex_direction = 'row';
} else {
this.flex_direction = 'column';
}
var that = this;
var num_columns = parseInt(this.num_columns) || 1;
var current_column = 1;
var current_row = 1;
_.each( this.image_options, function( image, index ) {
if (!this.show_option_labels) {
image.label = '';
}
if( Array.isArray( this.value ) ) {
if( Array.isArray( this.value[ 0 ] ) && -1 !== _.indexOf( this.value[ 0 ], image.value ) ) {
valueFound = true;
}
else if( _.indexOf( this.value, image.value ) ) {
valueFound = true;
}
}
if ( image.value == this.value ) {
valueFound = true;
}
/*
* TODO: This is a bandaid fix for making sure that each option has a "visible" property.
* This should be moved to creation so that when an option is added, it has a visible property by default.
*/
if ( 'undefined' == typeof image.visible ) {
image.visible = true;
}
if(that.list_orientation === 'horizontal' && current_column <= num_columns) {
image.styles = "margin:auto;grid-column: " + current_column + "; grid-row = " + current_row;
if(current_column === num_columns) {
current_column = 1;
current_row += 1;
} else {
current_column += 1;
}
}
image.image_type = that.image_type;
image.fieldID = this.id;
image.classes = this.classes;
image.index = index;
var selected = false;
/*
* This part has been re-worked to account for values passed in
* via custom user-meta ( a la User Mgmt add-on)
*/
if( Array.isArray( this.value ) && 0 < this.value.length ) {
if ( -1 !== _.indexOf( this.value[ 0 ].split( ',' ), image.value )
|| -1 !== _.indexOf( this.value, image.value ) ) {
selected = true;
}
} else if ( ! _.isArray( this.value ) && image.value == this.value ) {
selected = true;
} else if ( ( 1 == image.selected && this.clean ) && ('undefined' === typeof this.value || '' === this.value)) {
selected = true;
}
image.selected = selected;
image.isSelected = selected;
image.required = this.required;
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-field-listimage-option' );
html += template( image );
}, this );
if ( 1 == this.show_other ) {
if ( 'nf-other' == this.value ) {
valueFound = false;
}
var data = {
fieldID: this.id,
classes: this.classes,
value: this.value,
currentValue: this.value,
renderOtherText: this.renderOtherText,
valueFound: valueFound
};
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-field-listimage-other' );
html += template( data );
}
return html;
},
renderOtherText: function() {
if ( 'nf-other' == this.currentValue || ! this.valueFound ) {
if ( 'nf-other' == this.currentValue ) {
this.currentValue = '';
}
var data = {
fieldID: this.fieldID,
classes: this.classes,
currentValue: this.currentValue
};
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-field-listimage-other-text' );
return template( data );
}
},
getCalcValue: function( fieldModel ) {
var calc_value = 0;
var options = fieldModel.get( 'options' );
if ( 0 != options.length ) {
/*
* Check to see if this is a multi-select list.
*/
if ( 1 == parseInt( fieldModel.get( 'allow_multi_select' ) ) ) {
/*
* We're using a multi-select, so we need to check out any selected options and add them together.
*/
_.each( fieldModel.get( 'value' ), function( val ) {
var tmp_opt = _.find( options, function( opt ) { return opt.value == val } );
calc_value += Number( tmp_opt.calc );
} );
} else {
/*
* We are using a single select, so our selected option is in the 'value' attribute.
*/
var selected = _.find( options, function( opt ) { return fieldModel.get( 'value' ) == opt.value } );
/*
* If we have a selcted value, use it.
*/
if ( 'undefined' !== typeof selected ) {
calc_value = selected.calc;
}
}
}
return calc_value;
},
beforeUpdateField: function( el, model ) {
if(model.get('allow_multi_select') !== 1) {
var selected = jQuery( el ).val();
var options = model.get('image_options');
_.each(options, function(option, index) {
if(option.value === selected) {
option.isSelected = true;
option.selected = true;
} else {
option.isSelected = false;
option.selected = false;
}
if(!option.isSelected) {
option.selected = false;
jQuery("#nf-field-" + option.fieldID + "-" + index).removeClass('nf-checked');
jQuery("#nf-label-field-" + option.fieldID + "-" + index).removeClass('nf-checked-label');
} else {
jQuery("#nf-field-" + option.fieldID + "-" + index).addClass('nf-checked');
jQuery("#nf-label-field-" + option.fieldID + "-" + index).addClass('nf-checked-label');
}
});
} else {
var selected = model.get( 'value' ) || [];
if ( typeof selected == 'string' ) selected = [ selected ];
var value = jQuery( el ).val();
var checked = jQuery( el ).prop( 'checked' );
if ( checked ) {
selected.push( value );
jQuery( el ).addClass( 'nf-checked' );
jQuery( el ).parent().find( 'label[for="' + jQuery( el ).prop( 'id' ) + '"]' ).addClass( 'nf-checked-label' );
} else {
jQuery( el ).removeClass( 'nf-checked' );
jQuery( el ).parent().find( 'label[for="' + jQuery( el ).prop( 'id' ) + '"]' ).removeClass( 'nf-checked-label' );
var i = selected.indexOf( value );
if( -1 != i ){
selected.splice( i, 1 );
} else if ( Array.isArray( selected ) ) {
var optionArray = selected[0].split( ',' );
var valueIndex = optionArray.indexOf( value );
if( -1 !== valueIndex) {
optionArray.splice( valueIndex, 1 );
}
selected = optionArray.join( ',' );
}
}
}
return _.clone( selected );
}
});
return controller;
} );
define('controllers/fieldRadio',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'listradio' ), 'change:modelValue', this.changeModelValue );
this.listenTo( nfRadio.channel( 'listradio' ), 'init:model', this.register );
nfRadio.channel( 'listradio' ).reply( 'get:calcValue', this.getCalcValue, this );
this.listenTo( nfRadio.channel( 'listradio' ), 'change:field', this.updateCheckedClass, this );
},
register: function( model ) {
model.set( 'renderOptions', this.renderOptions );
model.set( 'renderOtherText', this.renderOtherText );
/*
* When we init a model, we need to set our 'value' to the selected option's value.
* This is the list equivalent of a 'default value'.
*/
if ( 0 != model.get( 'options' ).length ) {
/*
* Check to see if we have a selected value.
*/
var selected = _.find( model.get( 'options' ), function( opt ) { return 1 == opt.selected } );
if ( 'undefined' != typeof selected ) {
model.set( 'value', selected.value );
}
}
},
changeModelValue: function( model ) {
if ( 1 == model.get( 'show_other' ) ) {
// model.set( 'reRender', true );
model.trigger( 'reRender');
}
},
renderOptions: function() {
var html = '';
if ( '' == this.value ) {
var valueFound = true;
} else {
var valueFound = false;
}
_.each( this.options, function( option, index ) {
if ( option.value == this.value ) {
valueFound = true;
}
/*
* TODO: This is a bandaid fix for making sure that each option has a "visible" property.
* This should be moved to creation so that when an option is added, it has a visible property by default.
*/
if ( 'undefined' == typeof option.visible ) {
option.visible = true;
}
option.selected = false;
option.fieldID = this.id;
option.classes = this.classes;
option.currentValue = this.value;
option.index = index;
option.required = this.required;
/*
* If we haven't edited this field yet, use the default checked
*/
if ( this.clean && 1 == this.selected ) {
option.selected = true;
} else if ( this.value == option.value ) {
option.selected = true;
} else {
option.selected = false;
}
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-field-listradio-option' );
html += template( option );
}, this );
if ( 1 == this.show_other ) {
if ( 'nf-other' == this.value ) {
valueFound = false;
}
var data = {
fieldID: this.id,
classes: this.classes,
currentValue: this.value,
renderOtherText: this.renderOtherText,
valueFound: valueFound
};
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-field-listradio-other' );
html += template( data );
}
return html;
},
renderOtherText: function() {
if ( 'nf-other' == this.currentValue || ! this.valueFound ) {
if ( 'nf-other' == this.currentValue ) {
this.currentValue = '';
}
var data = {
fieldID: this.fieldID,
classes: this.classes,
currentValue: this.currentValue
};
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-field-listradio-other-text' );
return template( data );
}
},
getCalcValue: function( fieldModel ) {
/*
* Default to 0, in case we have no selection.
*/
var calc_value = 0;
if ( 0 != fieldModel.get( 'options' ).length ) {
/*
* Check to see if we have a selected value.
*/
var selected = _.find( fieldModel.get( 'options' ), function( opt ) { return fieldModel.get( 'value' ) == opt.value } );
if ( 'undefined' !== typeof selected ) {
calc_value = selected.calc;
}
}
return calc_value;
},
updateCheckedClass: function( el, model ) {
jQuery( '[name="' + jQuery( el ).attr( 'name' ) + '"]' ).removeClass( 'nf-checked' );
jQuery( el ).closest( 'ul' ).find( 'label' ).removeClass( 'nf-checked-label' );
jQuery( el ).addClass( 'nf-checked' );
jQuery( el ).closest( 'li' ).find( 'label[for="' + jQuery( el ).prop( 'id' ) + '"]' ).addClass( 'nf-checked-label' );
}
});
return controller;
} );
define('controllers/fieldNumber',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'number' ), 'init:model', this.maybeMinDefault );
this.listenTo( nfRadio.channel( 'number' ), 'keyup:field', this.validateMinMax );
},
maybeMinDefault: function( model ) {
if( '' == model.get( 'value' ) && '' == model.get( 'placeholder' ) ){
var min = model.get( 'num_min' );
model.set( 'placeholder', min );
}
},
validateMinMax: function( el, model ) {
var $el = jQuery( el );
var value = parseFloat( $el.val() );
var min = $el.attr( 'min' );
var max = $el.attr( 'max' );
var step = parseFloat( $el.attr( 'step' ) );
if( min && value < min ){
var fieldModel = nfRadio.channel( 'fields' ).request( 'get:field', model.get( 'id' ) );
var formModel = nfRadio.channel( 'app' ).request( 'get:form', fieldModel.get( 'formID' ) );
nfRadio.channel( 'fields' ).request( 'add:error', model.get( 'id' ), 'number-min', formModel.get( 'settings' ).fieldNumberNumMinError );
} else {
nfRadio.channel( 'fields' ).request( 'remove:error', model.get( 'id' ), 'number-min' );
}
if ( max && value > max ){
var fieldModel = nfRadio.channel( 'fields' ).request( 'get:field', model.get( 'id' ) );
var formModel = nfRadio.channel( 'app' ).request( 'get:form', fieldModel.get( 'formID' ) );
nfRadio.channel( 'fields' ).request( 'add:error', model.get( 'id' ), 'number-max', formModel.get( 'settings' ).fieldNumberNumMaxError );
} else {
nfRadio.channel( 'fields' ).request( 'remove:error', model.get( 'id' ), 'number-max' );
}
var testValue = Math.round( parseFloat( value ) * 1000000000 );
var testStep = Math.round( parseFloat( step ) * 1000000000 );
if( value && 0 !== testValue % testStep ){
var fieldModel = nfRadio.channel( 'fields' ).request( 'get:field', model.get( 'id' ) );
var formModel = nfRadio.channel( 'app' ).request( 'get:form', fieldModel.get( 'formID' ) );
nfRadio.channel( 'fields' ).request( 'add:error', model.get( 'id' ), 'number-step', formModel.get( 'settings' ).fieldNumberIncrementBy + step );
} else {
nfRadio.channel( 'fields' ).request( 'remove:error', model.get( 'id' ), 'number-step' );
}
}
});
return controller;
} );
define( 'controllers/mirrorField',[], function() {
var radioChannel = nfRadio.channel( 'fields' );
var controller = Marionette.Object.extend( {
listeningModel: '',
initialize: function() {
this.listenTo( radioChannel, 'init:model', this.registerMirror );
},
registerMirror: function( model ) {
if ( model.get( 'mirror_field' ) ) {
this.listeningModel = model;
var targetID = model.get( 'mirror_field' );
this.listenTo( nfRadio.channel( 'field-' + targetID ), 'change:modelValue', this.changeValue );
}
},
changeValue: function( targetModel ) {
this.listeningModel.set( 'value', targetModel.get( 'value' ) );
// this.listeningModel.set( 'reRender', true );
this.listeningModel.trigger( 'reRender' );
}
});
return controller;
} );
define( 'controllers/confirmField',[], function() {
var radioChannel = nfRadio.channel( 'fields' );
var errorID = 'confirm-mismatch';
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( radioChannel, 'init:model', this.registerConfirm );
this.listenTo( radioChannel, 'keyup:field', this.confirmKeyup );
},
registerConfirm: function( confirmModel ) {
if ( ! confirmModel.get( 'confirm_field' ) ) return;
this.listenTo( nfRadio.channel( 'form' ), 'loaded', function( formModal ){
this.registerConfirmListeners( confirmModel );
});
},
registerConfirmListeners: function( confirmModel ) {
var targetModel = nfRadio.channel( 'form-' + confirmModel.get( 'formID' ) ).request( 'get:fieldByKey', confirmModel.get( 'confirm_field' ) );
//TODO: Add better handling for password confirm fields on the front end.
if( 'undefined' == typeof targetModel ) return;
targetModel.set( 'confirm_with', confirmModel.get( 'id' ) );
this.listenTo( nfRadio.channel( 'field-' + targetModel.get( 'id' ) ), 'change:modelValue', this.changeValue );
this.listenTo( nfRadio.channel( 'field-' + confirmModel.get( 'id' ) ), 'change:modelValue', this.changeValue );
},
changeValue: function( model ) {
if ( 'undefined' == typeof model.get( 'confirm_with' ) ) {
var confirmModel = model;
var targetModel = nfRadio.channel( 'form-' + model.get( 'formID' ) ).request( 'get:fieldByKey', confirmModel.get( 'confirm_field' ) );
} else {
var targetModel = model;
var confirmModel = radioChannel.request( 'get:field', targetModel.get( 'confirm_with' ) );
}
var targetID = targetModel.get( 'id' );
var confirmID = confirmModel.get( 'id' );
if ( '' == confirmModel.get( 'value' ) || confirmModel.get( 'value' ) == targetModel.get( 'value' ) ) {
nfRadio.channel( 'fields' ).request( 'remove:error', confirmID, errorID );
} else {
var fieldModel = nfRadio.channel( 'fields' ).request( 'get:field', confirmID );
var formModel = nfRadio.channel( 'app' ).request( 'get:form', fieldModel.get( 'formID' ) );
nfRadio.channel( 'fields' ).request( 'add:error', confirmID, errorID, formModel.get( 'settings' ).confirmFieldErrorMsg );
}
},
confirmKeyup: function( el, model, keyCode ) {
var currentValue = jQuery( el ).val();
if ( model.get( 'confirm_field' ) ) {
var confirmModel = model;
var confirmID = model.get( 'id' );
var targetModel = nfRadio.channel( 'form-' + model.get( 'formID' ) ).request( 'get:fieldByKey', confirmModel.get( 'confirm_field' ) );
var compareValue = targetModel.get( 'value' );
var confirmValue = currentValue;
} else if ( model.get( 'confirm_with' ) ) {
var confirmModel = nfRadio.channel( 'fields' ).request( 'get:field', model.get( 'confirm_with' ) );
var confirmID = confirmModel.get( 'id' );
var confirmValue = confirmModel.get( 'value' );
var compareValue = confirmValue;
}
if ( 'undefined' !== typeof confirmModel ) {
if ( '' == confirmValue ) {
nfRadio.channel( 'fields' ).request( 'remove:error', confirmID, errorID );
} else if ( currentValue == compareValue ) {
nfRadio.channel( 'fields' ).request( 'remove:error', confirmID, errorID );
} else {
var fieldModel = nfRadio.channel( 'fields' ).request( 'get:field', confirmID );
var formModel = nfRadio.channel( 'app' ).request( 'get:form', fieldModel.get( 'formID' ) );
nfRadio.channel( 'fields' ).request( 'add:error', confirmID, errorID, formModel.get( 'settings' ).confirmFieldErrorMsg );
}
}
}
});
return controller;
} );
define('controllers/updateFieldModel',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
nfRadio.channel( 'nfAdmin' ).reply( 'update:field', this.updateField );
},
updateField: function( model, value ) {
if ( ! model.get( 'isUpdated' ) ) {
model.set( 'value', value );
model.set( 'isUpdated', true );
/*
* If we're working with an array, it won't trigger a change event on the value attribute.
* Instead, we have to manually trigger a change event.
*/
if ( _.isArray( value ) ) {
model.trigger( 'change:value', model );
}
}
}
});
return controller;
} );
define('controllers/submitButton',['controllers/submitButton'], function( submitButton ) {
var controller = Marionette.Object.extend( {
bound: {},
initialize: function() {
this.listenTo( nfRadio.channel( 'submit' ), 'init:model', this.registerHandlers );
},
registerHandlers: function( fieldModel ) {
if ( 'undefined' != typeof this.bound[ fieldModel.get( 'id' ) ] ) {
return false;
}
this.listenTo( nfRadio.channel( 'field-' + fieldModel.get( 'id' ) ), 'click:field', this.click, this );
/*
* Register an interest in the 'before:submit' event of our form.
*/
fieldModel.listenTo( nfRadio.channel( 'form-' + fieldModel.get( 'formID' ) ), 'before:submit', this.beforeSubmit, fieldModel );
fieldModel.listenTo( nfRadio.channel( 'form-' + fieldModel.get( 'formID' ) ), 'submit:failed', this.resetLabel, fieldModel );
fieldModel.listenTo( nfRadio.channel( 'form-' + fieldModel.get( 'formID' ) ), 'submit:response', this.resetLabel, fieldModel );
fieldModel.listenTo( nfRadio.channel( 'form-' + fieldModel.get( 'formID' ) ), 'enable:submit', this.maybeEnable, fieldModel );
fieldModel.listenTo( nfRadio.channel( 'form-' + fieldModel.get( 'formID' ) ), 'disable:submit', this.maybeDisable, fieldModel );
fieldModel.listenTo( nfRadio.channel( 'form-' + fieldModel.get( 'formID' ) ), 'processingLabel', this.processingLabel, fieldModel );
fieldModel.listenTo( nfRadio.channel( 'fields' ), 'add:error', this.maybeDisable, fieldModel );
fieldModel.listenTo( nfRadio.channel( 'fields' ), 'remove:error', this.maybeEnable, fieldModel );
this.bound[ fieldModel.get( 'id') ] = true;
},
click: function( e, fieldModel ) {
var formModel = nfRadio.channel( 'app' ).request( 'get:form', fieldModel.get( 'formID' ) );
nfRadio.channel( 'form-' + fieldModel.get( 'formID' ) ).request( 'submit', formModel );
},
beforeSubmit: function() {
this.set( 'disabled', true );
nfRadio.channel( 'form-' + this.get( 'formID' ) ).trigger( 'processingLabel', this );
},
maybeDisable: function( fieldModel ) {
if( 'undefined' != typeof fieldModel && fieldModel.get( 'formID' ) != this.get( 'formID' ) ) return;
this.set( 'disabled', true );
this.trigger( 'reRender' );
},
maybeEnable: function( fieldModel ) {
/*
* If the field reporting the error is not on the same form as the submit button, return false;
*/
if ( 'undefined' != typeof fieldModel && fieldModel.get( 'formID' ) != this.get( 'formID' ) ) {
return false;
}
var formModel = nfRadio.channel( 'app' ).request( 'get:form', this.get( 'formID' ) );
if ( 0 == _.size( formModel.get( 'fieldErrors' ) ) ) {
this.set( 'disabled', false );
this.trigger( 'reRender' );
}
},
processingLabel: function() {
if ( this.get( 'label' ) == this.get( 'processing_label' ) ) return false;
this.set( 'oldLabel', this.get( 'label' ) );
this.set( 'label', this.get( 'processing_label' ) );
this.trigger( 'reRender' );
},
resetLabel: function( response ) {
if ( 'undefined' != typeof response.errors &&
'undefined' != typeof response.errors.nonce &&
_.size( response.errors.nonce ) > 0 ) {
if( 'undefined' != typeof response.errors.nonce.new_nonce && 'undefined' != typeof response.errors.nonce.nonce_ts ) {
// Do not reset label for nonce errors, which will re-submit the form.
return;
}
}
if ( 'undefined' != typeof this.get( 'oldLabel' ) ) {
this.set( 'label', this.get( 'oldLabel' ) );
}
this.set( 'disabled', false );
this.trigger( 'reRender' );
}
});
return controller;
} );
define('controllers/submitDebug',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'forms' ), 'submit:response', this.submitDebug );
},
submitDebug: function( response, textStatus, jqXHR, formID ) {
if( 'undefined' == typeof response.debug ) return;
/* Form Debug Messages */
if( 'undefined' != typeof response.debug.form ) {
var debugMessages = document.createElement( 'span' );
_.each(response.debug.form, function (message, index) {
var messageText = document.createTextNode( message );
debugMessages.appendChild( messageText );
debugMessages.appendChild(
document.createElement( 'br' )
);
});
jQuery('.nf-debug-msg').html( debugMessages );
}
/* Console Debug Messages */
if( 'undefined' != typeof response.debug.console ) {
var style = '';
console.log( '%c%s', style, 'NINJA SUPPORT' );
_.each(response.debug.console, function (message, index) {
console.log( message );
});
console.log( '%c%s', style, 'END NINJA SUPPORT' );
}
}
});
return controller;
} );
define('controllers/getFormErrors',[], function() {
var radioChannel = nfRadio.channel( 'fields' );
var controller = Marionette.Object.extend( {
initialize: function( model ) {
nfRadio.channel( 'form' ).reply( 'get:errors', this.getFormErrors );
},
getFormErrors: function( formID ) {
var formModel = nfRadio.channel( 'app' ).request( 'get:form', formID );
var errors = false;
if ( formModel ) {
/*
* Check to see if we have any errors on our form model.
*/
if ( 0 !== formModel.get( 'errors' ).length ) {
_.each( formModel.get( 'errors' ).models, function( error ) {
errors = errors || {};
errors[ error.get( 'id' ) ] = error.get( 'msg' );
} );
}
_.each( formModel.get( 'fields' ).models, function( field ) {
if ( field.get( 'type' ) != 'submit' && field.get( 'errors' ).length > 0 ) {
errors = errors || {};
errors[ field.get( 'id' ) ] = field.get( 'errors' );
}
} );
}
return errors;
},
});
return controller;
} );
define('controllers/validateRequired',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'fields' ), 'blur:field', this.validateRequired );
this.listenTo( nfRadio.channel( 'fields' ), 'change:field', this.validateRequired );
this.listenTo( nfRadio.channel( 'fields' ), 'keyup:field', this.validateKeyup );
this.listenTo( nfRadio.channel( 'fields' ), 'change:modelValue', this.validateModelData );
this.listenTo( nfRadio.channel( 'submit' ), 'validate:field', this.validateModelData );
},
validateKeyup: function( el, model, keyCode ) {
if ( 1 != model.get( 'required' ) ) {
return false;
}
if ( ! model.get( 'clean' ) ) {
this.validateRequired( el, model );
}
},
validateRequired: function( el, model ) {
if ( 1 != model.get( 'required' ) || ! model.get( 'visible' ) ) {
return false;
}
var currentValue = jQuery( el ).val();
var customReqValidation = nfRadio.channel( model.get( 'type' ) ).request( 'validate:required', el, model );
var defaultReqValidation = true;
var maskPlaceholder = model.get( 'mask' );
if ( maskPlaceholder ) {
maskPlaceholder = maskPlaceholder.replace( /9/g, '_' );
maskPlaceholder = maskPlaceholder.replace( /a/g, '_' );
maskPlaceholder = maskPlaceholder.replace( /\*/g, '_' );
}
// If the field has a mask...
// AND that mask is equal to the current value...
if ( maskPlaceholder && currentValue === maskPlaceholder ) {
// If we have a pre-existing error...
if ( 0 < model.get( 'errors' ).length ) {
// Persist that error.
defaultReqValidation = false;
}
}
// If our value is an empty string...
if ( ! jQuery.trim( currentValue ) ) {
// Throw an error.
defaultReqValidation = false;
}
if ( 'undefined' !== typeof customReqValidation ) {
var valid = customReqValidation;
} else {
var valid = defaultReqValidation;
}
this.maybeError( valid, model );
},
validateModelData: function( model ) {
if ( 1 != model.get( 'required' ) || ! model.get( 'visible' ) || model.get( 'clean' ) ) {
return false;
}
/*
* If we already have a required error on this model, return false
*/
if ( model.get( 'errors' ).get( 'required-error' ) ) {
return false;
}
currentValue = model.get( 'value' );
var defaultReqValidation = true;
if ( ! jQuery.trim( currentValue ) ) {
defaultReqValidation = false;
}
var customReqValidation = nfRadio.channel( model.get( 'type' ) ).request( 'validate:modelData', model );
if ( 'undefined' !== typeof customReqValidation ) {
var valid = customReqValidation;
} else {
var valid = defaultReqValidation;
}
this.maybeError( valid, model );
},
maybeError: function( valid, model ) {
if ( ! valid ) {
var formModel = nfRadio.channel( 'form-' + model.get( 'formID' ) ).request( 'get:form' );
if( 'undefined' != typeof formModel ) {
nfRadio.channel('fields').request('add:error', model.get('id'), 'required-error', formModel.get('settings').validateRequiredField);
}
} else {
nfRadio.channel( 'fields' ).request( 'remove:error', model.get( 'id' ), 'required-error' );
}
}
});
return controller;
} );
define('controllers/submitError',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'forms' ), 'submit:response', this.submitErrors );
},
submitErrors: function( response, textStatus, jqXHR, formID ) {
// Check for nonce error.
if ( _.size( response.errors.nonce ) > 0 ) {
if( 'undefined' != typeof response.errors.nonce.new_nonce && 'undefined' != typeof response.errors.nonce.nonce_ts ) {
// Update nonce from response.
nfFrontEnd.ajaxNonce = response.errors.nonce.new_nonce;
nfFrontEnd.nonce_ts = response.errors.nonce.nonce_ts;
// Re-submit form.
var formModel = nfRadio.channel( 'app' ).request( 'get:form', formID );
nfRadio.channel( 'form-' + formID ).request( 'submit', formModel );
}
}
if ( _.size( response.errors.fields ) > 0 ) {
_.each( response.errors.fields, function( data, fieldID ) {
if ( typeof( data ) === 'object' ) {
nfRadio.channel( 'fields' ).request( 'add:error', fieldID, data.slug, data.message );
} else {
nfRadio.channel( 'fields' ).request( 'add:error', fieldID, 'required-error', data );
}
} );
}
if ( _.size( response.errors.form ) > 0 ) {
_.each( response.errors.form, function( msg, errorID ) {
nfRadio.channel( 'form-' + formID ).request( 'remove:error', errorID );
nfRadio.channel( 'form-' + formID ).request( 'add:error', errorID, msg );
} );
}
if ( 'undefined' != typeof response.errors.last ) {
if( 'undefined' != typeof response.errors.last.message ) {
var style = 'background: rgba( 255, 207, 115, .5 ); color: #FFA700; display: block;';
console.log( '%c NINJA FORMS SUPPORT: SERVER ERROR', style );
console.log( response.errors.last.message );
console.log( '%c END SERVER ERROR MESSAGE', style );
}
}
/**
* TODO: This needs to be re-worked for backbone. It's not dynamic enough.
*/
/*
* Re-show any hidden fields during a form submission re-start.
*/
jQuery( '#nf-form-' + formID + '-cont .nf-field-container' ).show();
}
});
return controller;
} );
define('controllers/actionRedirect',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'forms' ), 'submit:response', this.actionRedirect );
},
actionRedirect: function( response ) {
if ( 'undefined' != typeof response.data.halt && 'undefined' != typeof response.data.halt.redirect && '' != response.data.halt.redirect ) {
window.location = response.data.halt.redirect;
}
if ( _.size( response.errors ) == 0 && 'undefined' != typeof response.data.actions ) {
if ( 'undefined' != typeof response.data.actions.redirect && '' != response.data.actions.redirect ) {
window.location = response.data.actions.redirect;
}
}
}
});
return controller;
} );
define('controllers/actionSuccess',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'forms' ), 'submit:response', this.actionSubmit );
},
actionSubmit: function( response ) {
if ( _.size( response.errors ) == 0 && 'undefined' != typeof response.data.actions ) {
if ( 'undefined' != typeof response.data.actions.success_message && '' != response.data.actions.success_message ) {
var form_id = response.data.form_id;
var success_message = jQuery( '#nf-form-' + form_id + '-cont .nf-response-msg' );
success_message.html( response.data.actions.success_message ).show();
//Let's check if the success message is already fully visible in the viewport without scrolling
var top_of_success_message = success_message.offset().top;
var bottom_of_success_message = success_message.offset().top + success_message.outerHeight();
var bottom_of_screen = jQuery(window).scrollTop() + jQuery(window).height();
var top_of_screen = jQuery(window).scrollTop();
var the_element_is_visible = ((bottom_of_screen > bottom_of_success_message) && (top_of_screen < top_of_success_message));
if(!the_element_is_visible){
//The element isn't visible, so let's scroll to the success message as in the previous release, but with a short animation
jQuery('html, body').animate({
scrollTop: ( success_message.offset().top - 50 )
}, 300 );
}
}
}
}
});
return controller;
} );
define('controllers/fieldSelect',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'fields' ), 'init:model', function( model ){
if( 'list' == model.get( 'parentType' ) ) this.register( model );
}, this );
nfRadio.channel( 'listselect' ).reply( 'get:calcValue', this.getCalcValue, this );
nfRadio.channel( 'listmultiselect' ).reply( 'get:calcValue', this.getCalcValue, this );
},
register: function( model ) {
model.set( 'renderOptions', this.renderOptions );
model.set( 'renderOtherAttributes', this.renderOtherAttributes );
/*
* When we init a model, we need to set our 'value' to the selected option's value.
* This is the list equivalent of a 'default value'.
*/
if ( 0 != model.get( 'options' ).length ) {
//Check to see if there is a value set for the field
var savedVal = model.get( 'value' );
/*
* Check to see if this is a multi-select list.
*/
if ( 'listmultiselect' == model.get( 'type' ) ) {
/*
* We're using a multi-select, so we need to check out any selected options and add them together.
*/
var selected = _.filter( model.get( 'options' ), function( opt ) { return 1 == opt.selected } );
selected = _.map( selected, function( opt ) { return opt.value } );
var value = selected;
} else if ( 'listradio' !== model.get( 'type' ) ) {
/*
* Check to see if we have a selected value.
*/
var selected = _.find( model.get( 'options' ), function( opt ) { return 1 == opt.selected } );
/*
* We don't have a selected value, so use our first option.
*/
if ( 'undefined' == typeof selected ) {
selected = _.first( model.get( 'options' ) );
}
if ( 'undefined' != typeof selected
&& 'undefined' != typeof selected.value ) {
var value = selected.value;
} else if ( 'undefined' != typeof selected ) {
var value = selected.label;
}
}
/*
* This part is re-worked to take into account custom user-meta
* values for fields.
*/
if( 'undefined' !== typeof savedVal && '' !== savedVal
&& Array.isArray( savedVal ) ) {
model.set( 'value', savedVal );
} else if ( 'undefined' != typeof selected ) {
model.set( 'value', value );
}
}
},
renderOptions: function() {
var html = '';
_.each( this.options, function( option ) {
/*
* This part has been re-worked to account for values passed in
* via custom user-meta ( a la User Mgmt add-on)
*/
if ( _.isArray( this.value ) ) {
// If we have a multiselect list...
// AND it has selected values...
if( 'listmultiselect' === this.type && 0 < this.value.length &&
-1 != _.indexOf( this.value[ 0 ].split( ',' ), option.value ) ) {
var selected = true;
} else if( -1 != _.indexOf( this.value, option.value ) ) {
var selected = true;
}
} else if ( ! _.isArray( this.value ) && option.value == this.value ) {
var selected = true;
} else if ( ( 1 == option.selected && this.clean )
&& 'undefined' === typeof this.value ) {
var selected = true;
} else {
var selected = false;
}
/*
* TODO: This is a bandaid fix for making sure that each option has a "visible" property.
* This should be moved to creation so that when an option is added, it has a visible property by default.
*/
if ( 'undefined' == typeof option.visible ) {
option.visible = true;
}
option.selected = selected;
option.fieldID = this.id;
option.classes = this.classes;
option.currentValue = this.value;
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-field-listselect-option' );
html += template( option );
}, this );
return html;
},
renderOtherAttributes: function() {
var otherAttributes = '';
if( 'listmultiselect' == this.type ){
otherAttributes = otherAttributes + ' multiple';
var multiSize = this.multi_size || 5;
otherAttributes = otherAttributes + ' size="' + multiSize + '"';
}
return otherAttributes;
},
getCalcValue: function( fieldModel ) {
var calc_value = 0;
var options = fieldModel.get( 'options' );
if ( 0 != options.length ) {
/*
* Check to see if this is a multi-select list.
*/
if ( 'listmultiselect' == fieldModel.get( 'type' ) ) {
/*
* We're using a multi-select, so we need to check out any selected options and add them together.
*/
_.each( fieldModel.get( 'value' ), function( val ) {
var tmp_opt = _.find( options, function( opt ) { return opt.value == val } );
calc_value += Number( tmp_opt.calc );
} );
} else {
/*
* We are using a single select, so our selected option is in the 'value' attribute.
*/
var selected = _.find( options, function( opt ) { return fieldModel.get( 'value' ) == opt.value } );
/*
* We don't have a selected value, so use our first option.
*/
if ( 'undefined' == typeof selected ) {
selected = fieldModel.get( 'options' )[0];
}
calc_value = selected.calc;
}
}
return calc_value;
}
});
return controller;
} );
define('controllers/coreSubmitResponse',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'forms' ), 'submit:response', this.actionSubmit );
},
actionSubmit: function( response ) {
var formModel = nfRadio.channel( 'app' ).request( 'get:form', response.data.form_id );
/*
* If we have errors, don't hide or clear.
*/
if ( 0 != _.size( response.errors ) ) {
return false;
}
if ( 1 == response.data.settings.clear_complete ) {
// nfRadio.channel( 'form-' + response.data.form_id ).trigger( 'reset' );
formModel.get( 'fields' ).reset( formModel.get( 'loadedFields' ) );
if ( 1 != response.data.settings.hide_complete ) {
nfRadio.channel( 'captcha' ).trigger( 'reset' );
}
}
if ( 1 == response.data.settings.hide_complete ) {
/**
* TODO: This needs to be re-worked for backbone. It's not dynamic enough.
*/
formModel.trigger( 'hide' );
// jQuery( '.nf-fields' ).hide();
// jQuery( '.nf-form-title' ).hide();
}
}
});
return controller;
} );
define('controllers/fieldProduct',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'product' ), 'init:model', this.register );
nfRadio.channel( 'product' ).reply( 'get:calcValue', this.getCalcValue, this );
},
register: function( model ) {
model.set( 'renderProductQuantity', this.renderProductQuantity );
model.set( 'renderProduct', this.renderProduct );
model.set( 'renderOptions', this.renderOptions );
},
renderProduct: function(){
switch( this.product_type ) {
case 'user':
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-field-textbox' );
return template( this );
break;
case 'hidden':
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-field-hidden' );
return template( this );
break;
case 'dropdown':
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-product-dropdown' );
return template( this );
break;
default:
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-product-single' );
return template( this );
}
},
renderProductQuantity: function(){
if ( 1 == this.product_use_quantity ) {
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-product-quantity' );
return template( this );
}
},
renderOptions: function() {
var that = this;
var html = '';
_.each( this.options, function( option ) {
if ( 1 == option.selected ) {
var selected = true;
} else {
var selected = false;
}
option.selected = selected;
option.fieldID = that.id;
option.classes = that.classes;
option.currentValue = that.value;
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-product-' + that.product_type + '-option' );
html += template( option );
} );
return html;
},
getCalcValue: function( fieldModel ) {
var product_price = fieldModel.get( 'product_price' );
var product_quantity = fieldModel.get( 'value' );
return product_price * product_quantity;
}
});
return controller;
} );
define('controllers/fieldTotal',[], function() {
var controller = Marionette.Object.extend( {
totalModel: {},
productTotals: {},
initialize: function() {
this.listenTo( nfRadio.channel( 'total' ), 'init:model', this.register );
this.listenTo( nfRadio.channel( 'shipping' ), 'init:model', this.registerShipping );
},
register: function( totalModel ){
this.totalModel = totalModel;
var formID = totalModel.get( 'formID' );
this.listenTo( nfRadio.channel( 'form-' + formID ), 'loaded', this.onFormLoaded );
this.listenTo( nfRadio.channel( 'product' ), 'change:modelValue', this.onChangeProduct );
this.listenTo( nfRadio.channel( 'quantity' ), 'change:modelValue', this.onChangeQuantity );
},
registerShipping: function( shippingModel ){
this.shippingCost = shippingModel.get( 'shipping_cost' );
},
onFormLoaded: function( formModel ){
var fieldModels = formModel.get( 'fields' ).models;
var productFields = {};
var quantityFields = {};
for( var model in fieldModels ){
var field = fieldModels[ model ];
var fieldID = field.get( 'id' );
// TODO: Maybe use switch
if( 'product' == field.get( 'type' ) ){
productFields[ fieldID ] = field;
} else if( 'quantity' == field.get( 'type' ) ){
var productID = field.get( 'product_assignment' );
quantityFields[ productID ] = field;
}
}
for( var productID in productFields ){
var product = productFields[ productID ];
var productPrice = Number( product.get( 'product_price' ) );
if( quantityFields[ productID ] ){
productPrice *= quantityFields[ productID ].get( 'value' );
} else if( 1 == product.get( 'product_use_quantity' ) ){
productPrice *= product.get( 'value' );
}
this.productTotals[ productID ] = productPrice;
}
this.updateTotal();
},
onChangeProduct: function( model ){
var productID = model.get( 'id' );
var productPrice = Number( model.get( 'product_price' ) );
var productQuantity = Number( model.get( 'value' ) );
var newTotal = productQuantity * productPrice;
this.productTotals[ productID ] = newTotal;
this.updateTotal();
},
onChangeQuantity: function( model ){
var productID = model.get( 'product_assignment' );
var productField = nfRadio.channel( 'fields' ).request( 'get:field', productID );
var productPrice = Number( productField.get( 'product_price' ) );
var quantity = Number( model.get( 'value' ) );
var newTotal = quantity * productPrice;
this.productTotals[ productID ] = newTotal;
this.updateTotal();
},
updateTotal: function(){
var newTotal = 0;
for( var product in this.productTotals ){
newTotal += Number( this.productTotals[ product ] );
}
if( newTotal && this.shippingCost ) {
// Only add shipping if there is a cost.
newTotal += Number(this.shippingCost);
}
this.totalModel.set( 'value', newTotal.toFixed( 2 ) );
this.totalModel.trigger( 'reRender' );
}
});
return controller;
});
define('controllers/fieldQuantity',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'quantity' ), 'init:model', this.registerQuantity );
},
registerQuantity: function( model ){
var productID = model.get( 'product_assignment' );
var product = nfRadio.channel( 'fields' ).request( 'get:field', productID );
if( product ) {
product.set('product_use_quantity', 0);
}
},
});
return controller;
});
/**
* Model that represents a calculation.
*
* On init, we trigger a radio message so that controllers can do things when a calc model inits.
*/
define( 'models/calcModel',[], function() {
var model = Backbone.Model.extend( {
initialize: function() {
// Set our form id
this.set( 'formID', this.collection.options.formModel.get( 'id' ) );
// Set our initial fields object to empty. This will hold our key/value pairs.
this.set( 'fields', {} );
// Trigger a radio message to let controllers know we've inited this model.
nfRadio.channel( 'calc' ).trigger( 'init:model', this );
// When we change the value of this calculation, send out a radio message
this.on( 'change:value', this.changeValue, this );
},
/**
* Trigger a radio message when a field present in our calculation changes
*
* The listener that triggers/calls this function is in controllers/calculations
*
* @since 3.0
* @return void
*/
changeField: function( fieldModel ) {
nfRadio.channel( 'calc' ).trigger( 'change:field', this, fieldModel );
},
changeCalc: function( targetCalcModel ) {
nfRadio.channel( 'calc' ).trigger( 'change:calc', this, targetCalcModel );
},
changeValue: function() {
nfRadio.channel( 'calc' ).trigger( 'change:value', this );
}
} );
return model;
} );
define( 'models/calcCollection',['models/calcModel'], function( CalcModel ) {
var collection = Backbone.Collection.extend( {
model: CalcModel,
comparator: 'order',
initialize: function( models, options ) {
this.options = options;
_.each( models, function( model ) {
if( 'undefined' == typeof model.dec ) return;
if ( '' === model.dec.toString().trim() ) model.dec = 2;
model.dec = parseInt( model.dec );
} );
/*
* Respond to requests for our calc model
*/
nfRadio.channel( 'form-' + options.formModel.get( 'id' ) ).reply( 'get:calc', this.getCalc, this );
},
getCalc: function( key ) {
return this.findWhere( { name: key } );
}
} );
return collection;
} );
/**
* Controller responsible for keeping up with calculations.
*/
define('controllers/calculations',['models/calcCollection'], function( CalcCollection ) {
var controller = Marionette.Object.extend( {
initialize: function() {
this.calcs = {};
this.displayFields = {};
// When our form initialises, check to see if there are any calculations that need to be tracked.
this.listenTo( nfRadio.channel( 'form' ), 'loaded', this.registerCalcs );
// When our collection gets reset, reset calculation tracking as well.
this.listenTo( nfRadio.channel( 'fields' ), 'reset:collection', this.resetCalcs );
// When a calc model is initialised, run a setup function.
// this.listenTo( nfRadio.channel( 'calc' ), 'init:model', this.setupCalc );
// When a field referenced by a calc model changes, update our calc.
this.listenTo( nfRadio.channel( 'calc' ), 'change:field', this.changeField );
// When a calculation referenced by a calc model changes, update our calc.
this.listenTo( nfRadio.channel( 'calc' ), 'change:calc', this.changeCalc );
/*
* Listen to our field model init for fields that want to display calc values.
* If that field has a calc merge tag, replace it with the default calc value.
*/
var that = this;
_.each( nfFrontEnd.use_merge_tags.calculations, function( fieldType ) {
that.listenTo( nfRadio.channel( 'fields-' + fieldType ), 'init:model', that.initDisplayField );
} );
// When we change our calc value, update any display fields.
this.listenTo( nfRadio.channel( 'calc' ), 'change:value', this.updateDisplayFields );
// Set an init variable so that we only call reRender on the display field on change, not on init.
this.init = {};
},
/**
* Passthrough function to reset tracking of calculations when the fieldCollection is reset.
*
* @since 3.2
* @param backbone.collection fieldCollection
* @return void
*/
resetCalcs: function( fieldCollection ) {
if( 'undefined' != typeof( fieldCollection.options.formModel ) ) {
this.registerCalcs( fieldCollection.options.formModel );
}
},
/**
* When our form loads, create a collection out of any calculations.
*
* @since 3.0
* @param backbone.model formModel
* @return void
*/
registerCalcs: function( formModel ) {
var calcCollection = new CalcCollection( formModel.get( 'settings' ).calculations, { formModel: formModel } );
this.calcs[ formModel.get( 'id' ) ] = calcCollection;
var that = this;
_.each( calcCollection.models, function( calcModel ) {
/*
* We set a property on our init variable for the calc model we're looping over.
* This property is set to true so that when we make changes to the calc model on the next line
* the field view doesn't try to redraw itself.
* If we don't do this, the 'reRender' attribute of the model will be set before the view is initialized,
* which means that setting 'reRender' to true will never re-render the view.
*/
that.init[ calcModel.get( 'name' ) ] = true;
// Setup our calculation models with initial values and register listeners for calc-related fields.
that.setupCalc( calcModel );
} );
},
/**
* When a calculation model is instantiated from the registerCalcs function:
*
* Use a regex to get an array of the field keys
* Setup an initial key/values array
* Check for any references to other calculations
* Set the initial value of our calculation
*
* @since 3.0
* @param backbone.model calcModel
* @return void
*/
setupCalc: function( calcModel ) {
// Setup our that var so we can access 'this' context in our loop.
var that = this;
// Get our equation
var eq = calcModel.get( 'eq' );
// We want to keep our original eq intact, so we use a different var for string replacment.
var eqValues = eq;
// Store the name for debugging later.
var calcName = calcModel.get( 'name' );
/* TODO:
* It might be possible to refactor these two if statements.
* The difficulty is that each has a different method of retreiving the specific data model.
*/
// Check to see if we have any field merge tags in our equation.
var fields = eq.match( new RegExp( /{field:(.*?)}/g ) );
if ( fields ) {
/*
* fields is now an array of field keys that looks like:
* ['{field:key'], ['{field:key'], etc.
*
* We need to run a function with each of our field keys to setup our field key array and hook up our field change listner.
*/
fields = fields.map( function( field ) {
// field will be {field:key}
var key = field.replace( ':calc}', '' ).replace( '}', '' ).replace( '{field:', '' );
// Get our field model
fieldModel = nfRadio.channel( 'form-' + calcModel.get( 'formID' ) ).request( 'get:fieldByKey', key );
if( 'undefined' == typeof fieldModel ) return;
fieldModel.set( 'clean', false );
// Register a listener in our field model for value changes.
fieldModel.on( 'change:value', calcModel.changeField, calcModel );
// Get our calc value from our field model.
var calcValue = that.getCalcValue( fieldModel );
// Add this field to our internal key/value object.
that.updateCalcFields( calcModel, key, calcValue );
// Update the string tracking our merged eq with the calc value.
eqValues = that.replaceKey( 'field', key, calcValue, eqValues );
} );
}
// Check to see if we have any calc merge tags in our equation.
var calcs = eq.match( new RegExp( /{calc:(.*?)}/g ) );
if ( calcs ) {
/*
* calcs is now an array of calc keys that looks like:
* ['{calc:key'], ['{calc:key'], etc.
*
* We need to run a function with each of our calc keys to setup our calc key array and hook up our calc change listner.
*/
calcs = calcs.map( function( calc ) {
// calc will be {calc:name}
var name = calc.replace( '}', '' ).replace( '{calc:', '' );
// Get our calc model
var targetCalcModel = calcModel.collection.findWhere( { name: name } );
if( 'undefined' == typeof targetCalcModel ) return;
// Listen for changes on our calcluation, since we need to update our calc when it changes.
targetCalcModel.on( 'change:value', calcModel.changeCalc, calcModel );
// // Get our calc value from our calc model.
var calcValue = targetCalcModel.get( 'value' );
// Update the string tracking our merged eq with the calc value.
eqValues = that.replaceKey( 'calc', name, calcValue, eqValues );
} );
}
// Scrub unmerged tags (ie deleted/nox-existent fields/calcs, etc).
eqValues = eqValues.replace( /{([a-zA-Z0-9]|:|_|-)*}/g, 0 );
// Scrub line breaks.
eqValues = eqValues.replace( /\r?\n|\r/g, '' );
// Evaluate the equation and update the value of this model.
try {
this.debug('Calculation Decoder ' + eqValues + ' -> ' + this.localeDecodeEquation(eqValues) + ' (Setup)');
calcModel.set( 'value', Number( mexp.eval( this.localeDecodeEquation(eqValues) ) ).toFixed( calcModel.get( 'dec' ) ) );
} catch( e ) {
//console.log( calcName );
console.log( e );
}
// If for whatever reason, we got NaN, reset that to 0.
if( calcModel.get( 'value' ) === 'NaN' ) calcModel.set( 'value', '0' );
// Debugging console statement.
// console.log( eqValues + ' = ' + calcModel.get( 'value' ) );
},
/**
* Update an item in our key/value pair that represents our fields and calc values.
*
* @since 3.0
* @param backbone.model calcModel
* @param string key
* @param string calcValue
* @return void
*/
updateCalcFields: function( calcModel, key, calcValue ) {
var fields = calcModel.get( 'fields' );
fields[ key ] = calcValue;
calcModel.set( 'fields', fields );
},
/**
* Get a calc value from a field model.
*
* Sends a request to see if there's a special calc value
* Uses the value of the field if there is not.
*
* @since 3.0
* @param backbone.model fieldModel
* @return value
*/
getCalcValue: function( fieldModel ) {
/*
* Send out a request on the field type and parent type channel asking if they need to modify the calc value.
* This is helpful for fields like lists that can have a different calc_value than selected value.
*/
var value = nfRadio.channel( fieldModel.get( 'type' ) ).request( 'get:calcValue', fieldModel );
var localeConverter = new nfLocaleConverter(nfi18n.siteLocale, nfi18n.thousands_sep, nfi18n.decimal_point);
var calcValue = value || fieldModel.get( 'value' );
var machineNumber = localeConverter.numberDecoder(calcValue);
var formattedNumber = localeConverter.numberEncoder(calcValue);
if ( 'undefined' !== typeof machineNumber && jQuery.isNumeric( machineNumber ) ) {
value = formattedNumber;
} else {
value = 0;
}
// }
if ( ! fieldModel.get( 'visible' ) ) {
value = 0;
}
return value;
},
/**
* Replace instances of key with calcValue. This is used to replace one key at a time.
*
* If no eq is passed, use calcModel eq.
*
* Returns a string with instances of key replaced with calcValue.
*
* @since version
* @param string key
* @param string calcValue
* @param string eq
* @return string eq
*/
replaceKey: function( type, key, calcValue, eq ) {
eq = eq || calcModel.get( 'eq' );
tag = '{' + type + ':' + key + '}';
var reTag = new RegExp( tag, 'g' );
calcTag = '{' + type + ':' + key + ':calc}';
var reCalcTag = new RegExp( calcTag, 'g' );
eq = eq.replace( reTag, calcValue );
eq = eq.replace( reCalcTag, calcValue );
return eq;
},
/**
* Takes a calcModel and returns a string eq with all keys replaced by their appropriate calcValues.
*
* @since 3.0
* @param backbone.model calcModel
* @return string eq
*/
replaceAllKeys: function( calcModel ) {
var eq = calcModel.get( 'eq' );
var that = this;
_.each( calcModel.get( 'fields' ), function( value, key ) {
eq = that.replaceKey( 'field', key, value, eq );
} );
// If we have any calc merge tags, replace those as well.
var calcs = eq.match( new RegExp( /{calc:(.*?)}/g ) );
if ( calcs ) {
_.each( calcs, function( calc ) {
// calc will be {calc:key}
var name = calc.replace( '}', '' ).replace( '{calc:', '' );
var targetCalcModel = calcModel.collection.findWhere( { name: name } );
if( 'undefined' == typeof targetCalcModel ) return;
var re = new RegExp( calc, 'g' );
eq = eq.replace( re, targetCalcModel.get( 'value' ) );
} );
}
return eq;
},
/**
* Function that's called when a field within the calculation changes.
*
* @since 3.0
* @param backbone.model calcModel
* @param backbone.model fieldModel
* @return void
*/
changeField: function( calcModel, fieldModel ) {
var key = fieldModel.get( 'key' );
var value = this.getCalcValue( fieldModel );
this.updateCalcFields( calcModel, key, value );
var eqValues = this.replaceAllKeys( calcModel );
// Scrub unmerged tags (ie deleted/nox-existent fields/calcs, etc).
eqValues = eqValues.replace( /{([a-zA-Z0-9]|:|_|-)*}/g, '0' );
eqValues = eqValues.replace( /\r?\n|\r/g, '' );
try {
this.debug('Calculation Decoder ' + eqValues + ' -> ' + this.localeDecodeEquation(eqValues) + ' (Change Field)');
calcModel.set( 'value', Number( mexp.eval( this.localeDecodeEquation(eqValues) ) ).toFixed( calcModel.get( 'dec' ) ) );
} catch( e ) {
if(this.debug())console.log( e );
}
if( calcModel.get( 'value' ) === 'NaN' ) calcModel.set( 'value', '0' );
// Debugging console statement.
// console.log( eqValues + ' = ' + calcModel.get( 'value' ) );
},
initDisplayField: function( fieldModel ) {
if( ! fieldModel.get( 'default' ) || 'string' != typeof fieldModel.get( 'default' ) ) return;
var calcs = fieldModel.get( 'default' ).match( new RegExp( /{calc:(.*?)}/g ) );
if ( calcs ) {
_.each( calcs, function( calcName ) {
calcName = calcName.replace( '{calc:', '' ).replace( '}', '' ).replace( ':2', '' );
this.displayFields[ calcName ] = this.displayFields[ calcName ] || [];
this.displayFields[ calcName ].push( fieldModel );
}, this );
}
},
updateDisplayFields: function( calcModel ) {
var that = this;
if ( 'undefined' != typeof this.displayFields[ calcModel.get( 'name' ) ] ) {
_.each( this.displayFields[ calcModel.get( 'name' ) ], function( fieldModel ) {
var value = '';
/**
* if we have a html field, we want to use the actual
* value and re-evaluate
**/
if( "html" === fieldModel.get( 'type' ) ) {
value = fieldModel.get( 'value' );
} else {
// if not a html field, use default to re-evaluate
value = fieldModel.get( 'default' );
}
/*
This is a fix for the issue of the merge tags being
display'd
*/
// Find spans with calc data-key values
var spans = value.match( new RegExp( /<span data-key="calc:(.*?)<\/span>/g ));
_.each( spans, function( spanVar ) {
// transform the span back into a merge tag
var tmpCalcTag = "{" + spanVar.replace("<span" +
" data-key=\"", "" ).replace( /">(.*?)<\/span>/, "" ) + "}";
value = value.replace( spanVar, tmpCalcTag );
} );
var calcs = value.match( new RegExp( /{calc:(.*?)}/g ) );
_.each( calcs, function( calc ) {
// var rounding = false;
// calc will be {calc:key} or {calc:key:2}
var name = calc.replace( '}', '' ).replace( '{calc:', '' ).replace( ':2', '' );
/*
* TODO: Bandaid for rounding calculations to two decimal places when displaying the merge tag.
* Checks to see if we have a :2. If we do, remove it and set our rounding variable to true.
*/
// if ( -1 != name.indexOf( ':2' ) ) {
// rounding = true;
// name = name.replace( ':2', '' );
// }
var calcModel = that.calcs[ fieldModel.get( 'formID' ) ].findWhere( { name: name } );
var re = new RegExp( calc, 'g' );
var calcValue = calcModel.get( 'value' ) ;
// if ( rounding ) {
// calcValue = calcValue.toFixed( 2 );
// rounding = false;
// }
if( 'undefined' != typeof( calcValue ) ) {
calcValue = that.applyLocaleFormatting( calcValue, calcModel );
}
/*
* We replace the merge tag with the value
* surrounded by a span so that we can still find it
* and not affect itself or other field merge tags
*
* Unless this isn't a html field, then we just set
* value to calcValue
*/
if( "html" === fieldModel.get( 'type' ) ) {
value = value.replace(re, "<span data-key=\"calc:" + name + "\">"
+ calcValue + "</span>");
} else {
value = calcValue;
}
} );
fieldModel.set( 'value', value );
if ( ! that.init[ calcModel.get( 'name' ) ] ) {
// fieldModel.set( 'reRender', true );
fieldModel.trigger( 'reRender' );
}
that.init[ calcModel.get( 'name' ) ] = false;
} );
}
},
getCalc: function( name, formID ) {
return this.calcs[ formID ].findWhere( { name: name } );
},
changeCalc: function( calcModel, targetCalcModel ) {
var eqValues = this.replaceAllKeys( calcModel );
eqValues = eqValues.replace( '[', '' ).replace( ']', '' );
eqValues = eqValues.replace( /\r?\n|\r/g, '' );
try {
this.debug('Calculation Decoder ' + eqValues + ' -> ' + this.localeDecodeEquation(eqValues) + ' (Change Calc)');
calcModel.set( 'value', Number( mexp.eval( this.localeDecodeEquation( eqValues ) ) ).toFixed( calcModel.get( 'dec' ) ) );
} catch( e ) {
console.log( e );
}
if( calcModel.get( 'value' ) === 'NaN' ) calcModel.set( 'value', '0' );
},
/**
* Function to apply Locale Formatting to Calculations
* @since Version 3.1
* @param Str number
*
* @return Str
*/
applyLocaleFormatting: function( number, calcModel ) {
var localeConverter = new nfLocaleConverter(nfi18n.siteLocale, nfi18n.thousands_sep, nfi18n.decimal_point);
var formattedNumber = localeConverter.numberEncoder(number, calcModel.get('dec'));
// // Split our string on the decimal to preserve context.
// var splitNumber = number.split('.');
// // If we have more than one element (if we had a decimal point)...
// if ( splitNumber.length > 1 ) {
// // Update the thousands and remerge the array.
// splitNumber[ 0 ] = splitNumber[ 0 ].replace( /\B(?=(\d{3})+(?!\d))/g, nfi18n.thousands_sep );
// var formattedNumber = splitNumber.join( nfi18n.decimal_point );
// }
// // Otherwise (we had no decimal point)...
// else {
// // Update the thousands.
// var formattedNumber = number.replace( /\B(?=(\d{3})+(?!\d))/g, nfi18n.thousands_sep );
// }
return formattedNumber;
},
localeDecodeEquation: function( eq ) {
var result = '';
var expression = '';
var pattern = /[0-9.,]/;
var localeConverter = new nfLocaleConverter(nfi18n.siteLocale, nfi18n.thousands_sep, nfi18n.decimal_point);
// This pattern accounts for all whitespace characters (including thin space).
eq = eq.replace( /\s/g, '' );
eq = eq.replace( /&nbsp;/g, '' );
var characters = eq.split('');
// foreach ( characters as character ) {
characters.forEach( function( character ) {
// If the character is numeric or '.' or ','
if (pattern.test(character)) {
expression = expression + character;
} else {
// If we reach an operator char, append the expression to the result
if ( 0 < expression.length ) {
result = result + localeConverter.numberDecoder( expression );
expression = '';
}
result = result + character;
}
});
// The following catches the case of the last character being a digit.
if ( 0 < expression.length ) {
result = result + localeConverter.numberDecoder( expression );
}
return result;
},
debug: function(message) {
if ( window.nfCalculationsDebug || false ) console.log(message);
}
});
return controller;
} );
define('controllers/dateBackwardsCompat',[], function() {
var controller = Marionette.Object.extend({
initialize: function () {
this.listenTo( Backbone.Radio.channel( 'pikaday-bc' ), 'init', this.dateBackwardsCompat );
},
dateBackwardsCompat: function( dateObject, fieldModel ) {
/**
* Start backwards compatibility for old pikaday customisation
*/
// Legacy properties
dateObject.pikaday = {};
dateObject.pikaday._o = {};
//Old hook for Pikaday Custom code
nfRadio.channel( 'pikaday' ).trigger( 'init', dateObject, fieldModel );
// If we've set a disableDayFn property in custom code, hook it up to Flatpickr
if ( typeof dateObject.pikaday._o.disableDayFn !== 'undefined') {
dateObject.set( 'disable', [ dateObject.pikaday._o.disableDayFn ] );
}
//Compatibility for i18n pikaday function
if ( typeof dateObject.pikaday._o.i18n !== 'undefined' || typeof dateObject.pikaday._o.firstDay !== 'undefined') {
let locale = dateObject.config.locale;
if ( typeof dateObject.pikaday._o.firstDay !== 'undefined') {
locale.firstDayOfWeek = dateObject.pikaday._o.firstDay;
}
if ( typeof dateObject.pikaday._o.i18n !== 'undefined') {
if ( typeof dateObject.pikaday._o.i18n.weekdays !== 'undefined') {
locale.weekdays.longhand = dateObject.pikaday._o.i18n.weekdays;
}
if ( typeof dateObject.pikaday._o.i18n.weekdaysShort !== 'undefined') {
locale.weekdays.shorthand = dateObject.pikaday._o.i18n.weekdaysShort;
}
if ( typeof dateObject.pikaday._o.i18n.months !== 'undefined') {
jQuery( '.flatpickr-monthDropdown-months > option' ).each( function() {
this.text = dateObject.pikaday._o.i18n.months[ this.value ];
} );
}
}
dateObject.set( 'locale', locale );
}
if ( Object.keys(dateObject.pikaday._o).length > 0 ) {
console.log("%cDeprecated Ninja Forms Pikaday custom code detected.", "color: Red; font-size: large");
console.log("You are using deprecated Ninja Forms Pikaday custom code. Support for this custom code will be removed in a future version of Ninja Forms. Please contact Ninja Forms support for more details.");
}
}
});
return controller;
});
define('controllers/fieldDate',[], function() {
var controller = Marionette.Object.extend({
initialize: function () {
this.listenTo( nfRadio.channel( 'date' ), 'init:model', this.registerFunctions );
this.listenTo( nfRadio.channel( 'date' ), 'render:view', this.initDatepicker );
},
registerFunctions: function( model ) {
model.set( 'renderHourOptions', this.renderHourOptions );
model.set( 'renderMinuteOptions', this.renderMinuteOptions );
model.set( 'maybeRenderAMPM', this.maybeRenderAMPM );
model.set( 'customClasses', this.customClasses );
// Overwrite the default getValue() method.
model.getValue = this.getValue;
},
renderHourOptions: function() {
return this.hours_options;
},
renderMinuteOptions: function() {
return this.minutes_options;
},
maybeRenderAMPM: function() {
if ( 'undefined' == typeof this.hours_24 || 1 == this.hours_24 ) {
return;
}
return '<div style="float:left;"><select class="ampm extra"><option value="am">AM</option><option value="pm">PM</option></select></div>';
},
initDatepicker: function ( view ) {
view.model.set( 'el', view.el );
var el = jQuery( view.el ).find( '.nf-element' )[0];
view.listenTo( nfRadio.channel( 'form-' + view.model.get( 'formID' ) ), 'before:submit', this.beforeSubmit, view );
// If we are using a time_only date_mode, then hide the date input.
if ( 'undefined' != typeof view.model.get( 'date_mode' ) && 'time_only' == view.model.get( 'date_mode' ) ) {
jQuery( el ).hide();
return false;
}
var dateFormat = view.model.get( 'date_format' );
// For "default" date format, convert PHP format to JS compatible format.
if( '' == dateFormat || 'default' == dateFormat ){
dateFormat = this.convertDateFormat( nfi18n.dateFormat );
}
var dateSettings = {
classes: jQuery( el ).attr( "class" ),
placeholder: view.model.get( 'placeholder' ),
parseDate: function (datestr, format) {
return moment(datestr, format, true).toDate();
},
formatDate: function (date, format, locale) {
return moment(date).format(format);
},
dateFormat: dateFormat,
altFormat: dateFormat,
altInput: true,
ariaDateFormat: dateFormat,
mode: "single",
allowInput: true,
disableMobile: "true",
locale: {
months: {
shorthand: nfi18n.monthsShort,
longhand: nfi18n.months
},
weekdays: {
shorthand: nfi18n.weekdaysShort,
longhand: nfi18n.weekdays
},
firstDayOfWeek: nfi18n.startOfWeek,
}
};
// Filter our datepicker settings object.
let filteredDatePickerSettings = nfRadio.channel( 'flatpickr' ).request( 'filter:settings', dateSettings, view );
if ( 'undefined' != typeof filteredDatePickerSettings ) {
dateSettings = filteredDatePickerSettings;
}
var dateObject = flatpickr( el, dateSettings );
if ( 1 == view.model.get( 'date_default' ) ) {
dateObject.setDate( moment().format(dateFormat) );
view.model.set( 'value', moment().format(dateFormat) );
}
//Trigger Pikaday backwards compatibility
nfRadio.channel( 'pikaday-bc' ).trigger( 'init', dateObject, view.model, view );
nfRadio.channel( 'flatpickr' ).trigger( 'init', dateObject, view.model, view );
},
beforeSubmit: function( formModel ) {
if ( 'date_only' == this.model.get( 'date_mode' ) ) {
return false;
}
let hour = jQuery( this.el ).find( '.hour' ).val();
let minute = jQuery( this.el ).find( '.minute' ).val();
let ampm = jQuery( this.el ).find( '.ampm' ).val();
let current_value = this.model.get( 'value' );
let date = false;
if ( _.isObject( current_value ) ) {
date = current_value.date;
} else {
date = current_value;
}
let date_value = {
date: date,
hour: hour,
minute: minute,
ampm: ampm,
};
this.model.set( 'value', date_value );
},
getYearRange: function( fieldModel ) {
var yearRange = 10;
var yearRangeStart = fieldModel.get( 'year_range_start' );
var yearRangeEnd = fieldModel.get( 'year_range_end' );
if( yearRangeStart && yearRangeEnd ){
return [ yearRangeStart, yearRangeEnd ];
} else if( yearRangeStart ) {
yearRangeEnd = yearRangeStart + yearRange;
return [ yearRangeStart, yearRangeEnd ];
} else if( yearRangeEnd ) {
yearRangeStart = yearRangeEnd - yearRange;
return [ yearRangeStart, yearRangeEnd ];
}
return yearRange;
},
getMinDate: function( fieldModel ) {
var minDate = null;
var yearRangeStart = fieldModel.get( 'year_range_start' );
if( yearRangeStart ) {
return new Date( yearRangeStart, 0, 1 );
}
return minDate;
},
getMaxDate: function( fieldModel ) {
var maxDate = null;
var yearRangeEnd = fieldModel.get( 'year_range_end' );
if( yearRangeEnd ) {
return new Date( yearRangeEnd, 11, 31 );
}
return maxDate;
},
convertDateFormat: function( dateFormat ) {
// http://php.net/manual/en/function.date.php
// https://github.com/dbushell/Pikaday/blob/master/README.md#formatting **** Switched to flatpickr ***
// Note: Be careful not to add overriding replacements. Order is important here.
/** Day */
dateFormat = dateFormat.replace( 'D', 'ddd' ); // @todo Ordering issue?
dateFormat = dateFormat.replace( 'd', 'DD' );
dateFormat = dateFormat.replace( 'l', 'dddd' );
dateFormat = dateFormat.replace( 'j', 'D' );
dateFormat = dateFormat.replace( 'N', '' ); // Not Supported
dateFormat = dateFormat.replace( 'S', '' ); // Not Supported
dateFormat = dateFormat.replace( 'w', 'd' );
dateFormat = dateFormat.replace( 'z', '' ); // Not Supported
/** Week */
dateFormat = dateFormat.replace( 'W', 'W' );
/** Month */
dateFormat = dateFormat.replace( 'M', 'MMM' ); // "M" before "F" or "m" to avoid overriding.
dateFormat = dateFormat.replace( 'F', 'MMMM' );
dateFormat = dateFormat.replace( 'm', 'MM' );
dateFormat = dateFormat.replace( 'n', 'M' );
dateFormat = dateFormat.replace( 't', '' ); // Not Supported
// Year
dateFormat = dateFormat.replace( 'L', '' ); // Not Supported
dateFormat = dateFormat.replace( 'o', 'YYYY' );
dateFormat = dateFormat.replace( 'Y', 'YYYY' );
dateFormat = dateFormat.replace( 'y', 'YY' );
// Time - Not supported
dateFormat = dateFormat.replace( 'a', '' );
dateFormat = dateFormat.replace( 'A', '' );
dateFormat = dateFormat.replace( 'B', '' );
dateFormat = dateFormat.replace( 'g', '' );
dateFormat = dateFormat.replace( 'G', '' );
dateFormat = dateFormat.replace( 'h', '' );
dateFormat = dateFormat.replace( 'H', '' );
dateFormat = dateFormat.replace( 'i', '' );
dateFormat = dateFormat.replace( 's', '' );
dateFormat = dateFormat.replace( 'u', '' );
dateFormat = dateFormat.replace( 'v', '' );
// Timezone - Not supported
dateFormat = dateFormat.replace( 'e', '' );
dateFormat = dateFormat.replace( 'I', '' );
dateFormat = dateFormat.replace( 'O', '' );
dateFormat = dateFormat.replace( 'P', '' );
dateFormat = dateFormat.replace( 'T', '' );
dateFormat = dateFormat.replace( 'Z', '' );
// Full Date/Time - Not Supported
dateFormat = dateFormat.replace( 'c', '' );
dateFormat = dateFormat.replace( 'r', '' );
dateFormat = dateFormat.replace( 'u', '' );
return dateFormat;
},
customClasses: function( classes ) {
if ( 'date_and_time' == this.date_mode ) {
classes += ' date-and-time';
}
return classes;
},
// This function is called whenever we want to know the value of the date field.
// Since it could be a date/time field, we can't return just the value.
getValue: function() {
if ( 'date_only' == this.get( 'date_mode' ) ) {
return this.get( 'value' );
}
let el = this.get( 'el' );
let hour = jQuery( el ).find( '.hour' ).val();
let minute = jQuery( el ).find( '.minute' ).val();
let ampm = jQuery( el ).find( '.ampm' ).val();
let current_value = this.get( 'value' );
let date = false;
if ( _.isObject( current_value ) ) {
date = current_value.date;
} else {
date = current_value;
}
let value = '';
if ( 'undefined' != typeof date ) {
value += date;
}
if ( 'undefined' != typeof hour && 'undefined' != typeof minute ) {
value += ' ' + hour + ':' + minute;
}
if ( 'undefined' != typeof ampm ) {
value += ' ' + ampm;
}
return value;
// let date_value = {
// date: date,
// hour: hour,
// minute: minute,
// ampm: ampm,
// };
// this.model.set( 'value', date_value );
}
});
return controller;
});
define('controllers/fieldRecaptcha',[], function() {
var controller = Marionette.Object.extend({
initialize: function () {
this.listenTo( nfRadio.channel( 'recaptcha' ), 'init:model', this.initRecaptcha );
this.listenTo( nfRadio.channel( 'forms' ), 'submit:response', this.resetRecaptcha );
},
initRecaptcha: function ( model ) {
nfRadio.channel( 'recaptcha' ).reply( 'update:response', this.updateResponse, this, model.id );
},
updateResponse: function( response, fieldID ) {
var model = nfRadio.channel( 'fields' ).request( 'get:field', fieldID );
model.set( 'value', response );
nfRadio.channel( 'fields' ).request( 'remove:error', model.get( 'id' ), 'required-error' );
},
resetRecaptcha: function() {
var recaptchaID = 0;
jQuery( '.g-recaptcha' ).each( function() {
try {
grecaptcha.reset( recaptchaID );
} catch( e ){
console.log( 'Notice: Error trying to reset grecaptcha.' );
}
recaptchaID++;
} );
}
});
return controller;
} );
define('controllers/fieldRecaptchaV3',[], function() {
var controller = Marionette.Object.extend({
initialize: function () {
this.listenTo( nfRadio.channel( 'recaptcha_v3' ), 'init:model', this.initRecaptcha );
},
initRecaptcha: function ( model ) {
let formID = model.get( 'formID' );
nfRadio.channel( 'form-' + formID ).trigger( 'disable:submit', model );
grecaptcha.ready( function() {
grecaptcha.execute( model.get( 'site_key' ), {
action: 'register'
} ).then( function( token ) {
model.set( 'value', token );
nfRadio.channel( 'form-' + formID ).trigger( 'enable:submit', model );
} );
} );
},
});
return controller;
} );
define('controllers/fieldHTML',[], function() {
var controller = Marionette.Object.extend({
htmlFields: [],
trackedMergeTags: [],
initialize: function () {
this.listenTo( Backbone.Radio.channel( 'fields-html' ), 'init:model', this.setupFieldMergeTagTracking );
},
setupFieldMergeTagTracking: function( fieldModel ) {
this.htmlFields.push( fieldModel );
var formID = fieldModel.get( 'formID' );
this.listenTo( nfRadio.channel( 'form-' + formID ), 'init:model', function( formModel ){
var mergeTags = fieldModel.get( 'default' ).match( new RegExp( /{field:(.*?)}/g ) );
if ( ! mergeTags ) return;
_.each( mergeTags, function( mergeTag ) {
var fieldKey = mergeTag.replace( '{field:', '' ).replace( '}', '' );
var fieldModel = formModel.get( 'fields' ).findWhere({ key: fieldKey });
if( 'undefined' == typeof fieldModel ) return;
this.trackedMergeTags.push( fieldModel );
this.listenTo( nfRadio.channel( 'field-' + fieldModel.get( 'id' ) ), 'change:modelValue', this.updateFieldMergeTags );
}, this );
// Let's get this party started!
this.updateFieldMergeTags();
}, this );
},
updateFieldMergeTags: function( fieldModel ) {
_.each( this.htmlFields, function( htmlFieldModel ){
var value = htmlFieldModel.get( 'value' );
_.each( this.trackedMergeTags, function( fieldModel ){
/* Search the value for any spans with mergetag data-key
* values
*/
var spans = value.match( new RegExp( /<span data-key="field:(.*?)<\/span>/g ) );
_.each( spans, function( spanVar ) {
/* See if the span string contains the current
* fieldModel's key. If so replace the span with a
* merge tag for evaluation.
*/
if( -1 < spanVar.indexOf( "data-key=\"field:" + fieldModel.get( 'key' ) ) ) {
value = value.replace( spanVar, "{field:" + fieldModel.get( 'key' ) + "}" );
}
} );
var mergeTag = '{field:' + fieldModel.get( 'key' ) + '}';
/* We replace the merge tag with the value
* surrounded by a span so that we can still find it
* and not affect itself or other field merge tags
*/
value = value.replace( mergeTag, "<span data-key=\"field:"
+ fieldModel.get( 'key' ) + "\">"
+ fieldModel.getValue() + "</span>" );
}, this ) ;
htmlFieldModel.set( 'value', value );
htmlFieldModel.trigger( 'reRender' );
}, this );
}
});
return controller;
});
/**
* When a form is loaded, enable any help text that appears on the page.
*/
define('controllers/helpText',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'form' ), 'render:view', this.initHelpText );
nfRadio.channel( 'form' ).reply( 'init:help', this.initHelpText );
},
initHelpText: function( view ) {
jQuery( view.el ).find( '.nf-help' ).each( function() {
var jBox = jQuery( this ).jBox( 'Tooltip', {
theme: 'TooltipBorder',
content: jQuery( this ).data( 'text' )
});
} );
}
});
return controller;
} );
define('controllers/fieldTextbox',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
nfRadio.channel( 'textbox' ).reply( 'get:calcValue', this.getCalcValue, this );
},
getCalcValue: function( fieldModel ) {
if('currency' == fieldModel.get('mask')){
var form = nfRadio.channel( 'app' ).request( 'get:form', fieldModel.get( 'formID' ) );
var currencySymbol = ('undefined' !== typeof form) ? form.get( 'currencySymbol' ) : '';
var currencySymbolDecoded = jQuery('<textarea />').html(currencySymbol).text();
return fieldModel.get( 'value' ).replace(currencySymbolDecoded, '');
}
return fieldModel.get( 'value' );
},
});
return controller;
} );
/**
* When a form is loaded, enable any rtes in textareas.
*/
define('controllers/fieldTextareaRTE',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'textarea' ), 'render:view', this.initTextareaRTEs );
this.listenTo( nfRadio.channel( 'textarea' ), 'click:extra', this.clickExtra );
// Instantiates the variable that holds the media library frame.
this.meta_image_frame;
this.currentContext = {};
if( 'undefined' == typeof jQuery.summernote ) return;
jQuery.summernote.options.icons = {
'align': 'dashicons dashicons-editor-alignleft',
'alignCenter': 'dashicons dashicons-editor-aligncenter',
'alignJustify': 'dashicons dashicons-editor-justify',
'alignLeft': 'dashicons dashicons-editor-alignleft',
'alignRight': 'dashicons dashicons-editor-alignright',
'indent': 'dashicons dashicons-editor-indent',
'outdent': 'dashicons dashicons-editor-outdent',
// 'arrowsAlt': 'dashicons fa-arrows-alt',
'bold': 'dashicons dashicons-editor-bold',
'caret': 'dashicons dashicons-arrow-down',
// 'circle': 'dashicons fa-circle',
'close': 'dashicons dashicons-dismiss',
'code': 'dashicons dashicons-editor-code',
'eraser': 'dashicons dashicons-editor-removeformatting',
// 'font': 'dashicons fa-font',
// 'frame': 'dashicons fa-frame',
'italic': 'dashicons dashicons-editor-italic',
'link': 'dashicons dashicons-admin-links',
'unlink': 'dashicons dashicons-editor-unlink',
'magic': 'dashicons dashicons-editor-paragraph',
// 'menuCheck': 'dashicons fa-check',
'minus': 'dashicons dashicons-minus',
'orderedlist': 'dashicons dashicons-editor-ol',
// 'pencil': 'dashicons fa-pencil',
// 'picture': 'dashicons fa-picture-o',
// 'question': 'dashicons fa-question',
'redo': 'dashicons dashicons-redo',
'square': 'dashicons fa-square',
// 'strikethrough': 'dashicons fa-strikethrough',
// 'subscript': 'dashicons fa-subscript',
// 'superscript': 'dashicons fa-superscript',
'table': 'dashicons dashicons-editor-table',
// 'textHeight': 'dashicons fa-text-height',
// 'trash': 'dashicons fa-trash',
'underline': 'dashicons dashicons-editor-underline',
'undo': 'dashicons dashicons-undo',
'unorderedlist': 'dashicons dashicons-editor-ul',
// 'video': 'dashicons fa-youtube-play'
};
},
initTextareaRTEs: function( view ) {
if ( 1 != view.model.get( 'textarea_rte' ) ) {
return false;
}
/*
* Custom Button for links
*/
var that = this;
// var linkButton = this.linkButton();
var linkButton = function( context ) {
return that.linkButton( context );
}
var mediaButton = function( context ) {
return that.mediaButton( context );
}
var toolbar = [
[ 'paragraphStyle', ['style'] ],
[ 'fontStyle', [ 'bold', 'italic', 'underline','clear' ] ],
[ 'lists', [ 'ul', 'ol' ] ],
[ 'paragraph', [ 'paragraph' ] ],
[ 'customGroup', [ 'linkButton', 'unlink' ] ],
[ 'table', [ 'table' ] ],
[ 'actions', [ 'undo', 'redo' ] ],
];
if ( 1 == view.model.get( 'textarea_media' ) && 0 != userSettings.uid ) {
toolbar.push( [ 'tools', [ 'mediaButton' ] ] );
}
jQuery( view.el ).find( '.nf-element' ).summernote( {
toolbar: toolbar,
buttons: {
linkButton: linkButton,
mediaButton: mediaButton
},
height: 150, //set editable area's height
codemirror: { // codemirror options
theme: 'monokai',
lineNumbers: true
},
prettifyHtml: true,
callbacks: {
onChange: function( e ) {
view.model.set( 'value', jQuery( this ).summernote( 'code' ) );
}
}
} );
var linkMenu = jQuery( view.el ).find( '.link-button' ).next( '.dropdown-menu' ).find( 'button' );
linkMenu.replaceWith(function () {
return jQuery( '<div/>', {
class: jQuery( linkMenu ).attr( 'class' ),
html: this.innerHTML
} );
} );
},
linkButton: function( context ) {
var that = this;
var ui = jQuery.summernote.ui;
var linkButton = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-rte-link-button' );
var linkDropdown = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-rte-link-dropdown' );
return ui.buttonGroup([
ui.button({
className: 'dropdown-toggle link-button',
contents: linkButton({}),
tooltip: nfi18n.fieldTextareaRTEInsertLink,
click: function( e ) {
that.clickLinkButton( e, context );
},
data: {
toggle: 'dropdown'
}
}),
ui.dropdown([
ui.buttonGroup({
children: [
ui.button({
contents: linkDropdown({}),
tooltip: ''
}),
]
})
])
]).render();
},
mediaButton: function( context ) {
var that = this;
var ui = jQuery.summernote.ui;
var mediaButton = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-rte-media-button' );
return ui.button({
className: 'dropdown-toggle',
contents: mediaButton({}),
tooltip: nfi18n.fieldTextareaRTEInsertMedia,
click: function( e ) {
that.openMediaManager( e, context );
}
}).render();
},
openMediaManager: function( e, context ) {
context.invoke( 'editor.saveRange' );
// If the frame already exists, re-open it.
if ( this.meta_image_frame ) {
this.meta_image_frame.open();
return;
}
// Sets up the media library frame
this.meta_image_frame = wp.media.frames.meta_image_frame = wp.media({
title: nfi18n.fieldTextareaRTESelectAFile,
button: { text: 'insert' }
});
var that = this;
// Runs when an image is selected.
this.meta_image_frame.on('select', function(){
// Grabs the attachment selection and creates a JSON representation of the model.
var media_attachment = that.meta_image_frame.state().get('selection').first().toJSON();
that.insertMedia( media_attachment, context );
});
// Opens the media library frame.
this.meta_image_frame.open();
},
clickLinkButton: function ( e, context ) {
var range = context.invoke( 'editor.createRange' );
context.invoke( 'editor.saveRange' );
var text = range.toString()
this.currentContext = context;
jQuery( e.target ).closest( '.note-customGroup > .note-btn-group' ).on ('hide.bs.dropdown', function ( e ) {
return false;
});
jQuery( e.target ).closest( '.note-customGroup > .note-btn-group' ).on ('shown.bs.dropdown', function ( e ) {
jQuery( e.target ).parent().parent().find( '.link-text' ).val( text );
jQuery( e.target ).parent().parent().find( '.link-url' ).focus();
});
},
clickExtra: function( e ) {
var textEl = jQuery( e.target ).parent().find( '.link-text' );
var urlEl = jQuery( e.target ).parent().find( '.link-url' );
var isNewWindowEl = jQuery( e.target ).parent().find( '.link-new-window' );
this.currentContext.invoke( 'editor.restoreRange' );
if ( jQuery( e.target ).hasClass( 'insert-link' ) ) {
var text = textEl.val();
var url = urlEl.val();
var isNewWindow = ( isNewWindowEl.prop( 'checked' ) ) ? true: false;
if ( 0 != text.length && 0 != url.length ) {
this.currentContext.invoke( 'editor.createLink', { text:text, url: url, isNewWindow: isNewWindow } );
}
}
textEl.val( '' );
urlEl.val( '' );
isNewWindowEl.prop( 'checked', false );
jQuery( e.target ).closest( 'div.note-btn-group.open' ).removeClass( 'open' );
},
insertMedia: function( media, context ) {
context.invoke( 'editor.restoreRange' );
if ( 'image' == media.type ) {
context.invoke( 'editor.insertImage', media.url );
} else {
context.invoke( 'editor.createLink', { text: media.filename, url: media.url } );
}
}
});
return controller;
} );
define('controllers/fieldStarRating',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'starrating' ), 'init:model', this.register );
this.listenTo( nfRadio.channel( 'starrating' ), 'render:view', this.initRating );
},
register: function( model ) {
model.set( 'renderRatings', this.renderRatings );
},
initRating: function( view ){
jQuery( view.el ).find( '.starrating' ).rating();
},
renderRatings: function() {
var html = document.createElement( 'span' );
// changed from 'default' to 'number_of_stars'
for (var i = 0; i <= this.number_of_stars - 1; i++) {
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-field-starrating-star' );
var num = i + 1;
var checked = '';
// Check to see if current 'star' matches the default value
if ( this.value == num ) {
checked = 'checked';
}
var htmlFragment = template( { id: this.id, classes: this.classes, num: num, checked: checked, required: this.required } );
html.appendChild(
document.createRange().createContextualFragment( htmlFragment )
);
}
return html.innerHTML;
}
});
return controller;
});
define('controllers/fieldTerms',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'terms' ), 'init:model', this.register );
},
register: function( model ) {
// nfRadio.channel( 'field-' + this.model.get( 'id' ) ).trigger( 'click:extra', e, this.model );
this.listenTo( nfRadio.channel( 'field-' + model.get( 'id' ) ), 'click:extra', this.clickExtra );
this.listenTo( nfRadio.channel( 'field-' + model.get( 'id' ) ), 'keyup:field', this.keyUpExtra );
},
clickExtra: function( e, model ) {
var el = jQuery( e.currentTarget );
var value = el.parent().find( '.extra-value' ).val();
this.addOption( model, value );
},
keyUpExtra: function( el, model, keyCode ) {
if( 13 != keyCode ) return;
this.addOption( model, el.val() );
},
addOption: function( model, value ) {
if( ! value ) return;
var options = model.get( 'options' );
var new_option = {
label: value,
value: value,
selected: 0,
};
options.push( new_option );
var selected = model.get( 'value' );
selected.push( value );
// model.set( 'reRender', true );
model.trigger( 'reRender' );
}
});
return controller;
} );
/**
* Before we display our form content, ask if anyone wants to give us a different view.
* Before we do anything with the data, pass it through any loading filters.
*
* @package Ninja Forms builder
* @subpackage Main App
* @copyright (c) 2016 WP Ninjas
* @since 3.0
*/
define( 'controllers/formContentFilters',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
/*
* Init our fieldContent view and load filter arrays.
*/
this.viewFilters = [];
this.loadFilters = [];
/*
* Listen for requests to add new formContent filters.
*/
nfRadio.channel( 'formContent' ).reply( 'add:viewFilter', this.addViewFilter, this );
nfRadio.channel( 'formContent' ).reply( 'add:loadFilter', this.addLoadFilter, this );
/*
* Listen for requests to get our formContent filters.
*/
nfRadio.channel( 'formContent' ).reply( 'get:viewFilters', this.getViewFilters, this );
nfRadio.channel( 'formContent' ).reply( 'get:loadFilters', this.getLoadFilters, this );
/*
* -- DEPRECATED RADIO REPLIES --
*
* The 'fieldContents' channel has been deprecated as of 3.0 (it was present in the RC) in favour of 'formContent'.
* Listen for requests to add new fieldContent filters.
*
* TODO: These radio listeners on the 'fieldContents' channels are here for backwards compatibility and should be removed eventually.
*/
nfRadio.channel( 'fieldContents' ).reply( 'add:viewFilter', this.addViewFilter, this );
nfRadio.channel( 'fieldContents' ).reply( 'add:loadFilter', this.addLoadFilter, this );
/*
* Listen for requests to get our fieldContent filters.
* TODO: Remove eventually.
*/
nfRadio.channel( 'fieldContents' ).reply( 'get:viewFilters', this.getViewFilters, this );
nfRadio.channel( 'fieldContents' ).reply( 'get:loadFilters', this.getLoadFilters, this );
/*
* -- END DEPRECATED --
*/
},
addViewFilter: function( callback, priority ) {
this.viewFilters[ priority ] = callback;
},
getViewFilters: function() {
return this.viewFilters;
},
addLoadFilter: function( callback, priority ) {
this.loadFilters[ priority ] = callback;
},
getLoadFilters: function() {
return this.loadFilters;
}
});
return controller;
} );
define( 'views/fieldItem',[], function() {
var view = Marionette.ItemView.extend({
tagName: 'div',
initialize: function() {
this.listenTo( this.model, 'reRender', this.render, this );
this.listenTo( this.model, 'change:addWrapperClass', this.addWrapperClass, this );
this.listenTo( this.model, 'change:removeWrapperClass', this.removeWrapperClass, this );
this.listenTo( this.model, 'change:invalid', this.toggleAriaInvalid, this );
this.template = '#tmpl-nf-field-' + this.model.get( 'wrap_template' );
},
test: function( model ) {
console.log( 'firing from trigger 1' );
},
addWrapperClass: function() {
var cl = this.model.get( 'addWrapperClass' );
if ( '' != cl ) {
jQuery( this.el ).addClass( cl );
this.model.set( 'addWrapperClass', '' );
}
},
removeWrapperClass: function() {
var cl = this.model.get( 'removeWrapperClass' );
if ( '' != cl ) {
jQuery( this.el ).removeClass( cl );
this.model.set( 'removeWrapperClass', '' );
}
},
toggleAriaInvalid: function() {
var invalid = this.model.get( 'invalid' );
jQuery( '[aria-invalid]', this.el ).attr( 'aria-invalid', JSON.stringify( invalid ) );
},
onRender: function() {
this.$el = this.$el.children();
this.$el.unwrap();
this.setElement( this.$el );
/*
* If we have an input mask, init that mask.
* TODO: Move this to a controller so that the logic isn't in the view.
*/
if ( 'undefined' != typeof this.model.get( 'mask' ) && '' != jQuery.trim( this.model.get( 'mask' ) ) ) {
if ( 'custom' == this.model.get( 'mask') ) {
var mask = this.model.get( 'custom_mask' );
} else {
var mask = this.model.get( 'mask' );
}
/* POLYFILL */ Number.isInteger = Number.isInteger || function(value) { return typeof value === "number" && isFinite(value) && Math.floor(value) === value; };
if ( Number.isInteger( mask ) ) {
mask = mask.toString();
}
if ( 'currency' == mask ) {
var form = nfRadio.channel( 'app' ).request( 'get:form', this.model.get( 'formID' ) );
var thousands_sep = form.get( 'thousands_sep' );
/*
* TODO: if we have a &nbsp; , replace it with a string with a space.
*/
if ( '&nbsp;' == thousands_sep ) {
thousands_sep = ' ';
}
var currencySymbol = jQuery( '<div/>' ).html( form.get( 'currencySymbol' ) ).text();
thousands_sep = jQuery( '<div/>' ).html( thousands_sep ).text();
var decimal_point = jQuery( '<div/>' ).html( form.get( 'decimal_point' ) ).text();
/*
* TODO: Currently, these options use the plugin-wide defaults for locale.
* When per-form locales are implemented, these will need to be revisited.
*/
var autoNumericOptions = {
digitGroupSeparator : thousands_sep,
decimalCharacter : decimal_point,
currencySymbol : currencySymbol
};
// Initialization
var autoN_el = jQuery(jQuery( this.el ).find( '.nf-element' )[ 0 ]);
new AutoNumeric( jQuery( this.el ).find( '.nf-element' )[ 0 ], autoNumericOptions );
// update the value for the model so it gets saved to
// the database properly
var context = this;
autoN_el.on( 'change', function( e ) {
context.model.set( 'value', e.target.value );
})
} else {
jQuery( this.el ).find( '.nf-element' ).mask( mask );
}
}
nfRadio.channel( this.model.get( 'type' ) ).trigger( 'render:view', this );
nfRadio.channel( 'fields' ).trigger( 'render:view', this );
},
templateHelpers: function () {
var that = this;
return {
renderElement: function(){
var tmpl = _.find( this.element_templates, function( tmpl ) {
if ( 0 < jQuery( '#tmpl-nf-field-' + tmpl ).length ) {
return true;
}
} );
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-field-' + tmpl );
return template( this );
},
renderLabel: function() {
var template = nfRadio.channel( 'app' ).request( 'get:template', '#tmpl-nf-field-label' );
return template( this );
},
renderLabelClasses: function () {
var classes = '';
if ( 'undefined' != typeof this.customLabelClasses ) {
classes = this.customLabelClasses( classes );
}
return classes;
},
renderPlaceholder: function() {
var placeholder = this.placeholder;
if ( 'undefined' != typeof this.customPlaceholder ) {
placeholder = this.customPlaceholder( placeholder );
}
if( '' != jQuery.trim( placeholder ) ) {
return 'placeholder="' + placeholder + '"';
} else {
return '';
}
},
renderWrapClass: function() {
var wrapClass = 'field-wrap ' + this.type + '-wrap';
// Check if type and parentType are different. If, so
// then add appropriate parentType wrap class
if ( this.type !== this.parentType ) {
wrapClass = wrapClass + ' ' + this.parentType + '-wrap';
}
// If we have an old_classname defined, output wrap class for backward compatibility
if ( 'undefined' != typeof this.old_classname && 0 < jQuery.trim( this.old_classname ).length ) {
wrapClass += ' ' + this.old_classname + '-wrap';
}
if ( 'undefined' != typeof customWrapClass ) {
wrapClass = customWrapClass( wrapClass );
}
return wrapClass;
},
renderClasses: function() {
var classes = this.classes;
if ( this.error ) {
classes += ' nf-error';
} else {
classes = classes.replace( 'nf-error', '' );
}
if ( 'undefined' != typeof this.element_class && 0 < jQuery.trim( this.element_class ).length ) {
classes += ' ' + this.element_class;
}
/*
* If we have a function for adding extra classes, add those.
*/
if ( 'undefined' != typeof this.customClasses ) {
classes = this.customClasses( classes );
}
return classes;
},
maybeDisabled: function() {
if ( 1 == this.disable_input ) {
return 'disabled';
} else {
return '';
}
},
maybeRequired: function() {
if ( 1 == this.required ) {
return 'required';
} else {
return '';
}
},
maybeDisableAutocomplete: function() {
if ( 1 == this.disable_browser_autocomplete ) {
return 'autocomplete="off"';
} else {
return '';
}
},
maybeInputLimit: function() {
if ( 'characters' == this.input_limit_type && '' != jQuery.trim( this.input_limit ) ) {
return 'maxlength="' + this.input_limit + '"';
} else {
return '';
}
},
getHelpText: function() {
// this.help_text = jQuery( this.help_text ).html();
// return ( 'undefined' != typeof this.help_text ) ? this.help_text.replace(/"/g, "&quot;") : '';
return ( 'undefined' != typeof this.help_text ) ? this.help_text : '';
},
maybeRenderHelp: function() {
// use jQuery().text() to make sure help_text has actual
// text and not just HTML tags.
var check_text_par = document.createElement( 'p' );
check_text_par.innerHTML = this.help_text;
var shouldRenderHelpText = false;
// Check for text or image tags
if ( 0 != jQuery.trim( jQuery( check_text_par ).text() ).length
|| 0 < jQuery( check_text_par ).find('img').length ) {
shouldRenderHelpText = true;
}
if ( 'undefined' != typeof this.help_text && shouldRenderHelpText ) {
var icon = document.createElement( 'span' );
icon.classList.add( 'fa', 'fa-info-circle', 'nf-help' );
icon.setAttribute( 'data-text', this.getHelpText() );
return icon.outerHTML;
} else {
return '';
}
},
renderDescText: function() {
if ( 'undefined' == typeof this.desc_text ) {
return '';
}
// Creates an element so we can check to see if the text is empty.
var text = document.createElement( 'p' );
text.innerHTML = this.desc_text;
if( 0 == jQuery.trim( text.innerText ).length ) return '';
var check, checkText;
checkText = document.createTextNode( this.desc_text );
check = document.createElement( 'p' );
check.appendChild( checkText );
if ( 0 != jQuery.trim( jQuery( check ).text() ).length ) {
var descriptionText, fieldDescription;
descriptionText = document.createRange().createContextualFragment( this.desc_text );
fieldDescription = document.createElement( 'div' );
fieldDescription.classList.add( 'nf-field-description' );
fieldDescription.appendChild( descriptionText );
return fieldDescription.outerHTML;
} else {
return '';
}
},
renderNumberDefault: function() {
// If the field is clean...
if ( this.clean ) {
// If we have a default...
if ( this.default ) {
return this.default;
} // If we do not have a placeholder...
else if ( ! this.placeholder ) {
return this.value;
} // Otherwise...
else {
return '';
}
} // Otherwise... (The field is not clean.)
else {
return this.value;
}
},
renderCurrencyFormatting: function( number ) {
/*
* Our number will have a . as a decimal point. We want to replace that with our locale decimal, nfi18n.decimal_point.
*/
var replacedDecimal = number.toString().replace( '.', '||' );
/*
* Add thousands separator. Our original number var won't have thousands separators.
*/
var replacedThousands = replacedDecimal.replace( /\B(?=(\d{3})+(?!\d))/g, nfi18n.thousands_sep );
var formattedNumber = replacedThousands.replace( '||', nfi18n.decimal_point );
var form = nfRadio.channel( 'app' ).request( 'get:form', that.model.get( 'formID' ) );
var currency_symbol = form.get( 'settings' ).currency_symbol;
return currency_symbol + formattedNumber;
},
maybeRenderTime: function() {
if ( 'time_only' == this.date_mode || 'date_and_time' == this.date_mode ) {
return true;
}
return false;
},
};
},
events: {
'change .nf-element': 'fieldChange',
'keyup .nf-element': 'fieldKeyup',
'click .nf-element': 'fieldClick',
'click .extra': 'extraClick',
'change .extra': 'extraChange',
'blur .nf-element': 'fieldBlur'
},
fieldChange: function( e ) {
var el = jQuery( e.currentTarget );
var response = nfRadio.channel( 'nfAdmin' ).request( 'change:field', el, this.model );
},
fieldKeyup: function( e ) {
var el = jQuery( e.currentTarget );
var keyCode = e.keyCode;
nfRadio.channel( 'field-' + this.model.get( 'id' ) ).trigger( 'keyup:field', el, this.model, keyCode );
nfRadio.channel( this.model.get( 'type' ) ).trigger( 'keyup:field', el, this.model, keyCode );
nfRadio.channel( 'fields' ).trigger( 'keyup:field', el, this.model, keyCode );
},
fieldClick: function( e ) {
var el = jQuery( e.currentTarget );
nfRadio.channel( 'field-' + this.model.get( 'id' ) ).trigger( 'click:field', el, this.model );
nfRadio.channel( this.model.get( 'type' ) ).trigger( 'click:field', el, this.model );
nfRadio.channel( 'fields' ).trigger( 'click:field', el, this.model );
},
extraClick: function( e ) {
nfRadio.channel( 'field-' + this.model.get( 'id' ) ).trigger( 'click:extra', e, this.model );
nfRadio.channel( this.model.get( 'type' ) ).trigger( 'click:extra', e, this.model );
nfRadio.channel( 'fields' ).trigger( 'click:extra', e, this.model );
},
extraChange: function( e ) {
nfRadio.channel( 'field-' + this.model.get( 'id' ) ).trigger( 'change:extra', e, this.model );
nfRadio.channel( this.model.get( 'type' ) ).trigger( 'change:extra', e, this.model );
nfRadio.channel( 'fields' ).trigger( 'change:extra', e, this.model );
},
fieldBlur: function( e ) {
var el = jQuery( e.currentTarget );
nfRadio.channel( 'field-' + this.model.get( 'id' ) ).trigger( 'blur:field', el, this.model );
nfRadio.channel( this.model.get( 'type' ) ).trigger( 'blur:field', el, this.model );
nfRadio.channel( 'fields' ).trigger( 'blur:field', el, this.model );
},
onAttach: function() {
nfRadio.channel( this.model.get( 'type' ) ).trigger( 'attach:view', this );
}
});
return view;
} );
define( 'views/beforeField',[], function() {
var view = Marionette.ItemView.extend({
tagName: 'nf-section',
template: '#tmpl-nf-field-before'
});
return view;
} );
define( 'views/fieldErrorItem',[], function() {
var view = Marionette.ItemView.extend({
tagName: 'nf-section',
template: '#tmpl-nf-field-error',
onRender: function() {
this.$el = this.$el.children();
this.$el.unwrap();
this.setElement( this.$el );
},
});
return view;
} );
define( 'views/fieldErrorCollection',['views/fieldErrorItem'], function( fieldErrorItem ) {
var view = Marionette.CollectionView.extend({
tagName: "nf-errors",
childView: fieldErrorItem,
initialize: function( options ) {
this.fieldModel = options.fieldModel;
},
onRender: function() {
if ( 0 == this.fieldModel.get( 'errors' ).models.length ) {
this.fieldModel.removeWrapperClass( 'nf-error' );
this.fieldModel.removeWrapperClass( 'nf-fail' );
this.fieldModel.addWrapperClass( 'nf-pass' );
this.fieldModel.setInvalid( false );
} else {
this.fieldModel.removeWrapperClass( 'nf-pass' );
this.fieldModel.addWrapperClass( 'nf-fail' );
this.fieldModel.addWrapperClass( 'nf-error' );
this.fieldModel.setInvalid( true );
}
}
});
return view;
} );
define( 'views/inputLimit',[], function() {
var view = Marionette.ItemView.extend({
tagName: 'nf-section',
template: '#tmpl-nf-field-input-limit',
initialize: function() {
this.listenTo( nfRadio.channel( 'field-' + this.model.get( 'id' ) ), 'keyup:field', this.updateCount );
this.count = this.model.get( 'input_limit' );
this.render();
},
updateCount: function( el, model ) {
var value = jQuery( el ).val();
var regex = /\s+/gi;
var words = value.trim().replace(regex, ' ').split(' ');
var wordCount = words.length;
var charCount = value.length;
/**
* PHP Config has 'char' instead of 'characters', so I changed it to
* 'characters', but added 'char' here so existing form fields will
* act correctly
**/
if ( 'characters' == this.model.get( 'input_limit_type' )
|| 'char' == this.model.get( 'input_limit_type' ) ) {
jQuery( el ).attr( 'maxlength', this.model.get( 'input_limit' ) );
this.count = this.model.get( 'input_limit' ) - charCount;
} else {
this.count = this.model.get( 'input_limit' ) - wordCount;
var limit = this.model.get( 'input_limit' );
if( wordCount > limit ){
jQuery( el ).val( words.slice( 0, limit).join( ' ' ) );
}
}
this.render();
},
templateHelpers: function() {
var that = this;
return {
currentCount: function() {
return that.count;
}
}
}
});
return view;
} );
define( 'views/afterField',['views/fieldErrorCollection', 'views/inputLimit'], function( fieldErrorCollection, InputLimitView ) {
var view = Marionette.ItemView.extend({
tagName: 'nf-section',
template: '#tmpl-nf-field-after',
initialize: function() {
this.model.on( 'change:errors', this.changeError, this );
},
onRender: function() {
/*
* If we have an error, render our error view.
* TODO: Perhaps move to a controller?
*/
var errorEl = jQuery( this.el ).children( '.nf-error-wrap' );
this.errorCollectionView = new fieldErrorCollection( { el: errorEl, collection: this.model.get( 'errors' ), fieldModel: this.model } );
if ( 0 < this.model.get( 'errors' ).length ) {
this.errorCollectionView.render();
}
/*
* If we have an input limit set, render the view that contains our counter
* TODO: Move this to a controller so that the logic isn't in the view.
*/
if ( 'undefined' != typeof this.model.get( 'input_limit' ) && '' != jQuery.trim( this.model.get( 'input_limit' ) ) ){
var inputLimitEl = jQuery( this.el ).children( '.nf-input-limit');
this.inputLimitView = new InputLimitView( { el: inputLimitEl, model: this.model } );
}
},
changeError: function() {
this.errorCollectionView.render();
},
});
return view;
} );
define( 'views/fieldRepeaterFieldLayout',['views/fieldItem', 'views/beforeField', 'views/afterField'], function( fieldItem, beforeField, afterField ) {
var view = Marionette.LayoutView.extend({
tagName: 'nf-field',
regions: {
beforeField: '.nf-before-field',
field: '.nf-field',
afterField: '.nf-after-field',
},
initialize: function() {
this.listenTo( this.model, 'change:visible', this.render, this );
},
getTemplate: function() {
if ( this.model.get( 'visible' ) ) {
return '#tmpl-nf-field-layout';
} else {
return '#tmpl-nf-empty';
}
},
onRender: function() {
if ( this.model.get( 'visible' ) ) {
this.beforeField.show( new beforeField( { model: this.model } ) );
this.field.show( new fieldItem( { model: this.model } ) );
this.afterField.show( new afterField( { model: this.model } ) );
}
},
templateHelpers: function() {
return {
renderContainerClass: function() {
var containerClass = ' label-' + this.label_pos + ' ';
// If we have a description position, add that to our container.
if ( 'undefined' != typeof this.desc_pos ) {
containerClass += 'desc-' + this.desc_pos + ' ';
}
// if we have a container_class field setting, add that to our container.
if ( 'undefined' != typeof this.container_class && 0 < jQuery.trim( this.container_class ).length ) {
containerClass += this.container_class + ' ';
}
//check if the parent type and type are different. If
// so, add parent type container styling
if( this.type !== this.parentType ) {
containerClass += ' ' + this.parentType + '-container';
}
return containerClass;
}
}
}
});
return view;
} );
define( 'views/fieldRepeaterFieldCollection',['views/fieldRepeaterFieldLayout'], function( fieldLayout ) {
var view = Marionette.CollectionView.extend({
tagName: 'nf-fields-wrap',
childView: fieldLayout,
});
return view;
} );
define( 'views/fieldRepeaterSetLayout',[ 'views/fieldRepeaterFieldCollection' ], function( fieldCollection ) {
var view = Marionette.LayoutView.extend({
tagName: 'fieldset',
template: '#tmpl-nf-field-repeater-set',
regions: {
fields: '.nf-repeater-fieldset',
},
onRender: function() {
this.fields.show( new fieldCollection( { collection: this.model.get( 'fields' ) } ) );
},
events: {
'click .nf-remove-fieldset': 'removeSet',
},
removeSet: function() {
nfRadio.channel( "field-repeater" ).trigger( 'remove:fieldset', this.model )
}
});
return view;
} );
define( 'views/fieldRepeaterSetCollection',['views/fieldRepeaterSetLayout'], function( repeaterSetLayout ) {
var view = Marionette.CollectionView.extend({
tagName: 'div',
childView: repeaterSetLayout,
});
return view;
} );
define( 'views/fieldRepeaterLayout',[ 'views/fieldRepeaterSetCollection' ], function( repeaterSetCollection ) {
var view = Marionette.LayoutView.extend({
tagName: 'div',
template: '#tmpl-nf-field-repeater',
regions: {
sets: '.nf-repeater-fieldsets',
},
initialize: function() {
this.collection = this.model.get( 'sets' );
nfRadio.channel( 'field-repeater' ).on( 'rerender:fieldsets', this.render, this );
this.listenTo( nfRadio.channel( 'form-' + this.model.get( 'formID' ) ), 'before:submit', this.beforeSubmit );
},
onRender: function() {
this.sets.show( new repeaterSetCollection( { collection: this.collection } ) );
},
events: {
'click .nf-add-fieldset': 'addSet'
},
addSet: function( e ) {
nfRadio.channel( 'field-repeater' ).trigger( 'add:fieldset', e );
},
beforeSubmit: function() {
this.collection.beforeSubmit( this.model.get( 'sets' ) );
}
});
return view;
} );
define( 'views/fieldLayout',['views/fieldItem', 'views/beforeField', 'views/afterField', 'views/fieldRepeaterLayout'], function( fieldItem, beforeField, afterField, repeaterFieldLayout ) {
var view = Marionette.LayoutView.extend({
tagName: 'nf-field',
regions: {
beforeField: '.nf-before-field',
field: '.nf-field',
afterField: '.nf-after-field',
},
initialize: function() {
this.listenTo( this.model, 'change:visible', this.render, this );
},
getTemplate: function() {
if ( this.model.get( 'visible' ) ) {
return '#tmpl-nf-field-layout';
} else {
return '#tmpl-nf-empty';
}
},
onRender: function() {
if ( this.model.get( 'visible' ) ) {
this.beforeField.show( new beforeField( { model: this.model } ) );
if ( 'repeater' == this.model.get( 'type' ) ) {
this.field.show( new repeaterFieldLayout( { model: this.model } ) );
} else {
this.field.show( new fieldItem( { model: this.model } ) );
}
this.afterField.show( new afterField( { model: this.model } ) );
}
},
templateHelpers: function() {
return {
renderContainerClass: function() {
var containerClass = ' label-' + this.label_pos + ' ';
// If we have a description position, add that to our container.
if ( 'undefined' != typeof this.desc_pos ) {
containerClass += 'desc-' + this.desc_pos + ' ';
}
// if we have a container_class field setting, add that to our container.
if ( 'undefined' != typeof this.container_class && 0 < jQuery.trim( this.container_class ).length ) {
containerClass += this.container_class + ' ';
}
//check if the parent type and type are different. If
// so, add parent type container styling
if( this.type !== this.parentType ) {
containerClass += ' ' + this.parentType + '-container';
}
return containerClass;
}
}
}
});
return view;
} );
/**
* Return views that might be used in extensions.
* These are un-instantiated views.
*
* @package Ninja Forms builder
* @subpackage Main App
* @copyright (c) 2015 WP Ninjas
* @since 3.0
*/
define( 'controllers/loadViews',['views/fieldItem', 'views/fieldLayout'], function( fieldItemView, fieldLayoutView ) {
var controller = Marionette.Object.extend( {
initialize: function() {
// Reply to requests for our field item view.
nfRadio.channel( 'views' ).reply( 'get:fieldItem', this.getFieldItem );
nfRadio.channel( 'views' ).reply( 'get:fieldLayout', this.getFieldLayout );
},
getFieldItem: function( model ) {
return fieldItemView;
},
getFieldLayout: function() {
return fieldLayoutView;
}
});
return controller;
} );
/**
* If a form has at least one field error, we should disable the submit button and add a form error.
* If a form had errors, but all the field errors have been removed, we should remove the form error.
*
* @since 3.0
*/
define('controllers/formErrors',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
/*
* Listen for error messages being added to and removed from fields.
*/
this.listenTo( nfRadio.channel( 'fields' ), 'add:error', this.addError );
this.listenTo( nfRadio.channel( 'fields' ), 'remove:error', this.removeError );
/*
* Respond to requests to get form errors
*/
nfRadio.channel( 'form' ).reply( 'get:errors', this.getFormErrors );
},
addError: function( fieldModel, errorID, errorMsg ) {
var formModel = nfRadio.channel( 'app' ).request( 'get:form', fieldModel.get( 'formID' ) );
/*
* We store our errors in this object by field ID so that we don't have to loop over all our fields when we're testing for errors.
* They are stored as an object within an array, using the field ID as the key.
*
* If we haven't setup an array item for this field, set it as an object.
*/
if ( 'undefined' == typeof formModel.get( 'fieldErrors' )[ fieldModel.get( 'id' ) ] ) {
formModel.get( 'fieldErrors' )[ fieldModel.get( 'id' ) ] = {};
}
// Add an error to our tracking array
formModel.get( 'fieldErrors' )[ fieldModel.get( 'id' ) ][ errorID ] = errorMsg;
/*
* We have at least one field error, so submmission should be prevented.
* Add a form error.
*/
nfRadio.channel( 'form-' + fieldModel.get( 'formID' ) ).request( 'add:error', 'field-errors', formModel.get( 'settings' ).formErrorsCorrectErrors );
},
removeError: function( fieldModel, errorID ) {
var formModel = nfRadio.channel( 'app' ).request( 'get:form', fieldModel.get( 'formID' ) );
// Remove this error ID from our tracking array.
formModel.get( 'fieldErrors' )[ fieldModel.get( 'id' ) ] = _.omit( formModel.get( 'fieldErrors' )[ fieldModel.get( 'id' ) ], errorID );
/*
* If we don't have any more error IDs on this field, then we need to remove this field from the array.
*
* Then, if the fieldErrors tracking array has a length of 0, we remove our form error, because all field errors have been dealt with.
*/
if ( 0 == _.size( formModel.get( 'fieldErrors' )[ fieldModel.get( 'id' ) ] ) ) {
delete formModel.get( 'fieldErrors' )[ fieldModel.get( 'id' ) ];
}
if ( 0 == _.size( formModel.get( 'fieldErrors' ) ) ) {
// Remove our form error.
nfRadio.channel( 'form-' + fieldModel.get( 'formID' ) ).request( 'remove:error', 'field-errors' );
}
},
getFormErrors: function( formID ) {
var formModel = nfRadio.channel( 'app' ).request( 'get:form', formID );
var errors = false;
if ( formModel ) {
/*
* Check to see if we have any errors on our form model.
*/
if ( 0 !== formModel.get( 'errors' ).length ) {
_.each( formModel.get( 'errors' ).models, function( error ) {
errors = errors || {};
errors[ error.get( 'id' ) ] = error.get( 'msg' );
} );
}
}
return errors;
}
});
return controller;
} );
/**
* Handles submission of our form.
*/
define('controllers/submit',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'forms' ), 'init:model', this.registerSubmitHandler );
},
/**
* Register the submission handler function.
*
* @since 3.0
* @param Backbone.model formModel
* @return void
*/
registerSubmitHandler: function( formModel ) {
nfRadio.channel( 'form-' + formModel.get( 'id' ) ).reply( 'submit', this.submit );
},
/**
* Handles the actual submission of our form.
* When we submit:
*
* 1) Send out a message saying that we're about to begin form submission.
* 2) Check the form for errors
* 3) Submit the data
* 4) Send out a message with our response
*
* @since 3.0
* @param Backbone.model formModel
* @return void
*/
submit: function( formModel ) {
/*
* Send out a radio message saying that we're about to begin submitting.
* First we send on the generic forms channel, and then on the form-specific channel.
*/
nfRadio.channel( 'forms' ).trigger( 'before:submit', formModel );
nfRadio.channel( 'form-' + formModel.get( 'id' ) ).trigger( 'before:submit', formModel );
/*
* Validate our field models.
*/
var validate = nfRadio.channel( 'forms' ).request( 'maybe:validate', formModel );
if( false !== validate ){
// When validating all fields, set clean to false to force validation.
_.each( formModel.get( 'fields' ).models, function( fieldModel ) {
fieldModel.set( 'clean', false );
} );
/*
* This method is defined in our models/fieldCollection.js file,
* except where overridden by an add-on (ie Layout & Styles).
*/
formModel.get( 'formContentData' ).validateFields();
}
var submit = nfRadio.channel( 'form-' + formModel.get( 'id' ) ).request( 'maybe:submit', formModel );
if ( false == submit ) {
nfRadio.channel( 'forms' ).trigger( 'submit:cancel', formModel );
nfRadio.channel( 'form-' + formModel.get( 'id' ) ).trigger( 'submit:cancel', formModel );
return;
}
if( false !== validate ){
// Ignore non-blocking errors.
var blockingFormErrors = _.filter( formModel.get( 'errors' ).models, function( error ){
// Ignore email action related errors.
if( 'invalid_email' == error.get( 'id' ) || 'email_not_sent' == error.get( 'id' ) ) return false;
return true; // Error is blocking.
});
/*
* Make sure we don't have any form errors before we submit.
* Return false if we do.
*/
if ( 0 != _.size( blockingFormErrors ) ) {
nfRadio.channel( 'forms' ).trigger( 'submit:failed', formModel );
nfRadio.channel( 'form-' + formModel.get( 'id' ) ).trigger( 'submit:failed', formModel );
return false;
}
}
/*
* Send out a radio message saying that we're about to begin submitting.
* First we send on the generic forms channel, and then on the form-specific channel.
*/
nfRadio.channel( 'forms' ).trigger( 'after:submitValidation', formModel );
nfRadio.channel( 'form-' + formModel.get( 'id' ) ).trigger( 'after:submitValidation', formModel );
/*
* Actually submit our form, and send out a message with our response.
*/
var formID = formModel.get( 'id' );
var fields = {};
_.each( formModel.get( 'fields' ).models, function( field ) {
var fieldDataDefaults = { value:field.get( 'value' ), id:field.get( 'id' ) };
// Add field data at the field ID for efficient access.
fields[ field.get( 'id' ) ] = nfRadio.channel( field.get( 'type' ) ).request( 'get:submitData', fieldDataDefaults, field ) || fieldDataDefaults;;
} );
var extra = formModel.get( 'extra' );
var settings = formModel.get( 'settings' );
delete settings.formContentData;
var formData = JSON.stringify( { id: formID, fields: fields, settings: settings, extra: extra } );
var data = {
'action': 'nf_ajax_submit',
'security': nfFrontEnd.ajaxNonce,
'nonce_ts': nfFrontEnd.nonce_ts,
'formData': formData
}
var that = this;
jQuery.ajax({
url: nfFrontEnd.adminAjax,
type: 'POST',
data: data,
cache: false,
success: function( data, textStatus, jqXHR ) {
try {
var response = data;
nfRadio.channel( 'forms' ).trigger( 'submit:response', response, textStatus, jqXHR, formModel.get( 'id' ) );
nfRadio.channel( 'form-' + formModel.get( 'id' ) ).trigger( 'submit:response', response, textStatus, jqXHR );
jQuery( document ).trigger( 'nfFormSubmitResponse', { response: response, id: formModel.get( 'id' ) } );
} catch( e ) {
console.log( e );
console.log( 'Parse Error' );
console.log( e );
}
},
error: function( jqXHR, textStatus, errorThrown ) {
// Handle errors here
console.log('ERRORS: ' + errorThrown);
console.log( jqXHR );
try {
var response = jQuery.parseJSON( jqXHR.responseText );
nfRadio.channel( 'forms' ).trigger( 'submit:response', response, textStatus, jqXHR, formModel.get( 'id' ) );
nfRadio.channel( 'form-' + formModel.get( 'id' ) ).trigger( 'submit:response', response, textStatus, jqXHR );
} catch( e ) {
console.log( 'Parse Error' );
}
// STOP LOADING SPINNER
nfRadio.channel( 'forms' ).trigger( 'submit:response', 'error', textStatus, jqXHR, errorThrown );
}
});
}
});
return controller;
} );
define( 'views/fieldCollection',['views/fieldLayout'], function( fieldLayout ) {
var view = Marionette.CollectionView.extend({
tagName: 'nf-fields-wrap',
childView: fieldLayout
});
return view;
} );
/**
* Default filters
*
* @package Ninja Forms builder
* @subpackage Main App
* @copyright (c) 2015 WP Ninjas
* @since 3.0
*/
define( 'controllers/defaultFilters',[ 'views/fieldCollection', 'models/fieldCollection' ], function( FieldCollectionView, FieldCollection ) {
var controller = Marionette.Object.extend( {
initialize: function() {
this.listenTo( nfRadio.channel( 'form' ), 'before:filterData', this.registerDefaultDataFilter );
},
registerDefaultDataFilter: function( formModel ) {
/*
* Set our default formContent load filter
*/
nfRadio.channel( 'formContent' ).request( 'add:loadFilter', this.defaultFormContentLoad, 10, this );
/*
* Set our default formContentView.
*/
nfRadio.channel( 'formContent' ).request( 'add:viewFilter', this.defaultFormContentView, 10, this );
},
defaultFormContentLoad: function( formContentData, formModel, context ) {
var fieldCollection = formModel.get( 'fields' );
/*
* If we only have one load filter, we can just return the field collection.
*/
var formContentLoadFilters = nfRadio.channel( 'formContent' ).request( 'get:loadFilters' );
var sortedArray = _.without( formContentLoadFilters, undefined );
if ( 1 == sortedArray.length || 'undefined' == typeof formContentData || true === formContentData instanceof Backbone.Collection ) return formModel.get( 'fields' );
var fieldModels = _.map( formContentData, function( key ) {
return formModel.get( 'fields' ).findWhere( { key: key } );
}, this );
var currentFieldCollection = new FieldCollection( fieldModels );
fieldCollection.on( 'reset', function( collection ) {
var resetFields = [];
currentFieldCollection.each( function( fieldModel ) {
if ( 'submit' != fieldModel.get( 'type' ) ) {
resetFields.push( collection.findWhere( { key: fieldModel.get( 'key' ) } ) );
} else {
resetFields.push( fieldModel );
}
} );
currentFieldCollection.options = { formModel: formModel };
currentFieldCollection.reset( resetFields );
} );
return currentFieldCollection;
},
defaultFormContentView: function() {
return FieldCollectionView;
}
});
return controller;
} );
/**
* Controller responsible for removing unique field errors.
*/
define('controllers/uniqueFieldError',[], function() {
var controller = Marionette.Object.extend( {
initialize: function() {
/*
* Listen to keyup and field changes.
*
* If those fields have a unique field error, remove that error.
*/
this.listenTo( nfRadio.channel( 'fields' ), 'change:modelValue', this.removeError );
this.listenTo( nfRadio.channel( 'fields' ), 'keyup:field', this.removeError );
this.listenTo( nfRadio.channel( 'fields' ), 'blur:field', this.removeError );
},
removeError: function( el, model ) {
model = model || el;
/*
* Remove any unique field errors.
*/
nfRadio.channel( 'fields' ).request( 'remove:error', model.get( 'id' ), 'unique_field' );
},
});
return controller;
} );
define( 'models/fieldRepeaterSetModel',[], function() {
var model = Backbone.Model.extend( {
initialize: function(fieldsets, options) {
this.repeaterFieldModel = options.repeaterFieldModel;
this.set( 'label', this.repeaterFieldModel.get('label') );
nfRadio.channel( "field-repeater" ).reply( 'reset:repeaterFieldsets', this.resetRepeaterFieldsets, this );
nfRadio.channel( "field-repeater" ).reply( 'get:repeaterFieldsets', this.getRepeaterFieldsets, this );
nfRadio.channel( "field-repeater" ).reply( 'get:repeaterFields', this.getRepeaterFields, this );
nfRadio.channel( "field-repeater" ).reply( 'get:repeaterFieldById', this.getRepeaterFieldById, this );
},
resetRepeaterFieldsets: function( models) {
this.collection = {};
this.collection.models = models;
},
getRepeaterFieldsets: function() {
return this.collection.models;
},
getRepeaterFields: function() {
let fieldsets = this.getRepeaterFieldsets();
if(fieldsets.length <= 0 ) return;
let fields = [];
_.each(fieldsets, function(fieldset){
const inFields = fieldset.get('fields');
_.each( inFields.models, function( field ){
fields.push( field );
});
});
return fields;
},
getRepeaterFieldById: function( id ){
let fields = this.getRepeaterFields();
if(fields.length <= 0 ) return;
let model;
_.each(fields, function(field){
if( field.id === id ){
model = field;
}
});
return model;
}
} );
return model;
} );
define( 'models/fieldRepeaterSetCollection',['models/fieldRepeaterSetModel', 'models/fieldCollection' ], function( repeaterSetModel, fieldCollection ) {
var collection = Backbone.Collection.extend( {
model: repeaterSetModel,
initialize: function( models, options ) {
this.options = options;
nfRadio.channel( "field-repeater" ).on( 'sort:fieldsets', this.sortIDs, this);
nfRadio.channel( "field-repeater" ).on( 'remove:fieldset', this.removeSet, this );
nfRadio.channel( "field-repeater" ).on( 'add:fieldset', this.addSet, this );
},
addSet: function(e) {
//Get correct Field Model in case of multiple Repeater fields use
const repeaterFieldID = jQuery(e.target).prev(".nf-repeater").data("field-id");
const repeaterFieldModel = this.options.repeaterFieldModel.id === repeaterFieldID ? this.options.repeaterFieldModel : undefined;
if(repeaterFieldModel !== undefined){
//Create a new collection
let fields = new fieldCollection( this.options.templateFields, { formModel: this.options.formModel, repeaterFieldModel: repeaterFieldModel } );
//Add it th sets of collection
this.add( { fields: fields }, {repeaterFieldModel: repeaterFieldModel } );
//reset all fields IDs
this.sortIDs();
}
},
removeSet: function( fieldset ) {
//Remove the fieldset
this.remove( fieldset );
//reset all fields IDs
this.sortIDs();
},
sortIDs: function(){
nfRadio.channel( "field-repeater" ).request( 'reset:repeaterFieldsets', this.models );
//Reset repeater fields IDs when adding / removing a field
_.each(this.models, function(fieldset, modelIndex){
let fields = fieldset.get('fields');
fieldset.set( 'index', modelIndex + 1 );
_.each( fields.models, function( field ) {
//Remove suffix if it has one
cutEl = String(field.id).split('_')[0];
//Update Suffix using fieldset index
field.set("id", cutEl + "_" + modelIndex);
});
});
//Reload repeater field view ( collection of fieldsets updated )
nfRadio.channel( 'field-repeater' ).trigger( 'rerender:fieldsets' );
},
beforeSubmit: function( sets ) {
//Collect values of all fields in the repeater and create repeaterFieldValue object
let fieldsetCollection = sets.models;
if(fieldsetCollection.length > 0){
let repeaterFieldValue = {};
//Loop through fieldsets
_.each( fieldsetCollection, function( fieldset ){
let fields = fieldset.get('fields');
//Loop through fields in each fieldsets
_.each( fields.models, function( field ){
//Get ID and Value to format and store them in the repeaterFieldValue object
let value = field.get('value');
let id = field.get('id');
repeaterFieldValue[id] = {
"value": value,
"id": id
}
});
});
//Update repeater field value with repeaterFieldValue
nfRadio.channel( 'nfAdmin' ).request( 'update:field', this.options.repeaterFieldModel, repeaterFieldValue);
}
},
} );
return collection;
} );
define('controllers/fieldRepeater',[ 'models/fieldRepeaterSetCollection', 'models/fieldCollection' ], function( repeaterSetCollection, fieldCollection ) {
var controller = Marionette.Object.extend({
initialize: function () {
this.listenTo( nfRadio.channel( 'repeater' ), 'init:model', this.initRepeater );
},
initRepeater: function ( model ) {
if ( 'undefined' == typeof model.collection.options.formModel ) {
return false;
}
let fields = new fieldCollection( model.get( 'fields' ), { formModel: model.collection.options.formModel } );
model.set( 'sets', new repeaterSetCollection( [ { fields: fields } ], { templateFields: model.get( 'fields' ), formModel: model.collection.options.formModel, repeaterFieldModel: model } ) );
},
});
return controller;
});
define(
'controllers/loadControllers',[
'controllers/formData',
'controllers/fieldError',
'controllers/changeField',
'controllers/changeEmail',
'controllers/changeDate',
'controllers/fieldCheckbox',
'controllers/fieldCheckboxList',
'controllers/fieldImageList',
'controllers/fieldRadio',
'controllers/fieldNumber',
'controllers/mirrorField',
'controllers/confirmField',
'controllers/updateFieldModel',
'controllers/submitButton',
'controllers/submitDebug',
'controllers/getFormErrors',
'controllers/validateRequired',
'controllers/submitError',
'controllers/actionRedirect',
'controllers/actionSuccess',
'controllers/fieldSelect',
'controllers/coreSubmitResponse',
'controllers/fieldProduct',
'controllers/fieldTotal',
'controllers/fieldQuantity',
'controllers/calculations',
'controllers/dateBackwardsCompat',
'controllers/fieldDate',
'controllers/fieldRecaptcha',
'controllers/fieldRecaptchaV3',
'controllers/fieldHTML',
'controllers/helpText',
'controllers/fieldTextbox',
'controllers/fieldTextareaRTE',
'controllers/fieldStarRating',
'controllers/fieldTerms',
'controllers/formContentFilters',
'controllers/loadViews',
'controllers/formErrors',
'controllers/submit',
'controllers/defaultFilters',
'controllers/uniqueFieldError',
'controllers/fieldRepeater',
],
function(
FormData,
FieldError,
ChangeField,
ChangeEmail,
ChangeDate,
FieldCheckbox,
FieldCheckboxList,
FieldImageList,
FieldRadio,
FieldNumber,
MirrorField,
ConfirmField,
UpdateFieldModel,
SubmitButton,
SubmitDebug,
GetFormErrors,
ValidateRequired,
SubmitError,
ActionRedirect,
ActionSuccess,
FieldSelect,
CoreSubmitResponse,
FieldProduct,
FieldTotal,
FieldQuantity,
Calculations,
DateBackwardsCompat,
FieldDate,
FieldRecaptcha,
FieldRecaptchaV3,
FieldHTML,
HelpText,
FieldTextbox,
FieldTextareaRTE,
FieldStarRating,
FieldTerms,
FormContentFilters,
LoadViews,
FormErrors,
Submit,
DefaultFilters,
UniqueFieldError,
FieldRepeater
) {
var controller = Marionette.Object.extend( {
initialize: function() {
/**
* App Controllers
*/
new LoadViews();
new FormErrors();
new Submit();
/**
* Field type controllers
*/
new FieldCheckbox();
new FieldCheckboxList();
new FieldImageList();
new FieldRadio();
new FieldNumber();
new FieldSelect();
new FieldProduct();
new FieldTotal();
new FieldQuantity();
new FieldRecaptcha();
new FieldRecaptchaV3();
new FieldHTML();
new HelpText();
new FieldTextbox();
new FieldTextareaRTE();
new FieldStarRating();
new FieldTerms();
new FormContentFilters();
new UniqueFieldError();
new FieldRepeater();
/**
* Misc controllers
*/
new FieldError();
new ChangeField();
new ChangeEmail();
new ChangeDate();
new MirrorField();
new ConfirmField();
new UpdateFieldModel();
new SubmitButton();
new SubmitDebug();
new GetFormErrors();
new ValidateRequired();
new SubmitError();
new ActionRedirect();
new ActionSuccess();
new CoreSubmitResponse();
new Calculations();
new DefaultFilters();
/**
* Data controllers
*/
new DateBackwardsCompat();
new FieldDate();
new FormData();
}
});
return controller;
} );
define( 'views/beforeForm',[], function( ) {
var view = Marionette.ItemView.extend({
tagName: "nf-section",
template: "#tmpl-nf-before-form",
});
return view;
} );
define( 'views/formErrorItem',[], function() {
var view = Marionette.ItemView.extend({
tagName: 'nf-section',
template: '#tmpl-nf-form-error',
onRender: function() {
// this.$el = this.$el.children();
// this.$el.unwrap();
// this.setElement( this.$el );
},
});
return view;
} );
define( 'views/formErrorCollection',['views/formErrorItem'], function( formErrorItem ) {
var view = Marionette.CollectionView.extend({
tagName: "nf-errors",
childView: formErrorItem
});
return view;
} );
define( 'views/honeyPot',[], function() {
var view = Marionette.ItemView.extend({
tagName: 'nf-section',
template: '#tmpl-nf-form-hp',
events: {
'keyup .nf-field-hp': 'maybeError',
'change .nf-field-hp': 'maybeError'
},
maybeError: function( e ) {
/*
* If we have an empty honeyPot field, remove the honeypot form error.
* If we do not have an empty honeyPot field, add the honeypot form error.
*/
if ( 0 == jQuery( e.target ).val().length ) {
nfRadio.channel( 'form-' + this.model.get( 'id' ) ).request( 'remove:error', 'honeyPot' );
} else {
var formModel = nfRadio.channel( 'app' ).request( 'get:form', this.model.get( 'id' ) );
nfRadio.channel( 'form-' + this.model.get( 'id' ) ).request( 'add:error', 'honeyPot', formModel.get( 'settings' ).honeypotHoneypotError );
}
}
});
return view;
} );
define( 'views/afterFormContent',['views/formErrorCollection', 'views/honeyPot'], function( FormErrors, HoneyPot ) {
var view = Marionette.LayoutView.extend({
tagName: "nf-section",
template: "#tmpl-nf-after-fields",
regions: {
errors: ".nf-form-errors",
hp: ".nf-form-hp"
},
onShow: function() {
this.errors.show( new FormErrors( { collection: this.model.get( 'errors' ) } ) );
this.hp.show( new HoneyPot( { model: this.model } ) );
}
});
return view;
} );
define( 'views/beforeFormContent',[], function( ) {
var view = Marionette.ItemView.extend({
tagName: "nf-section",
template: "#tmpl-nf-before-fields",
templateHelpers: function () {
return {
renderFieldsMarkedRequired: function() {
var requiredFields = this.fields.filter( { required: 1 } );
return ( requiredFields.length ) ? this.fieldsMarkedRequired : '';
},
};
},
});
return view;
} );
define( 'views/formLayout',[ 'views/afterFormContent', 'views/beforeFormContent', 'models/fieldCollection' ], function( AfterFormContent, BeforeFormContent, FieldCollection ) {
var view = Marionette.LayoutView.extend({
tagName: "nf-section",
template: "#tmpl-nf-form-layout",
regions: {
beforeFormContent: ".nf-before-form-content",
formContent: ".nf-form-content",
afterFormContent: ".nf-after-form-content"
},
initialize: function() {
nfRadio.channel( 'form-' + this.model.get( 'id' ) ).reply( 'get:el', this.getEl, this );
/*
* If we need to hide a form, set the visibility of this form to hidden.
*/
this.listenTo( this.model, 'hide', this.hide );
},
onRender: function() {
this.$el = this.$el.children();
this.$el.unwrap();
this.setElement( this.$el );
},
onShow: function() {
this.beforeFormContent.show( new BeforeFormContent( { model: this.model } ) );
/*
* Set our formContentData to our form setting 'formContentData'
*/
var formContentData = this.model.get( 'formContentData' );
/*
* Check our fieldContentViewsFilter to see if we have any defined.
* If we do, overwrite our default with the view returned from the filter.
*/
var formContentViewFilters = nfRadio.channel( 'formContent' ).request( 'get:viewFilters' );
/*
* Get our first filter, this will be the one with the highest priority.
*/
var sortedArray = _.without( formContentViewFilters, undefined );
var callback = _.first( sortedArray );
formContentView = callback();
var options = {
data: formContentData,
formModel: this.model
};
/*
* If we have a collection, pass the returned data as the collection.
*
* If we have a model, pass the returned data as the collection.
*/
if ( false !== formContentData instanceof Backbone.Collection ) {
options.collection = formContentData;
} else if ( false !== formContentData instanceof Backbone.Model ) {
options.model = formContentData;
}
this.formContent.show( new formContentView( options ) );
this.afterFormContent.show( new AfterFormContent( { model: this.model } ) );
},
getEl: function() {
return this.el;
},
templateHelpers: function () {
return {
renderClasses: function() {
return '';
}
};
},
hide: function() {
jQuery( this.el ).hide();
}
});
return view;
} );
define( 'views/afterForm',[], function( ) {
var view = Marionette.ItemView.extend({
tagName: "nf-section",
template: "#tmpl-nf-after-form",
});
return view;
} );
define( 'views/mainLayout',['views/beforeForm', 'views/formLayout', 'views/afterForm'], function( BeforeForm, FormLayout, AfterForm ) {
var view = Marionette.LayoutView.extend({
template: '#tmpl-nf-layout',
regions: {
responseMsg: '.nf-response-msg',
beforeForm: '.nf-before-form',
formLayout: '.nf-form-layout',
afterForm: '.nf-after-form'
},
initialize: function() {
this.$el = jQuery( '#nf-form-' + this.model.id + '-cont' );
this.el = '#nf-form-' + this.model.id + '-cont';
this.render();
this.beforeForm.show( new BeforeForm( { model: this.model } ) );
this.formLayout.show( new FormLayout( { model: this.model, fieldCollection: this.options.fieldCollection } ) );
this.afterForm.show( new AfterForm( { model: this.model } ) );
/*
* If we need to hide a form, set the visibility of this form to hidden.
*/
this.listenTo( this.model, 'hide', this.hide );
},
hide: function() {
jQuery( this.el ).find( '.nf-form-title' ).hide();
}
});
return view;
} );
// const Intl = require('intl');
// class nfLocaleConverter {
var nfLocaleConverter = function(newLocale, thousands_sep, decimal_sep) {
// constructor(newLocale = 'en-US', thousands_sep, decimal_sep) {
if ('undefined' !== typeof newLocale && 0 < newLocale.length) {
this.locale = newLocale.split('_').join('-');
} else {
this.locale = 'en-US';
}
this.thousands_sep = thousands_sep || ',';
this.decimal_sep = decimal_sep || '.';
// }
this.uniqueElememts = function( value, index, self ) {
return self.indexOf(value) === index;
}
this.numberDecoder = function(num) {
num = num.toString();
// let thousands_sep = ',';
var formatted = '';
// Account for negative numbers.
var negative = false;
if ('-' === num.charAt(0)) {
negative = true;
num = num.replace( '-', '' );
}
// Account for a space as the thousands separator.
// This pattern accounts for all whitespace characters (including thin space).
num = num.replace( /\s/g, '' );
num = num.replace( /&nbsp;/g, '' );
// Determine what our existing separators are.
var myArr = num.split('');
var separators = myArr.filter(function(el) {
return !el.match(/[0-9]/);
});
var final_separators = separators.filter(this.uniqueElememts);
switch( final_separators.length ) {
case 0:
formatted = num;
break;
case 1:
var replacer = '';
if ( 1 == separators.length ) {
separator = separators.pop();
var sides = num.split(separator);
var last = sides.pop();
if ( 3 == last.length && separator == this.thousands_sep ) {
replacer = '';
} else {
replacer = '.';
}
} else {
separator = final_separators.pop();
}
formatted = num.split(separator).join(replacer);
break;
case 2:
var find_one = final_separators[0];
var re_one;
if('.' === find_one) {
re_one = new RegExp('[.]', 'g');
} else {
re_one = new RegExp(find_one, 'g');
}
formatted = num.replace(re_one, '');
var find_two = final_separators[1];
var re_two;
if('.' === find_two) {
re_two = new RegExp('[.]', 'g');
} else {
re_two = new RegExp(find_two, 'g');
}
formatted = formatted.replace(re_two, '.' );
break;
default:
return 'NaN';
}
if ( negative ) {
formatted = '-' + formatted;
}
this.debug('Number Decoder ' + num + ' -> ' + formatted );
return formatted;
}
this.numberEncoder = function(num, percision) {
num = this.numberDecoder(num);
return Intl.NumberFormat(this.locale, { minimumFractionDigits: percision, maximumFractionDigits: percision }).format(num);
}
this.debug = function(message) {
if ( window.nfLocaleConverterDebug || false ) console.log(message);
}
}
// module.exports = nfLocaleConverter;
define("../nfLocaleConverter", function(){});
/*
* Because our backbone listens to .change() events on elements, changes made using jQuery .val() don't bubble properly.
* This patch overwrites the default behaviour of jQuery .val() so that IF the item has an nf-element class, we fire a change event.
*/
( function( jQuery ) {
/*
* Store our original .val() function.
*/
var originalVal = jQuery.fn.val;
/*
* Create our own .val() function.
*/
jQuery.fn.val = function(){
var prev;
/*
* Store a copy of the results of the original .val() call.
* We use this to make sure that we've actually changed something.
*/
if( arguments.length > 0 ){
prev = originalVal.apply( this,[] );
}
/*
* Get the results of the original .val() call.
*/
var result = originalVal.apply( this, arguments );
/*
* If we have arguments, we have actually made a change, AND this has the nf-element class, trigger .change().
*/
if( arguments.length > 0 && prev != originalVal.apply( this, [] ) && jQuery( this ).hasClass( 'nf-element' ) ) {
jQuery(this).change();
}
return result;
};
} ) ( jQuery );
jQuery( document ).ready( function( $ ) {
require( [ 'models/formCollection', 'models/formModel', 'models/fieldCollection', 'controllers/loadControllers', 'views/mainLayout', '../nfLocaleConverter'], function( formCollection, FormModel, FieldCollection, LoadControllers, mainLayout ) {
if( 'undefined' == typeof nfForms ) {
/*
* nfForms is not defined. This means that something went wrong loading the form data.
* Bail form setup and empty the form containers to remove any loading animations.
*/
jQuery( '.nf-form-cont' ).empty();
return;
}
var NinjaForms = Marionette.Application.extend({
forms: {},
initialize: function( options ) {
var that = this;
Marionette.Renderer.render = function(template, data){
var template = that.template( template );
return template( data );
};
// Underscore one-liner for getting URL Parameters
this.urlParameters = _.object(_.compact(_.map(location.search.slice(1).split('&'), function(item) { if (item) return item.split('='); })));
if( 'undefined' != typeof this.urlParameters.nf_resume ) {
this.listenTo(nfRadio.channel('form-' + this.urlParameters.nf_resume), 'loaded', this.restart);
}
nfRadio.channel( 'app' ).reply( 'locale:decodeNumber', this.decodeNumber);
nfRadio.channel( 'app' ).reply( 'locale:encodeNumber',this.encodeNumber);
var loadControllers = new LoadControllers();
nfRadio.channel( 'app' ).trigger( 'after:loadControllers' );
nfRadio.channel( 'app' ).reply( 'get:template', this.template ); },
onStart: function() {
var formCollection = nfRadio.channel( 'app' ).request( 'get:forms' );
_.each( formCollection.models, function( form, index ) {
var layoutView = new mainLayout( { model: form, fieldCollection: form.get( 'fields' ) } );
nfRadio.channel( 'form' ).trigger( 'render:view', layoutView );
jQuery( document ).trigger( 'nfFormReady', layoutView );
} );
},
restart: function( formModel ) {
if( 'undefined' != typeof this.urlParameters.nf_resume ){
var data = {
'action': 'nf_ajax_submit',
'security': nfFrontEnd.ajaxNonce,
'nf_resume': this.urlParameters
};
nfRadio.channel( 'form-' + formModel.get( 'id' ) ).trigger( 'disable:submit' );
nfRadio.channel( 'form-' + formModel.get( 'id' ) ).trigger( 'processingLabel' );
this.listenTo( nfRadio.channel( 'form' ), 'render:view', function() {
/**
* TODO: This needs to be re-worked for backbone. It's not dynamic enough.
*/
/*
* Hide form fields (but not the submit button).
*/
jQuery( '#nf-form-' + formModel.get( 'id' ) + '-cont .nf-field-container:not(.submit-container)' ).hide();
});
// TODO: Refactor Duplication
jQuery.ajax({
url: nfFrontEnd.adminAjax,
type: 'POST',
data: data,
cache: false,
success: function( data, textStatus, jqXHR ) {
try {
var response = data;
nfRadio.channel( 'forms' ).trigger( 'submit:response', response, textStatus, jqXHR, formModel.get( 'id' ) );
nfRadio.channel( 'form-' + formModel.get( 'id' ) ).trigger( 'submit:response', response, textStatus, jqXHR );
} catch( e ) {
console.log( 'Parse Error' );
}
},
error: function( jqXHR, textStatus, errorThrown ) {
// Handle errors here
console.log('ERRORS: ' + textStatus);
// STOP LOADING SPINNER
nfRadio.channel( 'forms' ).trigger( 'submit:response', 'error', textStatus, jqXHR, errorThrown );
}
});
}
},
template: function( template ) {
return _.template( $( template ).html(), {
evaluate: /<#([\s\S]+?)#>/g,
interpolate: /\{\{\{([\s\S]+?)\}\}\}/g,
escape: /\{\{([^\}]+?)\}\}(?!\})/g,
variable: 'data'
} );
},
encodeNumber: function(num) {
var localeConverter = new nfLocaleConverter(nfi18n.siteLocale, nfi18n.thousands_sep, nfi18n.decimal_point);
return localeConverter.numberEncoder(num);
},
decodeNumber: function(num) {
var localeConverter = new nfLocaleConverter(nfi18n.siteLocale, nfi18n.thousands_sep, nfi18n.decimal_point);
return localeConverter.numberDecoder(num);
}
});
var ninjaForms = new NinjaForms();
ninjaForms.start();
} );
} );
define("main", function(){});
}());
//# sourceMappingURL=front-end.js.map