/**
*
* This method sets default value for a dialog field
* @memberof DialogDataService
* @function setDefaultValue
* @param data {any} This is a object that is all the information for a particular dialog field
*
**/
private setDefaultValue(data): any {
let defaultValue: any = '';
const firstOption = 0; // these are meant to help make code more readable
const fieldValue = 0;
if (_.isObject(data.values)) {
defaultValue = data.values[firstOption][fieldValue];
}
if (data.type === 'DialogFieldDateControl' || data.type === 'DialogFieldDateTimeControl') {
defaultValue = data.values ? new Date(data.values) : new Date();
}
if (data.default_value) {
defaultValue = data.default_value;
}
if (data.type === 'DialogFieldDropDownList' && data.options.force_multi_value && data.default_value) {
defaultValue = JSON.parse(data.default_value);
}
if (data.type === 'DialogFieldTagControl') {
// setting the default_value for a tag control's select box
// In case the default_value is not set for the ng-model of the component, an empty value option is displayed
let defaultOption = _.find(data.values, { id: null });
if (defaultOption) {
defaultOption.id = 0;
defaultValue = defaultOption.id;
}
}
if (this.checkboxNeedsNewDefaultValue(data)) {
defaultValue = data.values;
}
return defaultValue;
}
function retrieveFileFromDb (file) {
assert (_.isObject (file), 'file not an object');
return new Promise (function (resolve, reject) {
// Create a file with a name of the form 'file._id.<ext>', where <ext> is the extension of the original file
var filepath = __dirname + '/../client-build/' + file._id + '.' + file.filename.substr(file.filename.lastIndexOf('.')+1);
// Check whether the file already exists
fs.open (filepath, 'r', function (err, fd) {
if (!err) {
// File already exits
fs.closeSync (fd);
resolve (null);
}
else {
// File does not exist...create it
var fs_write_stream = fs.createWriteStream (filepath);
var gfs = Grid(conn.db);
//read from mongodb
var readstream = gfs.createReadStream ({_id: file._id});
readstream.pipe (fs_write_stream);
fs_write_stream.on ('close', function () {
console.log ('file created: ' + filepath);
resolve (null);
});
fs_write_stream.on ('error', function () {
err = 'file creation error: ' + filepath;
reject (err);
});
}
});
});
}
export function collectFrozenNodes(abstractSyntaxTree: any, nodes?: any[]): any[] {
nodes = nodes || [];
if (!_.isArray(abstractSyntaxTree) && _.isObject(abstractSyntaxTree) && abstractSyntaxTree.type && _.isUndefined(abstractSyntaxTree.nodeID)) {
abstractSyntaxTree.nodeID = nodes.length;
nodes.push(abstractSyntaxTree);
}
Object.freeze(abstractSyntaxTree);
_.forOwn(abstractSyntaxTree, (childNode, i) => {
if (childNode instanceof Object && !(childNode instanceof Array)) {
collectFrozenNodes(childNode, nodes);
} else if (childNode instanceof Array) {
_.forEach(childNode, (arrayChild) => {
if (arrayChild instanceof Object && !(arrayChild instanceof Array)) {
collectFrozenNodes(arrayChild, nodes);
}
});
}
});
return nodes;
};
constructor(options: ITool<T>) {
_.assign(this, options);
if (_.isUndefined(this.lifecycle)) {
this.lifecycle = Smithy.Lifecycle.Singleton;
}
assert(_.isString(this.name), "'name' is required and must be a string");
assert(!_.isUndefined(this.target), "'target' is required");
assert(!_.isNull(this.target), "'target' is required");
if (!_.isUndefined(this.bindingArguments)) {
assert(_.isObject(this.bindingArguments), "'bindingArguments', if defined, must be an object.");
}
if (!_.isUndefined(this.when)) {
assert(_.isFunction(this.when), "'when', if defined, must be a function.");
}
if (!_.isUndefined(this.hint)) {
assert(_.isString(this.hint), "'hint', if defined, must be a string.");
}
}
(value: boolean | Record<string, boolean>, uiCapability) => {
if (typeof value === 'boolean') {
if (!shouldDisableFeatureUICapability(featureId!, uiCapability!)) {
return value;
}
return checkPrivilegesForCapability(value, featureId!, uiCapability!);
}
if (isObject(value)) {
const res = mapValues(value, (enabled, subUiCapability) => {
return checkPrivilegesForCapability(
enabled,
featureId!,
uiCapability!,
subUiCapability!
);
});
return res;
}
throw new Error(
`Unexpected UI Capability value. Expected boolean or object, but found ${value}`
);
}
var checkInputType = function(scope) {
scope.isObject = _.isObject(scope.input.model);
scope.isNumber =
!scope.options &&
!scope.isObject &&
(scope.type === "number" || scope.type === "float" || scope.type === "integer");
scope.isDate = !scope.options && scope.type === "date";
scope.isText =
!scope.options &&
!scope.isObject &&
!(scope.type === "number" || scope.type === "float" || scope.type === "integer" || scope.type === "label");
scope.isMultiText = !scope.options && scope.isObject && scope.type !== "label";
scope.datePicker = {
options: YleinenData.dateOptions,
format: YleinenData.dateFormatDatepicker,
state: false,
open: function($event) {
$event.preventDefault();
$event.stopPropagation();
scope.datePicker.state = !scope.datePicker.state;
}
};
scope.isLabel = scope.type === "label";
};
var uusiViesti = function(tyyppi, viesti, ilmanKuvaa = false) {
if (_.isObject(viesti) && viesti.data && viesti.data.syy) {
viesti = viesti.data.syy;
} else if (!viesti) {
viesti = "";
}
if (!_.isEmpty(viestit)) {
var viimeinenViesti = viestit[_.size(viestit) - 1];
if (viimeinenViesti.tyyppi === tyyppi && viimeinenViesti.viesti === viesti) {
return;
}
}
viestit.push({
viesti: viesti ? viesti : tyyppi === 1 ? "tallennus-onnistui" : "",
ilmanKuvaa: ilmanKuvaa,
tyyppi: tyyppi,
luotu: new Date()
});
$rootScope.$broadcast("update:notifikaatiot");
refresh();
};
.service("virheService", function($state) {
var data = {};
return {
setData(d) {
data = d;
},
getData() {
return data;
},
virhe(virhe) {
if (_.isObject(virhe)) {
data = virhe;
} else {
data = { muu: virhe };
}
$state.go("root.virhe", {
location: "replace"
});
}
};
});
function mandatoryFieldValidator(fields, target) {
err = undefined;
const fieldsf = _.filter(fields || [], function(field) {
return (field as any).mandatory;
});
$rootScope.$$ekEditing = false;
if (!target) {
return false;
} else if (_.isString(target)) {
return !_.isEmpty(target);
} else if (_.isObject(target) && !_.isEmpty(target) && !_.isEmpty(fieldsf)) {
return _.all(fieldsf, function(field: any) {
var valid = Utils.hasLocalizedText(target[field.path]);
if (!valid) {
err = field.mandatoryMessage;
}
return valid;
});
} else {
return true;
}
}
costs: (costs: any) => {
let cost;
const errors: any[] = [];
for (const fileType of keys(costs)) {
cost = costs[fileType];
if (!fileTypes.exists(fileType)) {
errors.push({
path: fileType,
message: 'Invalid file type. Valid file types are: ["' + fileTypes.names.join('", "') + '"].',
setting: fileType,
});
}
if (!isNumber(cost) && !isObject(cost)) {
errors.push({
path: fileType,
message: 'Cost must be an integer or object.',
setting: cost,
});
}
}
if (errors.length > 0) {
return errors;
}
},
