281 lines
5.2 KiB
JavaScript
281 lines
5.2 KiB
JavaScript
HTMLElement.prototype.isChildOf = function(parent){
|
|
var node = this.parentNode;
|
|
while (node != null) {
|
|
if (node == parent) {
|
|
return true;
|
|
}
|
|
node = node.parentNode;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
class SerializerField {
|
|
/**
|
|
* constructor
|
|
*
|
|
* @param {HTMLElement} f Input field (input|select|textarea)
|
|
* @returns {SerializerField}
|
|
*/
|
|
constructor(f){
|
|
this.name;
|
|
this.parent;
|
|
this.field = f;
|
|
this.required = f.required
|
|
this.type = this.field.getAttribute("type");
|
|
}
|
|
|
|
/**
|
|
* serialize
|
|
*
|
|
* @returns {(String|Number|Boolean|Date)}
|
|
*/
|
|
serialize(){
|
|
if(this.type == "number" || this.type == "range"){
|
|
return Number(this.field.value);
|
|
} else if(this.type == "date" || this.type == "datetime-local" || this.type == "month" || this.type == "week") {
|
|
return new Date(this.field.value);
|
|
} else if(this.type == "checkbox") {
|
|
let checked = this.field.checked;
|
|
if(this.field.hasAttribute("string")){
|
|
if(checked) {
|
|
return this.field.value
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
return checked;
|
|
} else {
|
|
return this.field.value;
|
|
}
|
|
}
|
|
}
|
|
|
|
class Serializer {
|
|
/**
|
|
* constructor
|
|
*
|
|
* @param {HTMLElement} element
|
|
* @returns {Serializer}
|
|
*/
|
|
constructor(element){
|
|
let fields = element.querySelectorAll(`:scope input:not([type="submit"]), :scope select, :scope textarea, :scope group`);
|
|
let groups = [].slice.call(element.querySelectorAll(`:scope group`));
|
|
|
|
this.name = ":root";
|
|
this.parent;
|
|
this._fields = new Map();
|
|
this.min = Number(element.getAttribute("min") || -1);
|
|
|
|
this.required = element.getAttribute("required") !== null || this.min != -1;
|
|
|
|
for(let f of fields){
|
|
if(f.isChildOf(element) && groups.every(g => !f.isChildOf(g))){
|
|
this.addField(f);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* addField
|
|
*
|
|
* @param {HTMLElement} f
|
|
*/
|
|
addField(f){
|
|
let fieldName = f.getAttribute("name");
|
|
let isArray = fieldName.match(/^\[(\d*)\]/)
|
|
|
|
fieldName = fieldName.replace(/^\[\d*\]/, '');
|
|
|
|
let field;
|
|
if(f.tagName == "GROUP"){
|
|
field = new Serializer(f)
|
|
} else {
|
|
field = new SerializerField(f);
|
|
}
|
|
|
|
if(field.type == "file"){
|
|
return;
|
|
}
|
|
|
|
field.name = fieldName;
|
|
field.parent = this;
|
|
|
|
f.serializer = field
|
|
|
|
if(isArray){
|
|
if(!this._fields.has(fieldName)){
|
|
this._fields.set(fieldName, [])
|
|
}
|
|
if(isArray[1] != ""){
|
|
this._fields.get(fieldName)[isArray[1]] = field
|
|
} else {
|
|
this._fields.get(fieldName).push(field)
|
|
}
|
|
} else {
|
|
this._fields.set(fieldName, field)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* removeField
|
|
*
|
|
* @param {(HTMLElement|Serializer|SerializerField)} f Serializer child
|
|
*/
|
|
removeField(f){
|
|
if(this._fields.has(f.name)){
|
|
let fields = this._fields.get(f.name)
|
|
if(Array.isArray(fields)){
|
|
let index = fields.indexOf(f);
|
|
this._fields.set(f.name, fields.splice(index, 1))
|
|
} else {
|
|
this._fields.delete();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* serialize
|
|
*
|
|
* @returns {Object}
|
|
*/
|
|
serialize(){
|
|
let json = {};
|
|
for(let [k, f] of this._fields){
|
|
if(Array.isArray(f)){
|
|
if(k != ""){
|
|
json[k] = [];
|
|
} else {
|
|
json = [];
|
|
}
|
|
for(let key in f){
|
|
if(f[key]){
|
|
let d = f[key].serialize();
|
|
if(d !== null){
|
|
if(k == ""){
|
|
json[key] = d;
|
|
continue;
|
|
}
|
|
json[k][key] = d;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
let d = f.serialize();
|
|
if(f !== null){
|
|
if(k == ""){
|
|
json = d
|
|
continue;
|
|
}
|
|
json[k] = d
|
|
}
|
|
}
|
|
}
|
|
return json;
|
|
}
|
|
}
|
|
|
|
class Validator {
|
|
/**
|
|
* validateRequired
|
|
*
|
|
* @static
|
|
* @param {(erializer|SerializerField)} field
|
|
* @returns {Object}
|
|
*/
|
|
static validateRequired(field){
|
|
let e = {
|
|
valid: true,
|
|
errors: {},
|
|
}
|
|
let v;
|
|
if(field instanceof Serializer){
|
|
v = Validator.validateRequiredSerializer(field);
|
|
} else {
|
|
v = Validator.validateRequiredSerialzerField(field)
|
|
}
|
|
if(!v.valid){
|
|
e.valid = false;
|
|
e.errors = v.errors;
|
|
}
|
|
return e;
|
|
}
|
|
|
|
/**
|
|
* validateRequiredSerializer
|
|
*
|
|
* @static
|
|
* @param {Serializer} field
|
|
* @returns {Object}
|
|
*/
|
|
static validateRequiredSerializer(field){
|
|
let e = {
|
|
valid: true,
|
|
errors: {},
|
|
}
|
|
|
|
let min = field.min;
|
|
let validFieldsCount = 0;
|
|
for(let [k, f] of field._fields){
|
|
if(Array.isArray(f)){
|
|
e.errors = {
|
|
message: null,
|
|
};
|
|
let validCount = 0;
|
|
for(let sf of f){
|
|
if(!(sf.name in e.errors)){
|
|
e.errors[sf.name] = [];
|
|
}
|
|
|
|
let v = Validator.validateRequired(sf)
|
|
if(!v.valid){
|
|
console.log(e.errors)
|
|
e.errors[sf.name].push(v.errors);
|
|
continue;
|
|
}
|
|
validCount++
|
|
}
|
|
|
|
e.valid = min <= validCount
|
|
if(e.valid){
|
|
e.errors = {}
|
|
} else {
|
|
e.errors.message = `Should contain atleast ${min} value(s)`
|
|
}
|
|
} else {
|
|
let v = Validator.validateRequired(f);
|
|
if(!v.valid){
|
|
e.valid = false;
|
|
e.errors[f.name] = v.errors;
|
|
}
|
|
}
|
|
}
|
|
|
|
return e;
|
|
}
|
|
|
|
/**
|
|
* validateRequiredSerialzerField
|
|
*
|
|
* @static
|
|
* @param {SerializerField} field
|
|
* @returns {Object}
|
|
*/
|
|
static validateRequiredSerialzerField(field){
|
|
let e = {
|
|
valid: true,
|
|
errors: {},
|
|
}
|
|
|
|
if(field.required || (field.parent && field.parent.required)){
|
|
if(field.type != "checkbox"){
|
|
e.valid = field.field.validity.valueMissing !== true
|
|
e.errors = "Is required"
|
|
} else {
|
|
e.valid = field.field.checked
|
|
e.errors = "Not checked"
|
|
}
|
|
}
|
|
return e;
|
|
}
|
|
}
|