495 lines
12 KiB
JavaScript
495 lines
12 KiB
JavaScript
'use strict';
|
|
|
|
/**
|
|
* Module dependencies.
|
|
*/
|
|
var mongoose = require('mongoose'),
|
|
Schema = mongoose.Schema,
|
|
pdfFiller = require('pdffiller'),
|
|
_ = require('lodash'),
|
|
config = require('../../config/config'),
|
|
path = require('path'),
|
|
mUtilities = require('mongoose-utilities'),
|
|
fs = require('fs-extra'),
|
|
async = require('async'),
|
|
util = require('util');
|
|
|
|
//Mongoose Models
|
|
var FieldSchema = require('./form_field.server.model.js');
|
|
var Field = mongoose.model('Field');
|
|
|
|
var FormSubmissionSchema = require('./form_submission.server.model.js'),
|
|
FormSubmission = mongoose.model('FormSubmission', FormSubmissionSchema);
|
|
|
|
|
|
var ButtonSchema = new Schema({
|
|
url: {
|
|
type: String,
|
|
match: [/((([A-Za-z]{3,9}:(?:\/\/)?)(?:[-;:&=\+\$,\w]+@)?[A-Za-z0-9.-]+|(?:www.|[-;:&=\+\$,\w]+@)[A-Za-z0-9.-]+)((?:\/[\+~%\/.\w-_]*)?\??(?:[-\+=&;%@.\w_]*)#?(?:[\w]*))?)/],
|
|
},
|
|
action: String,
|
|
text: String,
|
|
bgColor: {
|
|
type: String,
|
|
match: [/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/],
|
|
default: '#5bc0de'
|
|
},
|
|
color: {
|
|
type: String,
|
|
match: [/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/],
|
|
default: '#ffffff'
|
|
}
|
|
});
|
|
|
|
/**
|
|
* Form Schema
|
|
*/
|
|
var FormSchema = new Schema({
|
|
title: {
|
|
type: String,
|
|
trim: true,
|
|
required: 'Form Title cannot be blank',
|
|
},
|
|
language: {
|
|
type: String,
|
|
enum: ['english', 'french', 'spanish'],
|
|
required: 'Form must have a language',
|
|
default: 'english'
|
|
},
|
|
description: {
|
|
type: String,
|
|
default: ''
|
|
},
|
|
form_fields: {
|
|
type: [FieldSchema]
|
|
},
|
|
|
|
submissions: [{
|
|
type: Schema.Types.ObjectId,
|
|
ref: 'FormSubmission'
|
|
}],
|
|
|
|
admin: {
|
|
type: Schema.Types.ObjectId,
|
|
ref: 'User',
|
|
required: 'Form must have an Admin'
|
|
},
|
|
|
|
pdf: {
|
|
type: Schema.Types.Mixed
|
|
},
|
|
pdfFieldMap: {
|
|
type: Schema.Types.Mixed
|
|
},
|
|
|
|
startPage: {
|
|
showStart:{
|
|
type: Boolean,
|
|
default: false,
|
|
},
|
|
introTitle:{
|
|
type: String,
|
|
default: 'Welcome to Form'
|
|
},
|
|
introParagraph:{
|
|
type: String
|
|
},
|
|
introButtonText:{
|
|
type: String,
|
|
default: 'Start'
|
|
},
|
|
buttons:[ButtonSchema]
|
|
},
|
|
|
|
hideFooter: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
isGenerated: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
isLive: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
autofillPDFs: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
|
|
design: {
|
|
colors:{
|
|
backgroundColor: {
|
|
type: String,
|
|
match: [/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/],
|
|
default: '#fff'
|
|
},
|
|
questionColor: {
|
|
type: String,
|
|
match: [/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/],
|
|
default: '#333'
|
|
},
|
|
answerColor: {
|
|
type: String,
|
|
match: [/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/],
|
|
default: '#333'
|
|
},
|
|
buttonColor: {
|
|
type: String,
|
|
match: [/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/],
|
|
default: '#fff'
|
|
},
|
|
buttonTextColor: {
|
|
type: String,
|
|
match: [/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/],
|
|
default: '#333'
|
|
},
|
|
},
|
|
font: String,
|
|
backgroundImage: { type: Schema.Types.Mixed }
|
|
},
|
|
|
|
plugins: {
|
|
oscarhost: {
|
|
baseUrl: {
|
|
type: String,
|
|
},
|
|
settings: {
|
|
lookupField: {
|
|
type: Schema.Types.ObjectId,
|
|
ref: 'Field'
|
|
},
|
|
updateType: {
|
|
type: String,
|
|
enum: ['upsert', 'force_add', 'force_update', 'fetch'],
|
|
},
|
|
fieldMap: {
|
|
type: Schema.Types.Mixed,
|
|
},
|
|
validUpdateTypes: {
|
|
type: [String]
|
|
},
|
|
validFields : {
|
|
type: [String],
|
|
default: [
|
|
'address',
|
|
'city',
|
|
'email',
|
|
'firstName',
|
|
'hin',
|
|
'lastName',
|
|
'phone',
|
|
'postal',
|
|
'province',
|
|
'sex',
|
|
'spokenLanguage',
|
|
'title',
|
|
'DOB']
|
|
}
|
|
},
|
|
auth: {
|
|
user: {
|
|
type: String,
|
|
},
|
|
pass: {
|
|
type: String,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
FormSchema.plugin(mUtilities.timestamp, {
|
|
createdPath: 'created',
|
|
modifiedPath: 'lastModified',
|
|
useVirtual: false
|
|
});
|
|
|
|
//DAVID: TODO: Make this so we don't have to update the validFields property ever save
|
|
FormSchema.pre('save', function (next) {
|
|
|
|
if(this.plugins.oscarhost.hasOwnProperty('baseUrl')){
|
|
var validUpdateTypes= mongoose.model('Form').schema.path('plugins.oscarhost.settings.updateType').enumValues;
|
|
this.plugins.oscarhost.settings.validUpdateTypes = validUpdateTypes;
|
|
}
|
|
|
|
next();
|
|
});
|
|
//Delete template PDF of current Form
|
|
FormSchema.pre('remove', function (next) {
|
|
if(this.pdf && process.env.NODE_ENV === 'development'){
|
|
//Delete template form
|
|
fs.unlink(this.pdf.path, function(err){
|
|
if (err) throw err;
|
|
console.log('successfully deleted', this.pdf.path);
|
|
});
|
|
}
|
|
});
|
|
|
|
var _original;
|
|
|
|
//Set _original
|
|
FormSchema.pre('save', function (next) {
|
|
|
|
this.constructor
|
|
.findOne({_id: this._id}).exec(function(err, original){
|
|
if(err) {
|
|
console.log(err);
|
|
next(err);
|
|
} else {
|
|
_original = original;
|
|
//console.log('_original');
|
|
// console.log(_original);
|
|
next();
|
|
}
|
|
});
|
|
});
|
|
|
|
function getDeletedIndexes(needle, haystack){
|
|
var deletedIndexes = [];
|
|
|
|
if(haystack.length > 0){
|
|
for(var i = 0; i < needle.length; i++){
|
|
if(haystack.indexOf(needle[i]) === -1){
|
|
deletedIndexes.push(i);
|
|
}
|
|
}
|
|
}
|
|
return deletedIndexes;
|
|
}
|
|
|
|
//Move PDF to permanent location after new template is uploaded
|
|
FormSchema.pre('save', function (next) {
|
|
if(this.pdf){
|
|
var that = this;
|
|
async.series([
|
|
function(callback){
|
|
if(that.isModified('pdf') && that.pdf.path){
|
|
|
|
var new_filename = that.title.replace(/ /g,'')+'_template.pdf';
|
|
|
|
var newDestination = path.join(config.pdfUploadPath, that.admin.username.replace(/ /g,''), that.title.replace(/ /g,'')),
|
|
stat = null;
|
|
|
|
try {
|
|
stat = fs.statSync(newDestination);
|
|
} catch (err) {
|
|
fs.mkdirSync(newDestination);
|
|
}
|
|
if (stat && !stat.isDirectory()) {
|
|
return callback( new Error('Directory cannot be created because an inode of a different type exists at "' + config.pdfUploadPath + '"'), null);
|
|
}
|
|
|
|
var old_path = that.pdf.path;
|
|
fs.move(old_path, path.join(newDestination, new_filename), {clobber: true}, function (err) {
|
|
if (err) {
|
|
console.error(err);
|
|
callback( new Error(err.message), 'task1');
|
|
}else {
|
|
that.pdf.path = path.join(newDestination, new_filename);
|
|
that.pdf.name = new_filename;
|
|
|
|
callback(null,'task1');
|
|
}
|
|
});
|
|
}else {
|
|
callback(null,'task1');
|
|
}
|
|
|
|
},
|
|
function(callback){
|
|
if(that.isGenerated){
|
|
that.pdf.path = path.join(config.pdfUploadPath, that.admin.username.replace(/ /g,''), that.title.replace(/ /g,''), that.title.replace(/ /g,'')+'_template.pdf');
|
|
that.pdf.name = that.title.replace(/ /g,'')+'_template.pdf';
|
|
var _typeConvMap = {
|
|
'Multiline': 'textarea',
|
|
'Text': 'textfield',
|
|
'Button': 'checkbox',
|
|
'Choice': 'radio',
|
|
'Password': 'password',
|
|
'FileSelect': 'filefield',
|
|
'Radio': 'radio'
|
|
};
|
|
|
|
// console.log('autogenerating form');
|
|
// console.log(that.pdf.path);
|
|
|
|
pdfFiller.generateFieldJson(that.pdf.path, function(err, _form_fields){
|
|
if(err){
|
|
callback( new Error(err.message), null);
|
|
}else if(!_form_fields.length || _form_fields === undefined || _form_fields === null){
|
|
callback( new Error('Generated formfields is empty'), null);
|
|
}
|
|
|
|
//Map PDF field names to FormField field names
|
|
for(var i = 0; i < _form_fields.length; i++){
|
|
var field = _form_fields[i];
|
|
|
|
//Convert types from FDF to 'FormField' types
|
|
if(_typeConvMap[ field.fieldType+'' ]){
|
|
field.fieldType = _typeConvMap[ field.fieldType+'' ];
|
|
}
|
|
|
|
// field = new Field(field);
|
|
field.required = false;
|
|
_form_fields[i] = field;
|
|
}
|
|
|
|
// console.log('NEW FORM_FIELDS: ');
|
|
// console.log(_form_fields);
|
|
|
|
that.form_fields = that.form_fields.concat(_form_fields);
|
|
|
|
// console.log('\n\nOLD FORM_FIELDS: ');
|
|
// console.log(that.form_fields);
|
|
that.isGenerated = false;
|
|
callback(null, 'task2');
|
|
});
|
|
}else{
|
|
callback(null, 'task2');
|
|
}
|
|
}
|
|
], function(err, results) {
|
|
if(err){
|
|
next(new Error({
|
|
message: err.message
|
|
}));
|
|
}
|
|
console.log('ending form save');
|
|
next();
|
|
|
|
});
|
|
}else if(_original){
|
|
if(_original.hasOwnProperty('pdf')){
|
|
fs.remove(_original.pdf.path, function (err) {
|
|
if(err) next(err);
|
|
console.log('file at '+_original.pdf.path+' successfully deleted');
|
|
next();
|
|
});
|
|
}
|
|
}
|
|
next();
|
|
});
|
|
|
|
FormSchema.pre('save', function (next) {
|
|
|
|
// console.log('_original\n------------');
|
|
// console.log(_original);
|
|
//console.log('field has been deleted: ');
|
|
//console.log(this.isModified('form_fields') && !!this.form_fields && !!_original);
|
|
|
|
if(this.isModified('form_fields') && this.form_fields && _original){
|
|
|
|
var old_form_fields = _original.form_fields,
|
|
new_ids = _.map(_.pluck(this.form_fields, '_id'), function(id){ return ''+id;}),
|
|
old_ids = _.map(_.pluck(old_form_fields, '_id'), function(id){ return ''+id;}),
|
|
deletedIds = getDeletedIndexes(old_ids, new_ids),
|
|
that = this;
|
|
|
|
// console.log('deletedId Indexes\n--------');
|
|
// console.log(deletedIds);
|
|
// console.log('old_ids\n--------');
|
|
// console.log(old_ids);
|
|
// console.log('new_ids\n--------');
|
|
// console.log(new_ids);
|
|
|
|
//Preserve fields that have at least one submission
|
|
if( deletedIds.length > 0 ){
|
|
|
|
var modifiedSubmissions = [];
|
|
|
|
async.forEachOfSeries(deletedIds,
|
|
function (deletedIdIndex, key, callback) {
|
|
|
|
var deleted_id = old_ids[deletedIdIndex];
|
|
|
|
//Find FormSubmissions that contain field with _id equal to 'deleted_id'
|
|
FormSubmission.
|
|
find({ form: that._id, admin: that.admin, form_fields: {$elemMatch: {_id: deleted_id} } }).
|
|
exec(function(err, submissions){
|
|
if(err){
|
|
console.error(err);
|
|
return callback(err);
|
|
}
|
|
|
|
//Delete field if there are no submission(s) found
|
|
if(submissions.length) {
|
|
// console.log('adding submissions');
|
|
// console.log(submissions);
|
|
//Add submissions
|
|
modifiedSubmissions.push.apply(modifiedSubmissions, submissions);
|
|
}
|
|
|
|
callback(null);
|
|
});
|
|
// }
|
|
},
|
|
function (err) {
|
|
if(err){
|
|
console.error(err.message);
|
|
next(err);
|
|
}
|
|
|
|
// console.log('modifiedSubmissions\n---------\n\n');
|
|
// console.log(modifiedSubmissions);
|
|
|
|
|
|
//Iterate through all submissions with modified form_fields
|
|
async.forEachOfSeries(modifiedSubmissions, function (submission, key, callback) {
|
|
|
|
//Iterate through ids of deleted fields
|
|
for(var i = 0; i < deletedIds.length; i++){
|
|
|
|
var index = _.findIndex(submission.form_fields, function(field){
|
|
var tmp_id = field._id+'';
|
|
return tmp_id === old_ids[ deletedIds[i] ];
|
|
}
|
|
);
|
|
|
|
var deletedField = submission.form_fields[index];
|
|
|
|
//Hide field if it exists
|
|
if(deletedField){
|
|
// console.log('deletedField\n-------\n\n');
|
|
// console.log(deletedField);
|
|
//Delete old form_field
|
|
submission.form_fields.splice(index, 1);
|
|
|
|
deletedField.deletePreserved = true;
|
|
|
|
//Move deleted form_field to start
|
|
submission.form_fields.unshift(deletedField);
|
|
that.form_fields.unshift(deletedField);
|
|
// console.log('form.form_fields\n--------\n\n');
|
|
// console.log(that.form_fields);
|
|
}
|
|
}
|
|
|
|
submission.save(function (err) {
|
|
if(err) callback(err);
|
|
else callback(null);
|
|
});
|
|
}, function (err) {
|
|
if(err){
|
|
console.error(err.message);
|
|
next(err);
|
|
}
|
|
// console.log('form.form_fields\n--------\n\n');
|
|
// console.log(that.form_fields);
|
|
next();
|
|
});
|
|
}
|
|
);
|
|
}else {
|
|
next();
|
|
}
|
|
}else {
|
|
next();
|
|
}
|
|
});
|
|
|
|
|
|
mongoose.model('Form', FormSchema);
|
|
|