Y.CommonModel

gistfile1.js

/**
     * Validations Facade. All the validation rules go here.
     */
    Y.ValidationFacade = Y.Base.create("ValidationFacade", Y.Base, [], {

        validations: {
            trim: function(key, val, attrs) {
                if (!val) {
                    val = "";
                }
                return val.trim();
            },
            required: function(key, val, attrs) {
                if (typeof val === "undefined" || !val) {
                    throw {
                        target: key,
                        val: val,
                        message: Y.Lang.sub("<strong>{s}</strong> can not be empty", {
                            s: this.titlize(key)
                        })
                    };

                }
                return val;
            },
            max: function(key, val, attrs, a) {
                var args = a.replace("(", "").replace(")", "").split(",");
                if (parseInt(args[0], 10) < val.length) {
                    throw {
                        target: key,
                        val: val,
                        message: Y.Lang.sub("<strong>{s}</strong> can not be longer than {L} chars", {
                            s: this.titlize(key),
                            L: args[0]
                        })
                    };
                }
                return val;
            },
            min: function(key, val, attrs, a) {
                var args = a.replace("(", "").replace(")", "").split(",");
                
                if (parseInt(args[0], 10) > val.length) {
                    throw {
                        target: key,
                        val: val,
                        message: Y.Lang.sub("<strong>{s}</strong> can not be shorter than {L} chars", {
                            s: this.titlize(key),
                            L: args[0]
                        })
                    };
                }
                return val;
            },
            email: function(key, val, attrs) {
                var reg = /^([A-Za-z0-9_\-\.])+\@([A-Za-z0-9_\-\.])+\.([A-Za-z]{2,4})$/;
                if (!reg.test(val)) {
                    throw {
                        target: key,
                        val: val,
                        message: Y.Lang.sub("<strong>{s}</strong> is not a valid email address", {
                            s: this.titlize(key)
                        })
                    };
                }
                return val.toLowerCase();
            },
            match: function(key, val, attrs, a) {
                var args = a.replace("(", "").replace(")", "").split(",");
                if (!attrs[args[0]] || attrs[args[0]] !== val) {
                    throw {
                        target: key,
                        val: val,
                        message: Y.Lang.sub("<strong>{s}</strong> does not match with {L}", {
                            s: this.titlize(key),
                            L: this.titlize(args[0])
                        })
                    };
                }
            },
            numeric: function(key, val, attrs) {
                var reg = /^([0-9])$/;
                if (!reg.test(val)) {
                    throw {
                        target: key,
                        val: val,
                        message: Y.Lang.sub("<strong>{s}</strong> is not a number", {
                            s: this.titlize(key)
                        })
                    };
                }
                return val;
            },
            string: function(key, val, attrs) {
                var reg = /^([A-Za-z])$/;
                if (!reg.test(val)) {
                    throw {
                        target: key,
                        val: val,
                        message: Y.Lang.sub("<strong>{s}</strong> is not a string", {
                            s: this.titlize(key)
                        })
                    };
                }
                return val;
            },
            /**
             * Uniqueness is a server only valdiation though it is transparently to the user.
             * @param a: "DocumentType,key"
             */
            unique: function(key, val, attrs) {
                var output;
                output = Y.api.invoke("/user/is_taken", {
                    key: key,
                    val: val
                });
               
                if (typeof output !== "undefined" && output !== false) {
                    if (output.taken === true) {
                        throw {
                            target: key,
                            val: val,
                            message: Y.Lang.sub("<strong>{s}</strong> is taken", {
                                s: this.titlize(key)
                            })
                        };
                    }
                }
                return val;
            }


        },
        titlize: function(str) {
            str = str.replace(/_/g, " ");
            return str.replace(/\w\S*/g, function(txt) {
                return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
            });

        },
        checkValidity:function(){ 
        	var errors = this.validate(this.getAttrs());
        	if(typeof errors ==="undefined" || errors===null){
        		return;
        	}
        	else{
        		return errors;
        	}
        	
        }
        

    });

/*
     * The CommonModel class represents the base Model for our application which supports our customized validation framework as well
     * @class  CommonModel
     * @extends AshleshaBaseModel
     * @uses
     * @constructor
     * @cfg {attrs:{
     *         attr_name:{
     *         value:'default value',
     *         validation_rules:'trim|required|numeric',
     *         hash:[true|false]
     *         save:[true,false]
     * }
     * }} configuration attributes
     *
     */
    Y.CommonModel = Y.Base.create("CommonModel", Y.AshleshaBaseModel, [Y.ValidationFacade], {
        initializer: function(config) {
            var attrs = this.get("attrs") || (config && config.attrs);

            if (attrs) //We supply attributes as initialization parameters along with
            {
                this.set("attrs", Y.clone(attrs));
                this.addAttrs(attrs);

            }

        },
        validate: function(attrs,callback) {
        	var attrConfig = this.get("attrs"),
                errors = [];
            if (attrConfig) {

                Y.Object.each(attrConfig, function(val, key) {
                    var v = val.validation_rules,
                        rules;

                    //If the validation rule chain is specified
                    if (v) {
                        rules = v.split("|");

                        try {

                            Y.Array.each(rules, function(item, index) {
                                var args = item.match(/\(.*\)/),
                                    f;
                                if (!args) {
                                    val = this.validations[item].apply(this, [key, attrs[key], attrs]);
                                }
                                else {
                                    f = item.match(/^(.*)(:?\(.*)/);

                                    //Teh function name max where the item = max(10)
                                    val = this.validations[f[1]].apply(this, [key, attrs[key], attrs, f[2]]);
                                }

                            }, this);

                        } catch (ex) {

                            errors.push({
                                field: key,
                                error: ex
                            });
                        }

                    }
                }, this);
            }
            if (errors.length > 0) {
                callback && callback(errors);
                return errors;
            }
            else
            {
            	callback && callback();
            }
        }
        
    	
    });






//EXAMPLE MODEL

Y.WREntryModel = Y.Base.create("WREntryModel", Y.CommonModel, [], {
        initializer: function() {
            Y.PostModel.superclass.initializer.apply(this, [{
                attrs: {

                    posttext: {
                        value: '',
                        validation_rules: "trim|required|min(8)"
                    },
                    image: {
                        value: ''
                    },
                    comments_count: {
                        value: 0
                    },
                    comments: {
                        value: []
                    },
                    likes: {
                        value: []
                    },
                    shares: {
                        value: []
                    },
                    tType: { //tType refers to the category of the post.
                        value: ''
                    },
                    section:{ //Each entry belongs to a section. For example "Mobile Phones" is a section
                    	value:''
                    	validation_rules: "trim|required"
                    },
                    brand_name:{ //Each product may be associated with a brand_name
                    	value:'',
                    	validation_rules: "trim|required"
                    },
                    section_id:{	//For future sake we also store the section_id if present
                    	value:''
                    },
                    brand_id:{ //For futures sake
                    	value:''
                    },
                    purchased_at:{ //location_id
                    	value:''
                    }
                    
                    

                }}]);
        }
    });