AJV'yi JSON doğrulamalarında kullanmak

Node.js üstünde AJV'de harici referansları olan ".json" uzantılı şemaların yüklenmesini birazcık anlatayım. Kodları test etmeden yazıyorum asıl olan temelde neyin döndüğüdür. Ana şemamız index.json ve içinde harici referans olarak test.json'ı içersin (bkz. definitons -> "TW": {"$ref": "http://localhost:3000/schema/providers/login/test.json"}

{
  "id": "http://localhost:3000/schema/providers/login/index",
  "title": "Providers",
  "$schema": "http://json-schema.org/draft-04/schema#",
  "description": "Kullanıcı Giriş Sağlayıcıları",
  "type": "object",
  "definitions": {
    "TW": {"$ref": "http://localhost:3000/schema/providers/login/test.json"}
  },
  "additionalProperties": false,
  "properties": {
    "TW": {"$ref": "#/definitions/TW"}
  }
}

test.json

{
  "id": "http://localhost:3000/schema/providers/login/test.json",
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "id": {
      "type": "integer",
      "default": 0
    },
    "id_str": {"type": "string"},
    "name": {
      "type": "string",
      "default": ""
    }
  },
  "required": [
    "id",
    "name"
  ]
}

Her iki şemanın ID'sinin, URL adresleri olduğuna dikkat! Çünkü bu sayede hem eşsizliği sağlamış olursunuz hem de bağlantılarını kopartmamış olursunuz. Ayrıca $ref kısmını definitions içinde veriyor ve properties içindeki özelliklere buradan verdiğimiz için aynı tipi başka bir yerde kullansakta bir kez http talebi yapmış olacağız (Örn. properties:{ ev_adresi:{$ref:'http:/..../adres.json'}, is_adresi:{$ref:'http:/..../adres.json'}, ..} olsaydı aynı json 2 kez çağrılmış olacaktı).

addSchema metodu

2 Parametre alıyor; ilki şemanın kendisi(json nesnesi olacak), ikincisi ise eğer şemanın içinde "id" tanımlanmamışsa kullanılması için sizin belirteceğiniz "id" değeri(string olacak).

var Ajv = require('ajv'),
    ajv = Ajv({removeAdditional:true});

function addSchema() {

    var schTest = require('./providers/login/test.json');
    var schIndex = require('./providers/login/index.json');
    ajv.addSchema(schTest);
    ajv.addSchema(schIndex);
    var bValid = ajv.validate(schIndex.id, {TW: {id: 2, a: 1, name: "cem"}});
    if (!bValid) {
        console.log("Hatalıysam ara: ");
        console.log(ajv.errors);
    }else{
        console.log("Herkül müsün kardeşim:");
        var sch2 = ajv.getSchema("http://localhost:3000/schema/providers/login/index");
        console.log(sch2.schema);
    }
}
addSchema();

compile metodu

var Ajv = require('ajv'),
    ajv = Ajv({removeAdditional:true});

function compile() {

    var schTest = require('./providers/login/test.json');
    var schIndex = require('./providers/login/index.json');
    ajv.addSchema(schTest);  // önce test şemasını ekleyelimki index.json içinde kullanılmadan önce hazır olsun
    var validate = ajv.compile(schIndex); // index.json'ı derleyerek doğrulayacak fonksiyonumuza ulaşalım.
    console.log(validate.schema) // şemamızın içinde test.json'ı referans olarak görürüz ama doğrulama sırasında bu referanslara bakarak veri nesnesini doğrulayacaktır
    var a = validate({TW: {id: 2, name: "cem"}})  // hata vermez ve başarıyla doğrulanmış olur

    if(validate.errors){
      console.log(validate.errors)
    }else{
      console.log(a);
    }
}
compile();

compileAsync metodu

Bu fonksiyonu kullanmadan önce asenkron olarak yükleme işini yapacak fonksiyonu tanımlamalısınız ve yükleme tamamlandıktan sonra doğrulama yapacak callback fonksiyonunu girmelisiniz. Bunun için AJV'nin options larından loadSchema'yı kullanacağız.

ajv = Ajv({
    loadSchema: function (uri, callback) {
        var request = require('request');
        request(uri, function (err, res, body) {
            console.log(body); // Bu gelen şemayı doğrulamaya göndermeden önce JSON'a çevirmelisiniz.

            if (err || res.statusCode >= 400)
                callback(err || new Error('Loading error: ' + res.statusCode));
            else {
                callback(null, JSON.parse(body));
            }
        });
    }
});

function compileAsync() {
    var sch = require('./providers/login/index.json');
    console.log("sch--------------");
    console.log(JSON.stringify(sch));

    ajv.compileAsync(sch, function (err, validate) {
        console.log(validate); // görelim ne var elimizde

        if (err) return; // hata varsa dön bebeğim

        var a = validate({TW:{id: 2, name: "cem"}});
        console.log(validate.errors); // null döner
        console.log(a);  // true döner(hatasız);
    });
}
compileAsync();

Tüm kod:

var Ajv = require('ajv'),
//sch = require('./index'),
    ajv = Ajv({removeAdditional: true}); // options can be passed
ajv = Ajv({
    loadSchema: function (uri, callback) {
        var request = require('request');
        request(uri, function (err, res, body) {
            console.log("request ended");
            console.log(body);

            if (err || res.statusCode >= 400)
                callback(err || new Error('Loading error: ' + res.statusCode));
            else {
                callback(null, JSON.parse(body));
            }
        });
    }
});


function compile() {

    var schTest = require('./providers/login/test.json');
    var schIndex = require('./providers/login/index.json');
    ajv.addSchema(schTest);
    var validate = ajv.compile(schIndex);
    console.log(validate.schema);
    var a = validate({TW: {id: 2, name: "cem"}});
    console.log(validate.errors);
    console.log(a);
}
//compile();

function compileAsync() {
    var sch = require('./providers/login/index.json');
    console.log("sch--------------");
    console.log(JSON.stringify(sch));

    ajv.compileAsync(sch, function (err, validate) {
        console.log(validate);
        console.log("neredeyim")
        console.log("err: " + err);
        if (err) return;

        var a = validate({id: 2, name: "cem"})
        console.log(validate.errors)
        console.log(a);

        console.log("buradayım");
    });
}
//compileAsync();

function addSchema() {

    var schTest = require('./providers/login/test.json');
    var schIndex = require('./providers/login/index.json');
    ajv.addSchema(schTest);
    ajv.addSchema(schIndex);
    var bValid = ajv.validate(schIndex.id, {a: 1,TW: {id: 2, name: "cem"}});
    if (!bValid) {
        console.log("Hatalıysam ara: ");
        console.log(ajv.errors);
    }else{
        console.log("Herkül müsün kardeşim:");
        var sch2 = ajv.getSchema("http://localhost:3000/schema/providers/login/index");
        console.log(sch2.schema);
    }
}
//addSchema();

JSON validator

Çok başarılı bir doğrulayıcı. Örneğim olsun deyyu ekliyorum:

https://github.com/mafintosh/is-my-json-valid

var trueString = {
    required: true,
    type: 'string'
},
falseString = {
    required: false,
    type: 'string'
},
trueBoolean = {
    "type": "boolean",
    required: true
},
falseBoolean = {
    type: 'boolean',
    required: true
},
trueNumber = {
    type: 'number',
    required: true
},
trueInteger = {
    type: 'integer',
    required: true
};

var boardSchema = {
    required: true,
    type: 'object',
    properties: {
        name: trueString,
        id: {
          type: 'integer',
          format: 'sadeceSifir'
      }
    }
},
 digerBoardSchema = {
    required: true,
    type: 'object',
    properties: {
        name: trueString,
        id: {
          type: 'integer',
          format: 'sadeceSifir'
      }
    }
}

var validate = validator(
                         { $ref: '#digeri' }, 
                         { 
                           schemas: { board: boardSchema, digeri: digerBoardSchema  }, 
                           formats: { sadeceSifir:/^0$/, sadece1:/^1$/ }
                         }
                        )


console.log(validate({ name: 'New board', id: 0 }));

Diğer örnek:

var validator = isMyJsonValid


var boardSchema = {
    required: true,
    type: 'object',
    properties: {
        name: {
            required: true,
            type: 'string'
        },
        id: {
            type: 'integer',
            format: 'sadece1'
        },
        columns: {
            type: 'array'
        },
        roles: {
            type: 'array'
        },
        users: {
            type: 'object',
            required: true,
            properties: {
                invitees: {
                    type: 'array'
                },
                members: {
                    type: 'array'
                }
            }
        },

    }
};

var schemaFormats = {
    schemas: {
        board: boardSchema
    },
    formats: {
        sadeceSifir: /^0$/,
        sadece1: /^1$/,
            'date-time': /^\d{4}-(?:0[0-9]{1}|1[0-2]{1})-[0-9]{2}[tT ]\d{2}:\d{2}:\d{2}(\.\d+)?([zZ]|[+-]\d{2}:\d{2})$/,
        date: /^\d{4}-(?:0[0-9]{1}|1[0-2]{1})-[0-9]{2}$/
    }
}

var validate = validator({
    $ref: '#board'
}, schemaFormats)


console.log(validate({
    name: 'New board',
    id: 1,
    users:{invitees1:[], members:[]}
}));

Node.js içinde kullanmak için yazdım

var validator = require('is-my-json-valid');


function f_validate(_obj, _schemaName) {
    var schema_member = {

        },
        schema_users = {
            type: 'object',
            required: true,
            properties: {
                invitees: {
                    type: 'array'
                },
                members: {
                    type: 'array'
                }
            }
        },
        schema_board = {
            required: true,
            type: 'object',
            properties: {
                name: {
                    required: true,
                    type: 'string'
                },
                id: {
                    type: 'integer',
                    format: 'sadece1'
                },
                columns: {
                    type: 'array'
                },
                roles: {
                    type: 'array'
                },
                users: schema_users
            }
        };

    var schemaFormats = {
        schemas: {
            board: schema_board,
            users: schema_users,
            member: schema_member
        },
        formats: {
            sadeceSifir: /^0$/,
            sadece1: /^1$/,
            'date-time': /^\d{4}-(?:0[0-9]{1}|1[0-2]{1})-[0-9]{2}[tT ]\d{2}:\d{2}:\d{2}(\.\d+)?([zZ]|[+-]\d{2}:\d{2})$/,
            date: /^\d{4}-(?:0[0-9]{1}|1[0-2]{1})-[0-9]{2}$/
        }
    }

    var validate = validator({$ref: '#' + _schemaName}, schemaFormats);

    var result = validate(_obj);
    console.log(validate.errors);

    return result;
}


module.exports = f_validate;

Bu daha iyisi:

var validator = require('is-my-json-valid');
var schema_member = {

    },
    schema_users = {
        type: 'object',
        required: true,
        properties: {
            invitees: {
                type: 'array'
            },
            members: {
                type: 'array'
            }
        }
    },
    schema_board = {
        required: true,
        type: 'object',
        properties: {
            name: {
                required: true,
                type: 'string'
            },
            id: {
                type: 'integer',
                format: 'sadece1'
            },
            columns: {
                type: 'array'
            },
            roles: {
                type: 'array'
            },
            users: schema_users
        }
    },
    schemaFormats = {
        schemas: {
            board: schema_board,
            users: schema_users,
            member: schema_member
        },
        formats: {
            sadeceSifir: /^0$/,
            sadece1: /^1$/,
            'date-time': /^\d{4}-(?:0[0-9]{1}|1[0-2]{1})-[0-9]{2}[tT ]\d{2}:\d{2}:\d{2}(\.\d+)?([zZ]|[+-]\d{2}:\d{2})$/,
            date: /^\d{4}-(?:0[0-9]{1}|1[0-2]{1})-[0-9]{2}$/
        }
    }


function f_filterAndValidate(_obj, _schemaName) {
    this.schemaName = _schemaName;
    this.obj = _obj;

    this.f_filter = function () {
        var filter = validator.filter({$ref: '#' + this.schemaName}, schemaFormats)
        return filter(this.obj);

    };

    this.f_validate = function (_filtered_object) {

        var validate = validator({$ref: '#' + this.schemaName}, schemaFormats);

        var result = validate(_filtered_object);
        console.log(validate.errors);

        return result;
    };

    return this.f_validate(this.f_filter())
}


module.exports = {
    schemas_board: 'board',
    schemas_users: 'users',
    'f_filterAndValidate': f_filterAndValidate
};

Javascript ile yeni şifre belirleme ve doğrulama

function Validatetextarea(field) {
   var valid = "ABCDEFGHIJKLMNOPRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-.";
   var temp;

   for (var i=0; i<field.length; i++) {
      temp = "" + field.substring(i, i+1);
      if  (valid.indexOf(temp) == "-1") {
         return false;
      }
   }
   return true;
} 
  
function checkForm(fp){
 if (fp.www.value != "") {
  if (Validatetextarea(fp.www.value)==false){
   alert("Lütfen Türkçe karakter kullanmayınız.");
   fp.www.focus();
   fp.www.select();
   return false;
  }
 }
 
 if (fp.password.value == "") {
  alert("Lütfen şifrenizi yazınız.");
  fp.password.focus();
  return false;
 }

 if (fp.password.value != fp.Repassword.value) {
  alert("Girdiğiniz iki şifre bir birinden farklı");
  fp.Repassword.focus();
  return false;
 }


 fp.ok.disabled=true;
 fp.ok.value='İşlem Yapılıyor...'
}