dausdaskreuz/mcf-objects
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Add minor fixes

Browse source
This commit is contained in:
dgarcia 2020-10-19 18:02:44 +02:00
parent e4ab9caf94
commit 19554d6848
4 changed files with 76 additions and 70 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
.eslintrc.js
View file

@ -49,4 +49,4 @@ module.exports = {
'ignoreReadBeforeAssign': true,
}],
},
};
}

2
dist/mcf-objects.js vendored
View file

File diff suppressed because one or more lines are too long

2
dist/mcf-objects.js.map vendored
View file

File diff suppressed because one or more lines are too long

128
src/index.js
View file

@ -2,52 +2,52 @@
// ========================================
class MCF_Type {
constructor(definition){
constructor(definition) {
this.definition = definition;
this.validations = {};
}
setValue(value){
setValue(value) {
this.validate(value);
this.value = value;
}
getValue(){
getValue() {
return this.value;
}
validate(value){
for (let validation in this.validations){
validate(value) {
for (let validation in this.validations) {
this.validations[validation](value, this.definition);
}
}
}
class MCF_String extends MCF_Type {
constructor(definition){
constructor(definition) {
super(definition);
this.addValidations();
}
addValidations(){
addValidations() {
this.validations.type = function(value) {
if (typeof (value) !== "string") {
if (typeof(value) !== "string") {
throw new Error(`MCF_String creation: the type of ${value} isn't "string"`);
}
};
for (let param in this.definition){
for (let param in this.definition) {
switch (param) {
case 'maxLength':
this.validations.maxLength = function(value, definition){
if (value.length > definition.maxLength){
this.validations.maxLength = function(value, definition) {
if (value.length > definition.maxLength) {
throw new Error(`MCF_String creation: the length of the string "${value}" is higher than the maximum defined: ${definition.maxLength}`);
}
};
break;
case 'minLength':
this.validations.minLength = function(value, definition){
if (value.length < definition.minLength){
this.validations.minLength = function(value, definition) {
if (value.length < definition.minLength) {
throw new Error(`MCF_String creation: the length of the string "${value}" is lower than the minimum defined: ${definition.minLength}`);
}
};
@ -56,31 +56,31 @@ class MCF_String extends MCF_Type {
}
}
}
class MCF_Number extends MCF_Type{
constructor(definition){
class MCF_Number extends MCF_Type {
constructor(definition) {
super(definition);
this.addValidations();
}
addValidations(){
addValidations() {
this.validations.type = function(value) {
if (typeof (value) !== "number") {
if (typeof(value) !== "number") {
throw new Error(`MCF_Number creation: the type of the value ${value} isn't "number"`);
}
};
for (let param in this.definition){
for (let param in this.definition) {
switch (param) {
case 'max':
this.validations.max = function(value, definition){
if (value > definition.max){
this.validations.max = function(value, definition) {
if (value > definition.max) {
throw new Error(`MCF_Number creation: the value ${value} is higher than the maximum defined: ${definition.max}`);
}
};
break;
case 'min':
this.validations.min = function(value, definition){
if (value < definition.min){
this.validations.min = function(value, definition) {
if (value < definition.min) {
throw new Error(`MCF_Number creation: the value ${value} is lower than the minimum defined: ${definition.min}`);
}
};
@ -89,45 +89,45 @@ class MCF_Number extends MCF_Type{
}
}
}
class MCF_Boolean extends MCF_Type{
constructor(definition){
class MCF_Boolean extends MCF_Type {
constructor(definition) {
super(definition);
this.addValidations();
}
addValidations(){
addValidations() {
this.validations.type = function(value) {
if (typeof (value) !== "boolean") {
if (typeof(value) !== "boolean") {
throw new Error(`MCF_Boolean creation: the type of the value ${value} isn't "boolean"`);
}
};
}
}
class MCF_Array extends MCF_Type {
constructor(definition){
constructor(definition) {
super(definition);
this.addValidations();
}
addValidations(){
addValidations() {
this.validations.type = function(value) {
if (!Array.isArray(value)) {
throw new Error(`MCF_Array creation: the type of ${value} isn't "array"`);
}
};
for (let param in this.definition){
for (let param in this.definition) {
switch (param) {
case 'maxLength':
this.validations.maxLength = function(value, definition){
if (value.length > definition.maxLength){
this.validations.maxLength = function(value, definition) {
if (value.length > definition.maxLength) {
throw new Error(`MCF_Array creation: the length of the array "${value}" is higher than the maximum defined: ${definition.maxLength}`);
}
};
break;
case 'minLength':
this.validations.minLength = function(value, definition){
if (value.length < definition.minLength){
this.validations.minLength = function(value, definition) {
if (value.length < definition.minLength) {
throw new Error(`MCF_Array creation: the length of the array "${value}" is lower than the minimum defined: ${definition.minLength}`);
}
};
@ -136,19 +136,19 @@ class MCF_Array extends MCF_Type {
}
}
}
class MCF_Enum extends MCF_Type{
constructor(definition){
class MCF_Enum extends MCF_Type {
constructor(definition) {
super(definition);
this.addValidations();
}
addValidations(){
this.validations.isAvailable = function(value, definition){
const valueIsAvailable = definition.availableValues.reduce(function(isAvailable, availableValue){
addValidations() {
this.validations.isAvailable = function(value, definition) {
const valueIsAvailable = definition.availableValues.reduce(function(isAvailable, availableValue) {
if (value === availableValue) return true;
return isAvailable;
}, false);
if (!valueIsAvailable){
if (!valueIsAvailable) {
throw new Error(`MCF_Enum creation: the value "${value}" isn't one of the next values, included in the field definition: ${definition.availableValues.toString()}`);
}
}
@ -182,68 +182,74 @@ class MCF_TypeFactory {
}
}
class MCF_DefinedObject {
constructor(definition){
constructor(definition) {
this.definition = definition;
this.validations = {};
this.fields = MCF_TypeFactory.buildDefinedObject(this);
this.validateValue(definition.value)
this.setValue(definition.value)
}
getDefinition(){
getDefinition() {
return this.definition;
}
getValue(){
getValue() {
let value = {};
for (let field in this.fields){
for (let field in this.fields) {
value[field] = this.fields[field].value;
}
return value;
}
setValue(value){
for (let field in this.definition.fields){
if (value[field] === undefined || value === null){
if (this.definition.fields[field].required === true){
validateValue(value){
for (let field in this.definition.fields) {
if (value[field] === undefined || value === null) {
if (this.definition.fields[field].required === true) {
throw new Error(`The field ${field} is required`);
}
if (this.definition.fields[field].defaultValue !== undefined){
if (this.definition.fields[field].defaultValue !== undefined) {
value[field] = this.definition.fields[field].defaultValue;
}
if (this.definition.fields[field].null === false){
if (this.definition.fields[field].null === false) {
throw new Error(`The field ${field} can't be undefined`);
}
}
}
}
for (let field in value){
if (value[field] === undefined){
this.fields[field].value = undefined;
setValue(value) {
for (let valueKey in value) {
if (value[valueKey] === undefined) {
this.fields[valueKey].value = undefined;
} else {
this.fields[field].setValue(value[field]);
this.fields[valueKey].setValue(value[valueKey]);
}
}
}
setPropertiesValue(value){
for (let field in value){
setPropertiesValue(value) {
for (let field in value) {
this.fields[field].setValue(value[field]);
}
}
}
const fileDefinition = {
filename: {TYPE: 'string', required: true},
extension: {TYPE: 'string', required: true},
path: {TYPE: 'string', required: true},
content: {TYPE: 'string'},
filename: { TYPE: 'string' },
extension: { TYPE: 'string' },
mimeType: { TYPE: 'string' },
path: { TYPE: 'string' },
content: { TYPE: 'string' },
}
class MCF_File extends MCF_DefinedObject {
constructor(params) {
const fields = (params.fields) ? params.fields : {}
const value = (params.value) ? params.value : params
super({
fields: fileDefinition,
value: params,
fields: {...fileDefinition, ...fields},
value: value,
})
}
}