Form serileştirme

Form içerisinde n tane element olan bir yapı. Form içinde topladığınız bilgileri sunucuya taşıyabilmek için HTTP paketleri kullanıyoruz. Buraya kadar hepimiz biliyoruz ;)

Bu paket başlık ve gövdeden oluşuyor ve aralarında sadece boş bir satır var. Genelde verileri gövde kısmına yükleriz. Sunucunun bu verileri parçalara ayırabilmesi(parse edebilmesi) gerekiyor. Bunu yapsın diye gövdeye yazacağımız bilgiyi iki tarafında (istemci ve sunucu) anlayabileceği şekilde oluşturmamız gerekiyor ki buna mesajın biçimi(formatı) diyoruz.
Mesaj formatlarımız neler:

• XML
• JSON
• x-www-form-urlencoded
• SOAP
• multipart/form-data

application/x-www-form-urlencoded yapılan talebe text/html tipinde aldığımız cevap:

Encode ve Decode terimleri hep oldu hep olacak çünkü biz harf yazıyoruz ve bunu bilgisayara manyetik değer olarak kaydediyoruz. Ben bilgiyi dairesel ve çizgisel karakterler olarak ekranda görünecek şekilde kaydediyorum bir başkası video da havanın bükülerek ses dalgaları haline getirerek aktarıyor. Demek ki biz mesajları sürekli encode ediyoruz ve o mesajları okurken, dinlerken decode ediyoruz.

isim="Cem Topkaya" verisini internet ortamında transfer etmek için url'nin sonuna eklediğimizi düşünelim http://cemtopkaya.com/kullanici.php?isim=Cem Topkaya siz de farkettinizki soyisim bir boşlukla ayrıldığı için url'nin parçası olamıyor.

JSON Schema da null olabilen boolean alan (nullable boolean property)

Şema:

{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "id": "http://jsonschema.net",
  "type": "object",
  "properties": {
    "c": {
      "anyOf": [
        {
          "type": "boolean"
        },
        {
          "type": "null"
        }
      ]
    }
  }
}

{c: null}

json-schema-defaults ile node.js üstünde .json uzantılı şemaları dinamik yüklemek

Tüm kodunu en aşağıya yapıştırdım ama ekelediğim yeri biraz anlatmış olayım:

var getRemoteRef = function (_uri, definitions) {
// loadschema ileride async olarak şema yüklemelerini sağlamak için kullanacağım için şimdiden hazır edeyim dedim.
    var 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));
            }
        });
    };

    // node uygulamasının hangi fiziksel klasörde olduğunu buluyorum
    var appRoot = require('app-root-path'),
        // dosya yolunun schema'lı halini oluşturuyorum
        indexOfSchema = _uri.indexOf('/schema/');

    // .json dosyasının tam yolunu bulduktan sonra 
    var filePath = appRoot + "/node/" + _uri.substr(indexOfSchema);
    console.log("Path: " + filePath);

    // reuqire ile çekiyoruz
    var result = require(filePath);

    if (!isObject(result)) {
        return result;
    }
    return cloneJSON(result);
}

(function (root, factory) {

    'use strict';

    if (typeof require === 'function' && typeof exports === 'object' && typeof module === 'object') {
        // CommonJS
        module.exports = factory();
    } else if (typeof define === 'function' && define.amd) {
        // AMD
        define('json-schema-defaults', [], function () {
            return factory();
        });
    } else {
        // global with noConflict
        var jsonSchemaDefaults = root.jsonSchemaDefaults;
        root.jsonSchemaDefaults = factory();
        root.jsonSchemaDefaults.noConflict = function () {
            var defaults = root.jsonSchemaDefaults;
            root.jsonSchemaDefaults = jsonSchemaDefaults;
            return defaults;
        };
    }

}(this, function () {

    'use strict';

    var ajv = null;

    /**
     * check whether item is plain object
     * @param {*} item
     * @return {Boolean}
     */
    var isObject = function (item) {
        return typeof item === 'object' && item !== null && item.toString() === {}.toString();
    };

    /**
     * deep JSON object clone
     *
     * @param {Object} source
     * @return {Object}
     */
    var cloneJSON = function (source) {
        return JSON.parse(JSON.stringify(source));
    };

    /**
     * returns a result of deep merge of two objects
     *
     * @param {Object} target
     * @param {Object} source
     * @return {Object}
     */
    var merge = function (target, source) {
        target = cloneJSON(target);

        for (var key in source) {
            if (source.hasOwnProperty(key)) {
                if (isObject(target[key]) && isObject(source[key])) {
                    target[key] = merge(target[key], source[key]);
                } else {
                    target[key] = source[key];
                }
            }
        }
        return target;
    };

    /**
     * merge list of objects from allOf properties
     * if some of objects contains $ref field extracts this reference and merge it
     *
     * @param {Array} allOfList
     * @param {Object} definitions
     * @return {Object}
     */
    var mergeAllOf = function (allOfList, definitions) {
        var length = allOfList.length,
            index = -1,
            result = {};

        while (++index < length) {
            var item = allOfList[index];

            item = (typeof item.$ref !== 'undefined') ? getLocalRef(item.$ref, definitions) : item;

            result = merge(result, item);
        }

        return result;
    };

    /**
     * get object by reference. works only with local references that points on
     * definitions object
     *
     * @param {String} path
     * @param {Object} definitions
     * @return {Object}
     */
    var getLocalRef = function (path, definitions) {
        path = path.replace(/^#\/definitions\//, '').split('/');

        var find = function (path, root) {
            var key = path.shift();
            if (!root[key]) {
                return {};
            } else if (!path.length) {
                return root[key];
            } else {
                return find(path, root[key]);
            }
        };

        var result = find(path, definitions);

        if (!isObject(result)) {
            return result;
        }
        return cloneJSON(result);
    };


    var getRemoteRef = function (_uri, definitions) {
        var 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));
                }
            });
        };

        var Path = require('path'),
            appRoot = require('app-root-path'),
            indexOfSchema = _uri.indexOf('/schema/');

        var filePath = appRoot + "/node/" + _uri.substr(indexOfSchema);
        console.log("Path: " + filePath);
        var result = require(filePath);
        if (!isObject(result)) {
            return result;
        }
        return cloneJSON(result);
    }


    /**
     * returns a object that built with default values from json schema
     *
     * @param {Object} schema
     * @param {Object} definitions
     * @return {Object}
     */
    var defaults = function (schema, definitions) {
        console.log("schema: " + JSON.stringify(schema, null, ' '));
        console.log("definitions: " + JSON.stringify(definitions));
        if (typeof schema['default'] !== 'undefined') {

            return schema['default'];

        }
        else if (typeof schema.allOf !== 'undefined') {

            var mergedItem = mergeAllOf(schema.allOf, definitions);
            console.log("MergedItem: " + JSON.stringify(mergedItem));
            return defaults(mergedItem, definitions);

        }
        else if (typeof schema.$ref !== 'undefined') {
            console.log("Reference name: " + schema.$ref);
            var reference;
            if (schema.$ref.indexOf("http") == 0) {
                reference = getRemoteRef(schema.$ref, definitions);
                //reference= getRemoteRef("http://localhost:3000/schema/providers/login/test.json", definitions);
            } else {
                reference = getLocalRef(schema.$ref, definitions);
            }

            console.log("Refernce: " + JSON.stringify(reference));
            return defaults(reference, definitions);

        }
        else if (schema.type === 'object') {

            if (!schema.properties) {
                return {};
            }

            for (var key in schema.properties) {
                if (schema.properties.hasOwnProperty(key)) {
                    schema.properties[key] = defaults(schema.properties[key], definitions);

                    if (typeof schema.properties[key] === 'undefined') {
                        delete schema.properties[key];
                    }
                }
            }

            return schema.properties;

        }
        else if (schema.type === 'array') {

            if (!schema.items) {
                return [];
            }
            return [defaults(schema.items, definitions)];

        }
        else if (schema.type && typeof(schema.type) === 'object') {

            console.log("Reference name: " + schema.type.$ref);
            var reference = getLocalRef(schema.$ref, definitions);
            console.log("Refernce: " + JSON.stringify(reference));
            return defaults(reference, definitions);

            if (!schema.items) {
                return [];
            }
            return [defaults(schema.items, definitions)];

        }

    };

    /**
     * main function
     *
     * @param {Object} schema
     * @param {Object|undefined} definitions
     * @return {Object}
     */
    return function (schema, definitions, _ajv) {
        ajv = _ajv;

        if (definitions && Array.isArray(definitions)) {
            var defs = {};
            definitions.forEach(function (_definition) {
                defs = merge(_definition, schema.definitions);
            });
            definitions = defs;
        }

        if (typeof definitions === 'undefined') {
            definitions = schema.definitions || {};
        }
        else if (isObject(schema.definitions)) {
            definitions = merge(definitions, schema.definitions);
        }

        return defaults(cloneJSON(schema), definitions);
    };

}));

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 Schema ile nesnelerinizi doğrulama ya da şemaya uygun başlangıç nesneleri tanımlama

Şimdilik zaman azlığı çektiğimden anahtar kelimeler ve biraz kod parçası atacağım.
NPM Kütüphaneleri:

1. json-schema-defaults
2. is-my-json-valid

Şablon olması için kullanabilirsiniz Webstorm içinde:

module.exports = {
    "$schema": "http://json-schema.org/draft-04/schema#",
    name: "BenimSchemaM",
    description:"Örnek şema olsun diye az açıklamalı olarak yazabildim.Daha ilişki yönetimleri vardı :(",
    definitions: {},
    type: "object",     // şemanın doğrulayacağı ya da şemadan oluşturulacak nesnenin tipi. string, object, array...
    required: [],       // string dizisi. Olması mecburi property isimlerini içerir

    additionalProperties: false,    // Şemada tanımlı olmayan ama şemaya uygun olduğunu iddia eden nesnenin fazladan propertysine müsade et/me

    properties: {
        Id: {type: "number", default: 0},
        WebAdresi: {type: "string", format: "url"},
        dizi: {
            type: "array",              // dizi property sinin tipi ARRAY olacak ve
            items: {type: "string"}     // içindeki her eleman string tipinde olacak
        }
    }
};

Miras Alma(Inheritance) ya da Genişletme(Extend)

Bir esas bir de onu miras alacak şemamız olsun.

module.exports = {
    name: "Kullanıcı",
    description: "Session içinde kullanılacak kullanıcı",
    type: "object",
    definitions: {
        Providers: require('../providers/login')
    },
    required: ["Id", "Providers"],
    properties: {
        Id: {type: "integer", default: 0},
        AdiSoyadi: {type: "string"},
        EPosta: {type: "string", format: "email"},
        Sifre: {type: "string"},
        Providers: {$ref: "#/definitions/Providers", default: {}}
    },
    additionalProperties: true
};

Miras alarak yeni bir şema oluşturalım:

var tahtaRolu = {

    $schema: "http://json-schema.org/draft-04/schema#",
    description: "Tahtanın rollerini içerir >  HS > tahta:401:rol : Tahtanın rolleri > 1 | {adi:'Sahip', Yetkileri:['Ihale Girişi','Ihaleye Katılım', 'Teklif Girişi'] }",
    type: "object",
    required: ["Id", "Adi", "Yetki"],
    definitions: {
        Kullanici: require('../ortak/kullanici'),
        Rol: require('./tahtaRolu')
    },
    allOf: [
        {$ref: "#/definitions/Kullanici"},
        {
            properties: {
                Rol: {$ref: "#/definitions/Rol"}
            }
        }
    ],
    additionalProperties: false
};

module.exports = tahtaRolu;

Sonuç:

POSTMAN ile ajax talebinde bulunalım

Aşağıda chrome ile yakalanmış bir ajax talebi var:

Bu talebin aynısını POSTMAN içinde oluşturalım ama önce gereksiz ayrıntıları kaldırarak:

Şimdi Chrome'da yakaladığımız talebin detaylısını oluşturalım:

Talebin içeriğine baktığınızda JSON tipinde olduğunu görüyorsunuz. Bunu sunucuya da söylemeliyizki HTTP talebinin gövdesini ona göre parçalasın. HTTP Talebimizin JSON formatında olduğunu Content-Type: application/json, charset=UTF-8 ile belirtiyoruz.

Bu kez tüm talebimizin HTTP paketinde nasıl olduğuna bakalım. Bir başlık(header) bir de gövdemiz(body) var. Gövdeye JSON tipinde verimizi yazıyoruz. Başlıkta da bir çok bilgiyle talebimizi yapıyoruz:

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
};

POSTGRESQL ile JSON alanlarda veri tutma aşkım alevlendi

Beklediğim PostgreSQL, JSON verilerini tutabilecek şekilde nihayet sürüm olarak yapıldı ve ben de üzerime düşeni yapmak üzere kuruluma başlıyorum. Amacım EAV modeliyle projemizi yazarak ve umarak okuduğum onlarca makaledeki performans sorunlarını yaşamamayı, çok sevgili şirketimiz için yine yeni bir projeye hayat vermek.
Önce zip halinde indirmek üzere aşağıdaki bu adrese gidilir:

Zipimiz açılır ve aşağıdaki şekilde klasör yapısına getirilir:

Data klasöründe veri dosyalarını, Log da ise çorba tariflerini tutacağımızdan bu iki klasörü oluşturduk ve zipin içinden çıkanları yapıştırdık POSTGRESQL_ROOT klasörümüze.

İlk başlatmak için:

C:\POSTGRESQL_ROOT\bin>initdb -U postgress -A password -E utf8 -W -D c:\POSTGRESQL_ROOT\data

yazıp entırladığımızda bize şifre soracağı ana kadar veritabanı ayarlarını yaparak ilerler

The files belonging to this database system will be owned by user "cem".
This user must also own the server process.

The database cluster will be initialized with locale "Turkish_Turkey.1254".
The default text search configuration will be set to "turkish".

Data page checksums are disabled.

fixing permissions on existing directory c:/POSTGRESQL_ROOT/data ... ok
creating subdirectories ... ok
selecting default max_connections ... 100
selecting default shared_buffers ... 128MB
creating configuration files ... ok
creating template1 database in c:/POSTGRESQL_ROOT/data/base/1 ... ok
initializing pg_authid ... ok
Enter new superuser password:
Enter it again:

Sonrasında yine işleme devam ederek:

setting password ... ok
initializing dependencies ... ok
creating system views ... ok
loading system objects' descriptions ... ok
creating collations ... not supported on this platform
creating conversions ... ok
creating dictionaries ... ok
setting privileges on built-in objects ... ok
creating information schema ... ok
loading PL/pgSQL server-side language ... ok
vacuuming database template1 ... ok
copying template1 to template0 ... ok
copying template1 to postgres ... ok
syncing data to disk ... ok

Success. You can now start the database server using:

    "postgres" -D "c:\POSTGRESQL_ROOT\data"
or
    "pg_ctl" -D "c:\POSTGRESQL_ROOT\data" -l logfile start

ilk başlatma işini tamamlar.

Bana düşen artık C:\POSTGRESQL_ROOT\bin>"postgres" -D "c:\POSTGRESQL_ROOT\data" komutuyla PostgreSQL sunucumu başlatmak:

Ve artık sunucumuz çalıştığına göre PostgreSQL Admin ile bağlanalım:

Serileştirme, Serialization, C#

Temel olarak serileştirme aşağıdaki kod ile anlaşılabilir ancak birazcık daha detaylı bilgi için biraz daha aşağıdaki kod yardımcı olacaktır.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;
using Newtonsoft.Json;

namespace ConsoleApplication1
{
    [Serializable]
    public class Ornek
    {
        public string Adi { get; set; }

        public void calis()
        {
        }
    }

    class Program
    {
        public static Ornek o = new Ornek() { Adi = "cem" };
        private static void Main(string[] args)
        {
            json();
        }


        public static void json()
        {
            string json = JsonConvert.SerializeObject(o);
            Console.WriteLine(json);
        }

        public static void binary()
        {
            BinaryFormatter formatter = new BinaryFormatter();
            FileStream stream = File.Create("c:\\temp\\test.txt");
            Console.WriteLine("Serializing vector");
            formatter.Serialize(stream, o);
            stream.Close();

        }

        public static void xml(){
            XmlSerializer x = new XmlSerializer(o.GetType());
            x.Serialize(Console.Out, o);
        }
    }
}


/* ÇIKTILARIMIZ:
 * XML
 
 <?xml version="1.0" encoding="ibm857"?>
<Ornek xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://w
ww.w3.org/2001/XMLSchema">
  <Adi>cem</Adi>
</Ornek>
 
 * 
 * BINARY
 
      ÿÿÿÿ             JConsoleApplication1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null      ConsoleApplication1.Ornek     <Adi>k__BackingField           cem 
 * 
 * JSON
 
 {"Adi":"cem"}
 */

---

Kodumuz şöyle olacak:

using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Formatters.Soap;
using System.Xml.Serialization;

namespace ConsoleApplication7
{
    [Serializable]
    public class Basit
    {
        public char c = 'a';
        public byte b = (byte)'a';
        private char privateAmaBinaryFormatterSerilestirir_SoapFormatterSerilestirmez = (char)65;

        [XmlElement(DataType = "string", ElementName="ADI")] // XSD tanımlamaları
        public string Adi = "isimsiz";

        [NonSerialized] // BinaryFormatter private'a bakmaksızın serileştirdiği için [NonSerialized] ile işaretliyoruzki, serileştirmesin
        private byte NonSerialized_isaretli_BinaryFormatter_Serilestirmez = 1;
    }

    public class Example
    {
        public static void Main()
        {
            var b = BinaryFormatla_seri_deseri_lestir();
            var s = SoapFormatla_seri_deseri_lestir();
            var x = XML_seri_deseri_lestir();
            /*
             * Binary Serialization
             * Serialization can be defined as the process of storing the state of an object to a storage medium. 
             * During this process, 
             *   the public and private fields of the object 
             *   and the name of the class, 
             *   including the assembly containing the class, 
             * are converted to a stream of bytes, which is then written to a data stream. 
             * When the object is subsequently deserialized, an exact clone of the original object is created.
             * When implementing a serialization mechanism in an object-oriented environment, you have to make a number of tradeoffs between ease of use and flexibility. 
             * The process can be automated to a large extent, provided you are given sufficient control over the process. 
             */

            /*
             * XML and SOAP Serialization
             * XML serialization converts (serializes) the public fields and properties of an object, 
             * or the parameters and return values of methods, 
             * into an XML stream that conforms to a specific XML Schema definition language (XSD) document. 
             * XML serialization results in strongly typed classes with public properties and fields that are converted to a serial format (in this case, XML) for storage or transport.
             */
        }

        private static Basit XML_seri_deseri_lestir()
        {
            Type t = Type.GetType("ConsoleApplication7.Basit");
            XmlSerializer ser = new XmlSerializer(t);
            FileStream fs = new FileStream("XmlSer.xml",FileMode.OpenOrCreate);
            ser.Serialize(fs,new Basit());
            fs.Close();

            Basit x = (Basit) ser.Deserialize(new FileStream("XmlSer.xml", FileMode.Open));
            return x;
        }

        private static Basit SoapFormatla_seri_deseri_lestir()
        {
            SoapFormatter soapFmt = new SoapFormatter();
            FileStream fs = new FileStream("basit.xml", FileMode.OpenOrCreate);
            soapFmt.Serialize(fs, new Basit());
            fs.Close();

            FileStream fs1 = new FileStream("basit.xml", FileMode.Open);
            Basit s = (Basit)soapFmt.Deserialize(fs1);
            return s;
        }

        private static Basit BinaryFormatla_seri_deseri_lestir()
        {
            BinaryFormatter binaryFmt = new BinaryFormatter();
            FileStream fs = new FileStream("basit.bin", FileMode.OpenOrCreate);
            binaryFmt.Serialize(fs, new Basit());
            fs.Close();

            FileStream fs1 = new FileStream("basit.bin", FileMode.Open);
            Basit b = (Basit)binaryFmt.Deserialize(fs1);
            return b;
        }
    }
}

ve çıktılardan önce dönen değişkenler şöyle:

Dosyalardaki çıktılar ise: BINARY Formatlı Çıktının HEX Görünümü:

SOAP XML Çıktısı:

<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:clr="http://schemas.microsoft.com/soap/encoding/clr/1.0" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<SOAP-ENV:Body>
<a1:Basit id="ref-1" xmlns:a1="http://schemas.microsoft.com/clr/nsassem/ConsoleApplication7/ConsoleApplication7%2C%20Version%3D1.0.0.0%2C%20Culture%3Dneutral%2C%20PublicKeyToken%3Dnull">
<c>a</c>
<b>97</b>
<privateAmaBinaryFormatterSerilestirir_SoapFormatterSerilestirmez>A</privateAmaBinaryFormatterSerilestirir_SoapFormatterSerilestirmez>
<Adi id="ref-3">isimsiz</Adi>
</a1:Basit>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>

XML Çıktısı:

<?xml version="1.0"?>
<Basit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <c>97</c>
  <b>97</b>
  <ADI>isimsiz</ADI>
</Basit>

Javascript'de dizi oluşturma

<html>
<head>
</head>
<body>
    <script type="text/javascript">
      
      function Person(_adi,_soyadi){
       this.Adi = "";
       this.Soyadi = "";
               
       this.Set = function(_adi,_soyadi){
        this.Adi = _adi;
        this.Soyadi = _soyadi; 
       }
       
       if(_adi===undefined) {
        this.Set("Cem","Topkaya"); 
       }else{
        this.Set(_adi,_soyadi);
       }
      }
    </script>
    <div> BOŞLUK </div>
</body>
</html>


var cenk = new Person("Cenk","Topkaya");
var dizi = [{"_adi":"Cenk","_soyadi":"Topkaya"},{"_adi":"Cem","_soyadi":"Topkaya"}];
console.log(dizi.length);
console.debug(dizi);

var dizi2 = [eval(new Person("Cenk","Topkaya")),eval(new Person("Cem","Topkaya"))];
console.debug(dizi2);

var dizi3 = [new Person("Cenk","Topkaya"),new Person("Cem","Topkaya")];
console.debug(dizi3);

JSON formatında Microsoft'un culturInfo javascript değişkeni

var __cultureInfo = 
'{"name":"tr-TR",
"numberFormat":
	{
	"CurrencyDecimalDigits":2,
	"CurrencyDecimalSeparator":","
	,"IsReadOnly":true,
	"CurrencyGroupSizes":[3],
	"NumberGroupSizes":[3],
	"PercentGroupSizes":[3],
	"CurrencyGroupSeparator":".",
	"CurrencySymbol":"TL",
	"NaNSymbol":"NaN",
	"CurrencyNegativePattern":8,
	"NumberNegativePattern":1,
	"PercentPositivePattern":2,
	"PercentNegativePattern":2,
	"NegativeInfinitySymbol":"-Infinity",
	"NegativeSign":"-",
	"NumberDecimalDigits":2,
	NumberDecimalSeparator":",",
	"NumberGroupSeparator":".",
	"CurrencyPositivePattern":3,
	"PositiveInfinitySymbol":"Infinity",
	"PositiveSign":"+",
	"PercentDecimalDigits":2,
	"PercentDecimalSeparator":",",
	"PercentGroupSeparator":".",
	"PercentSymbol":"%",
	"PerMilleSymbol":"‰",
	"NativeDigits":["0","1","2","3","4","5","6","7","8","9"],
	"DigitSubstitution":1
	},
"dateTimeFormat":
	{
	"AMDesignator":"",
		"Calendar":
			{
			"MinSupportedDateTime":"\/Date(-62135596800000)\/",
			"MaxSupportedDateTime":"\/Date(253402293599999)\/",
			"AlgorithmType":1,
			"CalendarType":1,
			"Eras":[1],
			"TwoDigitYearMax":2029,
			"IsReadOnly":true
			},
		"DateSeparator":".",
		"FirstDayOfWeek":1,
		"CalendarWeekRule":0,
		"FullDateTimePattern":"dd MMMM yyyy dddd HH:mm:ss",
		"LongDatePattern":"dd MMMM yyyy dddd",
		"LongTimePattern":"HH:mm:ss",
		"MonthDayPattern":"dd MMMM",
		"PMDesignator":"",
		"RFC1123Pattern":"ddd, dd MMM yyyy HH\u0027:\u0027mm\u0027:\u0027ss \u0027GMT\u0027",
		"ShortDatePattern":"dd.MM.yyyy",
		"ShortTimePattern":"HH:mm",
		"SortableDateTimePattern":"yyyy\u0027-\u0027MM\u0027-\u0027dd\u0027T\u0027HH\u0027:\u0027mm\u0027:\u0027ss",
		"TimeSeparator":":",
		"UniversalSortableDateTimePattern":"yyyy\u0027-\u0027MM\u0027-\u0027dd HH\u0027:\u0027mm\u0027:\u0027ss\u0027Z\u0027",
		"YearMonthPattern":"MMMM yyyy",
		"AbbreviatedDayNames":["Paz","Pzt","Sal","Çar","Per","Cum","Cmt"],
		"ShortestDayNames":["Pz","Pt","Sa","Ça","Pe","Cu","Ct"],
		"DayNames":["Pazar","Pazartesi","Salı","Çarşamba","Perşembe","Cuma","Cumartesi"],
		"AbbreviatedMonthNames":["Oca","Şub","Mar","Nis","May","Haz","Tem","Ağu","Eyl","Eki","Kas","Ara",""],
		"MonthNames":["Ocak","Şubat","Mart","Nisan","Mayıs","Haziran",
		"Temmuz","Ağustos","Eylül","Ekim","Kasım","Aralık",""],
		"IsReadOnly":true,
		"NativeCalendarName":"Gregoryen Takvimi",
		"AbbreviatedMonthGenitiveNames":["Oca","Şub","Mar","Nis","May","Haz","Tem","Ağu","Eyl","Eki","Kas","Ara",""],
		"MonthGenitiveNames":["Ocak","Şubat","Mart","Nisan","Mayıs","Haziran","Temmuz","Ağustos","Eylül","Ekim","Kasım","Aralık",""]
	}
}';

JQuery ve ASP.NET web servisi ile JSON veriyi parsetmek

public class HavaDurumu
{
    public string Min;
    public string Max;
    public string Name;
    public string Image;
}

[WebMethod]
public HavaDurumu f_HavaDurumuJson(string _sSehirler)
{
    // TR873,TR2342 gibi bir string gelecek.
    string[] _ArrSehirler = _sSehirler.Split(new[] { ',' });

    string sSehirSonucu = "";
    string name = "", min = "", max = "", image_code = "";

    // Settings içinde havaDurumu = http://www.bugun.com.tr/files/hava.xml olmalı
    XmlTextReader xmlReader = new XmlTextReader(Properties.Settings.Default.havaDurumu);
    XmlDocument xmlDocument = new XmlDocument();
    xmlDocument.Load(xmlReader);
    XmlNode topNode = xmlDocument.DocumentElement;

    foreach (string sehir in _ArrSehirler)
    {
        XmlNode hava = topNode.SelectSingleNode("record[code='" + sehir + "']");

        name = hava.ChildNodes[1].InnerText;
        min = hava.ChildNodes[4].InnerText;
        max = hava.ChildNodes[5].InnerText;
        image_code = hava.ChildNodes[6].InnerText;
        sSehirSonucu += "{name:'" + name + "', min:" + min + ", max:" + max + ", image_code:'" + image_code + "'},";
    }

    return new HavaDurumu()
               {
                   Name = name, 
                   Image = image_code, 
                   Min = min, 
                   Max = max
               };
}

function f_HavaDurumuJson(_sehir) {
    alert("sehir sorgu: " + _sehir);
    $.ajax({
        type: "POST",
        contentType: "application/json; charset=utf-8",
        url: 'WS/wsGenel.asmx/f_HavaDurumuJson',
        data: "{_sSehirler:'" + _sehir + "'}",
        dataType: "json",
        success: function(data) {

                alert(data.d.Name);
                alert(data.d.Min);
                alert(data.d.Max);
                alert(data.d.Image);

                $.each(data.d, function(ozellik, deger) {
                    alert(ozellik + " - " + deger);
                });
        }
    });
}

f_HavaDurumuJson('TR2342');

---

Bir sınıfın dizi tipinde dönen değerini almak

public class HavaDurumu
{
    public string Min;
    public string Max;
    public string Name;
    public string Image;
}

[WebMethod]
public HavaDurumu[] f_HavaDurumuJson(string _sSehirler)
{
    // TR873,TR2342 gibi bir string gelecek.
    string[] _ArrSehirler = _sSehirler.Split(new[] { ',' });
    HavaDurumu[] sonuc = new HavaDurumu[_ArrSehirler.Length];

    string sSehirSonucu = "";
    string name = "", min = "", max = "", image_code = "";

    // Settings içinde havaDurumu = http://www.bugun.com.tr/files/hava.xml olmalı
    XmlTextReader xmlReader = new XmlTextReader(Properties.Settings.Default.havaDurumu);
    XmlDocument xmlDocument = new XmlDocument();
    xmlDocument.Load(xmlReader);
    XmlNode topNode = xmlDocument.DocumentElement;

    for (int i = 0; i < _ArrSehirler.Length; i++)
    {
        string sehir = _ArrSehirler[i];
        XmlNode hava = topNode.SelectSingleNode("record[code='" + sehir + "']");

        name = hava.ChildNodes[1].InnerText;
        min = hava.ChildNodes[4].InnerText;
        max = hava.ChildNodes[5].InnerText;
        image_code = hava.ChildNodes[6].InnerText;
        sSehirSonucu += "{name:'" + name + "', min:" + min + ", max:" + max + ", image_code:'" + image_code + "'},";
        sonuc[i] = new HavaDurumu()
        {
            Name = name,
            Image = image_code,
            Min = min,
            Max = max
        };
    }

    return sonuc;
}

function f_HavaDurumuJson(_sehir) {
    alert("sehir sorgu: " + _sehir);
    $.ajax({
        type: "POST",
        contentType: "application/json; charset=utf-8",
        url: 'WS/wsGenel.asmx/f_HavaDurumuJson',
        data: "{_sSehirler:'" + _sehir + "'}",
        dataType: "json",
        success: function(data) {

                alert("Dizinin uzunluğu: " + data.d.length);
                alert("0. elemanın Name değeri: "+ data.d[0].Name);
                $.each(data.d, function(i, eleman) {
                    
                    alert(eleman.Name + " | " + eleman.Min + " | " + eleman.Max + " | " + eleman.Image);
                    
                    $.each(eleman, function(key, value) {
                        alert(key + " - " + value);
                    });
                    
                });
        }
    });
}

f_HavaDurumuJson('TR2342,TR4801');

Kaynak:
http://www.eburhan.com/jquery-ve-json-islemleri/
http://prettycode.org/2009/04/07/using-jquery-with-aspnet-web-services-and-json/