(function(global){

     global.assert = function(condition, message) {
        if (!condition) {
            message = message || "Assertion failed";
            if (typeof Error !== "undefined") {
                throw new Error(message);
            }
            throw message; // Fallback
        }
    }

	global.defaultize = function(invadors, defaults, test){

		var target = {};
		for(
			var key in defaults
		){

			if(
				invadors == undefined
				|| invadors[key] == undefined
			){
				target[key] = defaults[key];
			}else{
				target[key] = invadors[key];
			}
		}

		for(
			var key in invadors
		){
			if(
				target[key] == undefined
				&& invadors[key] != undefined
			){
				target[key] = invadors[key];
			}

		}

		return target;

	}

	global.operator = function(alias){

		//check passed param
		if(
			//check if key is passed
			alias == undefined
		){
			//dont return any operator
			return "";

		}else{

			//link passed key
			var thisKey = alias;

			if(
				//check if open ends is requested
				thisKey == "<>"
			){
				//return open ends
				return "*";

			}else if(
				//check if starting end is requested
				thisKey == "<"
			){
				//return starting end
				return "$";

			}else if(
				//check if closing end is requested
				thisKey == ">"
			){
				//return closing end
				return "|";

			}else{

				//dont return any operator as default
				return "";
			}

		}
	}

    global.breakParam = function(string){

        var type = string.split("(")[0];
        var backing = string.split("(")[1];

        if(
            backing != undefined
        ){
            backing = backing.replace(")", "");
            backing = backing.split(",");
        }else{
            backing = [];
        }
        var param = {};

        if(
            backing.length > 0
        ){

            $.each(backing, function(index, backing){

                if(
                    backing.split(":")[1] != undefined
                ){
                    param[backing.split(":")[0]] = backing.split(":")[1];
                }else{
                    param[index] = backing;
                }
            });
        }

        return {
            type : type,
            param : param
        };

    }

    global.handleMessages = function(functionParam){

        var result = false;

        var thisParam = defaultize(functionParam, {
            response : undefined,
            assessment : undefined,
            config : undefined
        });

        thisParam.assessment.content.clear({});

        if(
            thisParam.response != undefined
            && thisParam.assessment != undefined
        ){

            if(
                thisParam.response.assessment != undefined
            ){

                $.each(thisParam.response.assessment, function(index, message){

                    if(
                        message.type != undefined
                        && message.code != undefined
                        && thisParam.config != undefined
                        && thisParam.config[message.type] != undefined
                        && thisParam.config[message.type] == true
                    ){
                      
                        thisParam.assessment.content.add({
                            exception : message.code,
                            section : message.type,
                            data : {
                                config : message
                            }
                        });



                        result = true;

                    }

                });

            }

        }

        return result;

    }

	global.find = function(selecter, list){



		for(
			var i in list
		){

			var crit = "";
			var thisList = list[i];



			for(
				var n in thisList
			){

				var thisCrit = thisList[n];

				crit += "[";

				if(
                   thisCrit.key != undefined
				){
					crit += thisCrit.key;
				}

				if(
                    thisCrit.key != undefined
					&& thisCrit.value != undefined
				){
					crit += "=" + operator(thisCrit.operator) + "\"" + thisCrit.value + "\"";
				}

				crit += "]";

			}

            while(
                crit.indexOf("[]") >= 0
            ){
                crit = crit.replace("[]","");
            }

			if(
				crit.length > 0
			){
				selecter = $(selecter).has(crit);
			}else{
				selecter = $(selecter);
			}

		}

		return $(selecter);

	};

}(window));

(function(global){

	var objectName = "Surfable";

	var Class = function(){

		var classObject = this;

		return classObject;

	}
	Class.prototype.log = [];

	global[objectName] = new Class;

}(window));
(function(global){
	
	var objectName = "Surfable";
	var className = "Constraint";
	
	
	var Class = function(methodParam){
		
	}
	
	global[objectName][className] = Class;
		
}(window));
(function(global){
	
	var objectName = "Surfable";
	var className = "Property";
	
	
	var Class = function(methodParam){
		
		var classObject = this;
		var thisParam = defaultize(methodParam, {});
		
		
		for(
			var key in thisParam
		){
			if(
				classObject.isProto(key) == false
			){
				
				classObject.set({
					key : key,
					value : thisParam[key]
				});
			}

		}
		
		return classObject;
		
	}
	
	Class.prototype.prepair = function(methodParam){

		var classObject = this;
		var thisParam = defaultize(methodParam, {
			key : undefined,
		});
		
		if(
			thisParam.key == undefined
		){
			
			Surfable.log.push("object("+className+") method(sub) key(value) issue(missing)");
			return false;
			
		}else{
			
			if(
				classObject[thisParam.key] == undefined
			){
				classObject[thisParam.key] = new Surfable.Property;
			}
			
			return classObject[thisParam.key];
			
		}
		
	}
	Class.prototype.set = function(methodParam){

		var classObject = this;
		var thisParam = defaultize(methodParam, {
			key : undefined,
			value : undefined
		});
		
		if(
			thisParam.value == undefined
		){
			
			Surfable.log.push("object("+className+") method(set) key(value) issue(missing)");
			return false;
			
		}else{
			
			var key;
			
			if(
				thisParam.key == undefined
			){
				key = classObject.key();
			}else{
				key = thisParam.key;
			}
						
			classObject[key] = thisParam.value;
			return key;
			
			
		}
		
	}
	Class.prototype.get = function(methodParam){

		var classObject = this;
		var thisParam = defaultize(methodParam, {
			key : undefined
		});
		
		if(
			thisParam.key == undefined
			
		){
			
			return classObject;
			
		}else if(
			thisParam.key != undefined
			&& classObject[thisParam.key] == undefined
		){
			
			Surfable.log.push("object("+objectName+") method(get) key(key) value("+thisParam.key+") issue(unknown)");
			return false;
			
		}else{
			
			var result = {};
			result[thisParam.key] = classObject[thisParam.key];
			return result;
		}
		
	}
	Class.prototype.key = function(methodParam){
		
		var classObject = this;
		var thisParam = defaultize(methodParam, {
			key : undefined
		});
		
		var thisKey;
		
		if(
			thisParam.key == undefined
		){
			var i = 0;
			
			while(
				classObject[i] != undefined
			){
				i++
			}
			
			thisKey = i;
			
		}else{
			thisKey = thisParam.key;
		}
		
		if(
			classObject != undefined
			&& classObject[thisKey] == undefined
		){
			
			return thisKey;
		
		}else{
			
			Surfable.log.push("object("+className+") method(key) key(thisKey) issue(ambigious)");
			return  false;
		
		}
		
	}
    
    Class.prototype.list = function(methodParam){
        
        var classObject = this;
        var thisParam = defaultize(methodParam, {
		});
        
        var array = [];
        
        $.each(classObject, function(key, object){
            
            if(
                classObject.isProto(key) == false
            ){
                array.push(object);
            }
            
        });
        
        return array;
    }
    Class.prototype.object = function(methodParam){
        
        var classObject = this;
        var thisParam = defaultize(methodParam, {
		});
        
        var array = {};
        
        $.each(classObject, function(key, object){
            
            if(
                classObject.isProto(key) == false
            ){
                array[key] = object;
            }
            
        });
        
        return array;
    }
    
	Class.prototype.apply = function(methodParam){
		       
		var classObject = this;

        var array = {};
        
		for(
			var key in classObject
		){ 
			if(
				classObject.isProto(key) == false
			){
				
				if(
					classObject != undefined
					&& classObject[key] != undefined
				){
					if(
						typeof classObject[key] == "object"
						&& classObject[key].apply != undefined
						&& typeof classObject[key].apply == "function"
					){
						array[key] = classObject[key].apply(methodParam);
						
					}else if(
						typeof classObject[key] == "function"
					){
						array[key] = classObject[key](methodParam);
						
					}
				}
				
			}
			
		}

        return array;
        
	}
    Class.prototype.find = function(methodParam){
        
        var classObject = this;
        var thisParam = defaultize(methodParam, {});
        
        return _.where(classObject, thisParam);
        
    }
	
	Class.prototype.isProto = function(key){
		
		var classObject = this;
		
		if(
			classObject.__proto__[key] == undefined
		){
			return false;
		}else{
			return true;
		}
	}
	
	global[objectName][className] = Class;
		
}(window));
(function(global){

    var getCookie = function(name) {
        var cookies = document.cookie.split(';');
        for(var i=0 ; i < cookies.length ; ++i) {
            var pair = cookies[i].trim().split('=');
            if(pair[0] == name)
                return pair[1];
        }
        return null;
    };

	var objectName = "Surfable";
	var className = "API";


    var utilityIssueList = ["tokenize"];
	var momentIssueList = ["before", "error", "success", "timeout", "complete"];

    var done = [];

	var Class = function(methodParam){

		var classObject = this;

        var thisConfig = defaultize(methodParam, {
            url : undefined,
            async : true,
            cache : false,
            type : "post",
            dataType : "json",
            auth : {
                account : undefined,
                secret : undefined,
                group : undefined,
            },
        });

				classObject.state = {
					setup : false,
				};

        classObject.ready = false;

        watch(classObject, "ready", function(arg){
            if(
                classObject.ready == true
            ){


                $.each(classObject.que.object(), function(key, call){

                    if(
                        call != undefined
                    ){


                        classObject.clearCallback({});
                        classObject.call(call);
                        delete classObject.que[key];

                    }

                });

            }

        });

        classObject.config = new Surfable.Property(thisConfig);
        classObject.property = new Surfable.Property({});
        classObject.que = new Surfable.Property({});

		classObject.initCallback({});

		return classObject;

	}

    Class.prototype.config = new Surfable.Property({});
    Class.prototype.property = new Surfable.Property({});
	Class.prototype.callback = new Surfable.Property({});

    Class.prototype.applyCallback = function(methodParam){

        var classObject = this;

        var thisParam = defaultize(methodParam, {
            moment : undefined,
            callback : classObject.callback,
            data : undefined,
        });

        if(
            thisParam.moment != undefined
        ){
            if(
                thisParam.callback != undefined
                && thisParam.callback[thisParam.moment] != undefined
            ){
                $.each(thisParam.callback[thisParam.moment], function(key, callbackObject){
                    if(
                        thisParam.callback[thisParam.moment].isProto(key) == false
                    ){
                        callbackObject(thisParam.data);
                    }
                });
            }
        }

        return true;
    }
    Class.prototype.clearCallback = function(methodParam){

        var classObject = this;

        var thisParam = defaultize(methodParam, {
            //
        });

        classObject.callback = new Surfable.Property(thisParam);

        $.each(momentIssueList, function(key, moment){
            classObject.callback.prepair({
                key : moment,
            });
        });

        return true;
    }
    Class.prototype.initCallback = function(methodParam){

        var classObject = this;

        var thisParam = defaultize(methodParam, {
            //
        });

        classObject.clearCallback(thisParam);
    }
    Class.prototype.mergeCallback = function(methodParam){

        var classObject = this;

        var thisParam = defaultize(methodParam, {
            callback : {},
        });

        $.each(momentIssueList, function(issueKey, issue){

            if(
                thisParam.callback[issue] != undefined
                && classObject.callback[issue] != undefined
            ){
                $.each(thisParam.callback[issue], function(callbackKey, callback){

                    if(
                        classObject.callback[issue].get()[callbackKey] == undefined
                    ){
                        classObject.callback[issue].set({
                            key : callbackKey,
                            value : callback
                        });
                    }else{
                        classObject.callback[issue].set({
                            value : callback
                        });
                    }

                });
            }

        });

        return classObject.callback;
    }
    Class.prototype.checkQue = function(methodParam){

        var classObject = this;

        var thisParam = defaultize(methodParam, {
            command : undefined,
        });

        if(
            classObject.ready == false
            && utilityIssueList.indexOf(thisParam.command) < 0
        ){
            return false;
        }else{
            return true;
        }
    }
    Class.prototype.addQue = function(methodParam){

        var classObject = this;

        var thisParam = defaultize(methodParam, {
            param : undefined,
        });

        classObject.que.set({
            value: thisParam.param
        });
    }
    Class.prototype.setup = function(methodParam){

        var classObject = this;

        var thisParam = defaultize(methodParam, {
            command : "tokenize",
            callback : undefined
        });

        classObject.initCallback({});
        classObject.call(thisParam);

        return true;
    }
    Class.prototype.call = function(methodParam){

		var classObject = this;

        var thisParam = defaultize(methodParam, {
            token : undefined,
            session : getCookie("PHPSESSID"),
            command : undefined,
            auth : undefined,
            body : {},
            config : classObject.config.object(),
            callback : {},
        });

        if(
            classObject.checkQue({
                command : thisParam.command
            }) == false
        ){

            classObject.addQue({
                param : thisParam
            });

            return false;
        }

        classObject.callback.before.set({
            key : "activateQueing",
            value : function(arg){

                classObject.ready = false;

            }
        });
        classObject.callback.complete.set({
            key : "disableQueing",
            value : function(arg){

                classObject.ready = true;

            }
        });
        classObject.callback.success.set({
            key : "applyUtility",
            value : function(arg){

                if(
                    arg != undefined
                    && arg.response != undefined
                    && arg.response.header != undefined
                ){
                    var issues = ["session", "token"];

                    $.each(issues, function(key, issue){

                        if(
                            arg.response.header[issue] != undefined
                        ){
                            classObject.property.set({
                                key : issue,
                                value : arg.response.header[issue]
                            });
                        }

                    });

                }

            }
        });

        thisParam.callback = classObject.mergeCallback({
            callback : thisParam.callback
        });

        var thisHeader = defaultize({
            command : thisParam.command,
            auth : thisParam.auth,
        }, {
            token : classObject.property.get().token,
            session : classObject.property.get().session,
            command : undefined,
            auth : thisParam.config.auth,
            session : thisParam.session,
        });

        var serviceParam = {
			url: thisParam.config.url,
			async: thisParam.config.async,
			cache: thisParam.config.cache,
			type: thisParam.config.type,
			dataType: thisParam.config.dataType,
            data: {
                header : thisHeader,
                body : thisParam.body
            },
			beforeSend: function(data){

				classObject.property.set({
                    key : "processing",
                    callback : thisParam.callback,
                    value : true
                });

                classObject.applyCallback({
                    moment : "before",
                    callback : thisParam.callback,
                    data : data,
                });

			},
			error: function (data){
                classObject.applyCallback({
                    moment : "error",
                    callback : thisParam.callback,
                    data : data,
                });

			},
			success: function(data){
                classObject.applyCallback({
                    moment : "success",
                    callback : thisParam.callback,
                    data : data,
                });

			},
			complete: function(data){

                classObject.property.set({
                    key : "processing",
                    callback : thisParam.callback,
                    value : false
                });

                classObject.applyCallback({
                    moment : "complete",
                    callback : thisParam.callback,
                    data : data,
                });

			}
		};

        jQuery.ajax(serviceParam);

	}

	global[objectName][className] = Class;

}(window));
(function(global){
	
	var objectName = "Surfable";
	var className = "Event";
	
	
	var Class = function(methodParam){
		
		var classObject = this;
		var thisParam = defaultize(methodParam, {
		});
		
		classObject.property = new Surfable.Property(thisParam);
		
		classObject.onTrigger = new Surfable.Property;
		classObject.onReady = new Surfable.Property;
		
		return classObject;
		
	}
	
	Class.prototype.add = function(methodParam){
		
		var classObject = this;
		var thisParam = defaultize(methodParam, {
			trigger : undefined,
			onTrigger : undefined,
			onReady : undefined,
			key : undefined
		});
		
		if(
			thisParam.trigger == undefined
		){
			Surfable.log.push("object("+className+") method(add) key(trigger) issue(missing)");
			return false;
			
		}else{
			
			if(
				typeof thisParam.trigger == "string"
			){
				var add = function(type, fnc){
					
					if(
						classObject[type].get({
							key : thisParam.trigger
						}) == false
					){
                        
						classObject[type].prepair({
							key : thisParam.trigger
						});
					
					}
					
					classObject[type].get({
						key : thisParam.trigger
					})[thisParam.trigger].set({
						value : fnc,
						key : thisParam.key,
					});
					
				}
				
				add("onTrigger", thisParam.onTrigger);
				add("onReady", thisParam.onReady);
				
			}else{
				
				for(
					var key = 0;
					key < thisParam.trigger.length;
					key ++
				){
					
					classObject.add({
						trigger : thisParam.trigger[key],
						onTrigger : thisParam.onTrigger,
						onReady : thisParam.onReady,
						key : thisParam.key,
					});
					
				}
			}
			
			
		}
		
	}
	Class.prototype.deploy = function(methodParam){

		var classObject = this;
		
		var thisParam = defaultize(methodParam, {
			element : undefined
		});
		
		if(
			thisParam.element == undefined
		){
			Surfable.log.push("object("+className+") method(deploy) key(element) issue(missing)");
			return false;
				
		}else{
			
			var onTriggerEventList = classObject.onTrigger.get();
			var onReadyEventList = classObject.onReady.get();
			
			for(
				var key in onTriggerEventList
			){
				if(
					onTriggerEventList.__proto__[key] == undefined
				){
					(function(key){
						
						var apply = function(index, element){
							
							if(
								typeof classObject[index][key].apply == "function"
							){
                                
                                if(
                                    element.element.length == undefined
                                ){
                                    element.element = $(element.element);
                                }
                                
                                if(
                                	element.e != undefined
                                ){
                                	element.element.e = element.e;
                                }
								classObject[index][key].apply(element.element);
							}
							
						}
						
						$(thisParam.element)/*.off(key)*/.on(key, function(e){

							apply("onTrigger", {element:this, e:e});
							
						}).ready(function(){
							
							apply("onReady", {element:thisParam.element});
							
						});
						
					}(key));
					
				}
			}
			
			return true;
		}
	}
	
	global[objectName][className] = Class;
		
}(window));(function(global){
	
	var objectName = "Surfable";
	var className = "Object";
	
	
	var Class = function(methodParam){
		
		var classObject = this;
		var thisParam = defaultize(methodParam, {
			objectAttribute : "data-cinc-object",
			objectElement : undefined,
			paramNameAttr : "name",
			paramValueAttr : "value",
			multipleList : [],
			interfaceObject : {},
		});
		
		classObject.property = new Surfable.Property(thisParam);
		classObject.repository = new Surfable.Property;
		
		classObject.multiple = new Surfable.Property;
		$.each(thisParam.multipleList, function(key, value){
			
			classObject.multiple.set({
				key : value,
				value : true,
			});
		
		});
		
		classObject.deploy({
			element : thisParam.objectElement
		});
		
		return classObject;
		
	}
	
	Class.prototype.deploy = function(methodParam){
		
		var classObject = this;
		var thisParam = defaultize(methodParam, {
			element : undefined
		});
		
        //aggregate relevant element(list)
		var thisElement;
		if(
			thisParam.element == undefined
		){
			thisElement = "[" + classObject.property.get({}).objectAttribute + "]";
		}else{
			thisElement = thisParam.element;
		}
		
         //define bind method for changes
		function bind(thisArray){
            
			watch(thisArray, [classObject.property.get({}).paramValueAttr], function(prop, action, difference, oldvalue){

				var value;
				
				if(
					typeof thisArray.value == "string"
				){
                    value = thisArray.value;
				}else{
					value = thisArray.value.join(" ");
				}
                
                if(
                    typeof value == "string"
                ){
                    $(thisArray.element).attr(classObject.property.get({}).paramValueAttr, value);
                }
                
			});
            
            $(thisArray.element).off("change").on("change", function(){
                
                var value = thisArray.value = $(thisArray.element).attr(classObject.property.get({}).paramValueAttr);
                var entity = $(thisArray.parent.element).attr(classObject.property.get({}).objectAttribute);
                
                if(
                    classObject.property
                    && classObject.property.get({}).interfaceObject
                    && classObject.property.get({}).interfaceObject[entity] != undefined
                    && classObject.property.get({}).interfaceObject[entity].attachment != undefined
                    && classObject.property.get({}).interfaceObject[entity].attachment.gateway != undefined
                    && classObject.property.get({}).interfaceObject[entity].attachment.gateway.element != undefined
                    && $(classObject.property.get({}).interfaceObject[entity].attachment.gateway.element).val() != value
                ){
                    $(classObject.property.get({}).interfaceObject[entity].attachment.gateway.element).trigger("sync");
                }
				
			});
            
		}
        
        //define method how to extract data drom dom-objects na how to build js-object
		function extract(selecter, param, parent){
			
			var array = new Surfable.Property;
			
			var elementList = $(selecter);
			
			for(
				var childKey = 0;
				childKey < elementList.length;
				childKey ++ 
			){
				var childElement = elementList[childKey];
			
				
				var elementName;
				if(
					param == true
				){
					elementName = $(childElement).attr(classObject.property.get({}).paramNameAttr);
				}else{
					elementName = $(childElement).attr(classObject.property.get({}).objectAttribute);
					
					if(
						$(childElement).find("[" + classObject.property.get({}).paramNameAttr + "=\"entity\"]").length == 0
					){
						var entityParam = new Surfable.Component;
						
						entityParam.template.set({
							key : "param",
							status : "ready",
							template : "<param " + classObject.property.get({}).paramNameAttr + "=\"entity\" " + classObject.property.get({}).paramValueAttr + "=\"{{value}}\"/>"
						});
						
						entityParam.deploy({
							parent : childElement,
							property : {
								value : elementName
							}
						});
					}
					
				}
				
				var elementValue;
				var endpoint;
				
				var thisArray = {
					element : $(childElement),
                    event : new Surfable.Property
				};
				
				if(
					typeof parent == "object" 
				){
					thisArray.parent = parent;
				}
				
				if(
					$(childElement).children().length == 0
				){
					
					elementValue = $(childElement).attr(classObject.property.get({}).paramValueAttr);
					
					if(
						classObject.multiple.get({
							key : elementName
						})[elementName] == true
					){
						
						elementValueParts = elementValue.split(" ");
						elementValue = new Surfable.Property();
						
						for(
							var i = 0;
							i < elementValueParts.length;
							i++
						){
				
							elementValue.set({
								value : elementValueParts[i]
							});
						}
					}
					endpoint = true;
					
				}else{
					
					elementValue = extract($(childElement).children(), true, thisArray);
					endpoint = false;
				}
                
				thisArray.value = elementValue;
				
				array.set({
					key : elementName,
					value : thisArray
				});
				
				
				if(
					endpoint == true
				){
					
					bind(thisArray);
		
				}
				
			}
			
			return array;
		}

        //execute 
		var result = extract(thisElement);
			
		classObject.repository = new Surfable.Property(result);
			
		return extract;
			
		
	}
	Class.prototype.get = function(methodParam){
		
		var classObject = this;
		var thisParam = defaultize(methodParam, {
			entity : undefined
		});
		
		return classObject.repository.get({
			key : thisParam.entity
		});
		
	};
	Class.prototype.add = function(methodParam){
		
		var classObject = this;
		var thisParam = defaultize(methodParam, {
			property : {
				entity : undefined
			},
			objectEventList : undefined,
			paramEventList : undefined,
		});
		
		if(
			thisParam.property == undefined
		){
			
			Surfable.log.push("object("+className+") method(add) key(property) issue(missing)");
			return false;
			
		}else if(
			thisParam.property.entity == undefined
		){
			
			Surfable.log.push("object("+className+") method(add) key(property.entity) issue(missing)");
			return false;
			
		}else{
			
			var objectStancil = new Surfable.Component;
				
			objectStancil.template.set({
				key : "object",
				status : "ready",
				template : "<object "+classObject.property.get({}).objectAttribute+"=\"{{entity}}\">{{{nested}}}</object>"
			});
				
			var newObject = objectStancil.deploy({
				parent : "body",
				property : thisParam.property,
				eventList : thisParam.objectEventList
			});
			
			
			$.each(thisParam.property, function(key, value){
				
				if(
					key != ""
				){

				}
				var paramStancil = new Surfable.Component;
				
				paramStancil.template.set({
					key : "param",
					status : "ready",
					template : "<param name=\"{{name}}\" value=\"{{value}}\"/>"
				});
				
				var newParam = paramStancil.deploy({
					parent : newObject,
					property : {
						name : key,
						value : value
					},
					eventList : thisParam.paramEventList
				});
	
			});
			
			return $(newObject);
		}
		
		
	}
	Class.prototype.find = function(methodParam){
		
		var classObject = this;
		var thisParam = defaultize(methodParam, []);
		
		return find($("[" + classObject.property.get({}).objectAttribute + "]"), thisParam);
		
	}
	
	global[objectName][className] = Class;

}(window));(function(global){
	
	var objectName = "Surfable";
	var className = "Template";
	
	
	var Class = function(methodParam){
		
		var classObject = this;
		
        var thisParam = defaultize(methodParam, {
		});
        
		classObject.property = new Surfable.Property(thisParam);
		classObject.repository = new Surfable.Property({});
		
		return classObject;
		
	}

	Class.prototype.set = function(methodParam){
		
		var classObject = this;
		var thisParam = defaultize(methodParam, {
			key : undefined,
			status : "failed",
			template : ""
		});
		
		classObject.repository.set({
			key : thisParam.key,
			value : {
				status : thisParam.status,
				template : thisParam.template,
			}
		});
	
	}
	Class.prototype.load = function(methodParam){

		var classObject = this;
		var thisParam = defaultize(methodParam, {
			url : undefined,
			key : undefined
		});
		
		if(
			thisParam.url == undefined
		){
			Surfable.log.push("object("+className+") method(loadTemplate) key(template url) issue(missing)");
			return false;
			
		}else{
			
			if(
				thisParam.key == undefined
			){
				thisParam.key = classObject.repository.key({});
			}
			
			$.ajax({
				
				url: thisParam.url,
				type : "POST",
				
				beforeSend : function(){
					
					classObject.repository.set({
						key : thisParam.key,
						status : "initialized",
						template : "",
					});
				
				},
				
				error : function() {

					classObject.repository.set({
						key : thisParam.key,
						status : "failed",
						template : "",
					});
					
				},
				
				success: function(template) {
					
					classObject.repository.set({
						key : thisParam.key,
						status : "ready",
						template : template,
					});
					
				},
				
				complete : function(){
					
				},
				
				accepts : undefined,
				cache : undefined,
				contents : undefined,
				contentType : undefined,
				context : undefined,
				converters : undefined,
				crossDomain : undefined,
				data : undefined,
				dataFilter : undefined,
				dataType : undefined,
				global : undefined,
				headers : undefined,
				ifModified : undefined,
				isLocal : undefined,
				jsonp : undefined,
				jsonpCallback : undefined,
				method : undefined,
				mimeType : undefined,
				username : undefined,
				password : undefined,
				processData : undefined,
				scriptCharset : undefined,
				statusCode : undefined,
				timeout : undefined,
				traditional : undefined,
				xhrFields : undefined,
				async: true,
				
			});
			
			return thisParam.key;
		}
		
	}
	Class.prototype.build = function(methodParam){

		var classObject = this;
		var thisParam = defaultize(methodParam, {
			property: {},
			key : undefined
		});
		
		var templateList = classObject.repository.get({
			key : thisParam.key
		});
		
		var markup = "";
		
		for(
			var key in templateList
		){
			
			var thisTemplate = templateList[key];
			
			if(
				thisTemplate.template == undefined
			){
				
				Surfable.log.push("object("+className+") method(build) key(template "+key+") issue(empty)");
				return false;
				
			}else{
				
				if(
					thisTemplate.status == undefined
					|| thisTemplate.status != "ready"
				){
					Surfable.log.push("object("+className+") method(build) key(status) issue(invalid)");
					return false;
				}else{
					return Mustache.render(thisTemplate.template, thisParam.property);
				}
			}
		}
			
		
	}

	global[objectName][className] = Class;
		
}(window));
(function(global){
	
	var objectName = "Surfable";
	var className = "Component";
	
	
	var Class = function(methodParam){
		
		var classObject = this;
        
        var thisParam = defaultize(methodParam, {
		});
        
		classObject.property = new Surfable.Property(thisParam);
		classObject.event = new Surfable.Event({});
		classObject.template = new Surfable.Template({});
		
		return classObject;
		
	}
	
	Class.prototype.deploy = function(methodParam){

		var classObject = this;
		var thisParam = defaultize(methodParam, {
			parent : undefined,
			property : undefined,
			clone : {
				avoid : true,
				selecter : undefined,
				markup : undefined
			},
			eventList : []
		});

		if(
			thisParam.property != undefined
		){
			
			$.each(thisParam.property, function(key, value){
				
				classObject.property.set({
					key : key,
					value : value,
				});
				
			});
			
		}
		
		if(
			thisParam.parent == undefined
		){
			Surfable.log.push("object("+className+") method(deploy) key(parent) issue(missing)");
			return false;
			
		}else{
			
			var thisParent = thisParam.parent;
			var thisMarkup = classObject.template.build({
				property : classObject.property
			});

			var replaceAll = function(search, replace, string){

				while(
					string.indexOf(search) >= 0
				){
					string = string.replace(search, replace);
				}

				return String(string);
			}
			thisMarkup = replaceAll("*]", ">", thisMarkup);
			thisMarkup = replaceAll("*[:", "</", thisMarkup);
			thisMarkup = replaceAll("*[", "<", thisMarkup);
			thisMarkup = replaceAll("*#", "\"", thisMarkup);
			
			


			var thisElement = $(thisMarkup);

			var parentMarkup = $(thisParent).html();
			var elementMarkup = $(thisElement).html();

			if(
				thisParam.clone.avoid == true
				&& (
					parentMarkup.indexOf(elementMarkup) > 0
					|| parentMarkup.indexOf(thisParam.clone.markup) > 0
					|| thisMarkup == thisParam.clone.markup
					|| $(thisParent).find(thisParam.clone.selecter).length > 0
				)
			){
			
				return false;

			}else{

				thisElement = $(thisMarkup).appendTo(thisParent);

				thisElement.elementOriginal = thisElement;

			}
			if(
				thisParam.eventList != undefined
			){
				$.each(thisParam.eventList, function(index, event){
					classObject.event.add(event);
				});
			}
			
			classObject.event.deploy({
		        element : thisElement
		    });
					
		        classObject.element = $(thisElement);
		        
		        return classObject.element;
		}
		
	}
	Class.prototype.clear = function(methodParam){

		var classObject = this;
		var thisParam = defaultize(methodParam, {
			parent : undefined
		});
		
		if(
			thisParam.parent == undefined
		){
			Surfable.log.push("object("+className+") method(method) key(parent) issue(missing)");
			return false;
			
		}else{
			
			$(thisParam.parent).html("");
			return true;
			
		}
		
	}
	
	global[objectName][className] = Class;
		
}(window));

    // if object has no reflection/markuppointer dont proceed/or do proceed id service?
        //set object-param when data.* is set but element missing
        // still cant precess radiobuttons
        // custom dropdown items / list
            // delegate $("[data-cinc-option=\"" + data.entity + "\"]").trigger("check"); to gateway?
            // delegate $("[data-cinc-option=\"" + data.reference + "\"]").trigger("check").trigger("checkInterfaceConstraint"); check to gateway




(function(global){

	var objectName = "Surfable";
	var className = "Dialog";

    var language_message;

    if(
        global.language_message == undefined
    ){

        language_message = function(code){
            console.log("\"language_message\" is no valid method to pull exceptions in " + objectName + " Object " + className + "Class");
        }

    }else{

        language_message = global.language_message;

    }


	var Class = function(methodParam){

		var classObject = this;

		classObject.init(methodParam);
        classObject.setup({});

		return classObject;
	}

    Class.prototype.init = function(methodParam){

        var classObject = this;

        var thisParam = defaultize(methodParam, {
            multipleList : ["someParamNameValue"],
            definitionAttr : "someElementAttribute",
            interfaceAttr : "someElementAttribute",
            objectElement : undefined,
        });

        classObject.property = new Surfable.Property(thisParam);

        classObject.feature = new Surfable.Property;

        classObject.constraint = new Surfable.Property;
        classObject.status = {
            entity : {},
            section : {},
        };
        classObject.defaultConstraint({});

        classObject.interface = new Surfable.Property;
    }

    Class.prototype.setup = function(methodParam){

        var classObject = this;

        var thisParam = defaultize(methodParam, {
            objectAttribute : classObject.property.get().objectAttribute,
            paramNameAttr : "name",
            paramValueAttr : "value",
            multipleList : classObject.property.get().multipleList,
            interfaceObject : classObject.property.get().interface,
            entity : undefined,
        });

        classObject.definition = new Surfable.Object(thisParam);
        classObject.getDefinition(thisParam);

        classObject.stageInterface(thisParam);
        classObject.defineInterfaceDefault(thisParam);
        classObject.deployInterface(thisParam);
    };

    Class.prototype.addFeature = function(methodParam){

        var classObject = this;

        var thisParam = defaultize(methodParam, {
            name : undefined,
            feature : undefined
        });

        if(
            thisParam.name == undefined
        ){
            Surfable.log.push("object("+className+") method(addFeature) key(name) issue(missing)");
            result = false;

        }else if(
            thisParam.feature == undefined
        ){
            Surfable.log.push("object("+className+") method(addFeature) key(feature) issue(missing)");
            result = false;

        }else if(
            classObject.feature == undefined
            || classObject.feature.get() == undefined
            || classObject.feature.get()[thisParam.feature] != undefined
        ){

            Surfable.log.push("object("+className+") method(addFeature) key(invalid)");
            result = false;

        }else{

            classObject.feature.set({
                key : thisParam.name,
                value : thisParam.feature
            });

            result = true;

        }
    }
    Class.prototype.triggerFeature = function(methodParam){

        var classObject = this;

        var thisParam = defaultize(methodParam, {
            name : undefined,
            argument : undefined
        });

        if(
            thisParam.name == undefined
        ){
            Surfable.log.push("object("+className+") method(triggerFeature) key(name) issue(missing)");
            result = false;

        }else if(
            classObject.feature == undefined
            || classObject.feature.get() == undefined
            || classObject.feature.get()[thisParam.name] == undefined
        ){
            Surfable.log.push("object("+className+") method(triggerFeature) key(invalid)");
            result = false;

        }else{
            result = classObject.feature.get()[thisParam.name](thisParam.argument);

        }

        return result;
    }

    Class.prototype.defaultConstraint = function(methodParam){

        var classObject = this;

		var thisParam = defaultize(methodParam, {});

        var checkType = function(obj){
            if(
                obj != undefined
                && obj.interface != undefined
                && obj.interface.attachment != undefined
                && obj.interface.attachment.assessment != undefined
            ){

                return obj.interface.attachment.assessment;
            }else{
                return false;
            }
        }
        var addMessage = function(functionParam){
            var thisParam = defaultize(functionParam, {
                exception : undefined,
                section : undefined,
                obj : {},
                data : {},
            });

            thisParam.data = thisParam.obj.config;

            var assessment = checkType(thisParam.obj);

            if(
                assessment != false
            ){
                assessment.content.add(thisParam);
            }

        }
        var removeMessage = function(functionParam){

            var thisParam = defaultize(functionParam, {
                exception : undefined,
                section : undefined,
                obj : {},
                data : {},
            });

            thisParam.data = thisParam.obj.config;

            var assessment = checkType(thisParam.obj);

            if(
                assessment != false
            ){
                assessment.content.remove(thisParam);
            }
        }

        //mandatory
        classObject.constraint.set({
            key : "mandatory",
            value : function(obj){

                var status = true;

                $.each(obj, function(type, value){
                    if(
                        value == false
                    ){

                        status = false;
                    }
                });

                if(
                    status == false
                ){

                    addMessage({
                        obj : obj,
                        section : "error",
                        exception : "mandatory-unsatisfied",
                        message : language_message("mandatory-unsatisfied"),
                        data : {},
                    });
                }else{
                    removeMessage({
                        obj : obj,
                        section : "error",
                        exception : "mandatory-unsatisfied",
                    });
                }

                return status;

            }
        });
        //isset
        classObject.constraint.set({
            key : "isset",
            value : function(obj){

                var value = $(obj.element).val();

                if(
                    value == undefined
					|| value == null
					|| value == false
					|| value == 0
					|| value.length == 0
					|| value == "nn"
					|| value == "na"
                ){

                    addMessage({
                        obj : obj,
                        section : "error",
                        exception : "isset-unsatisfied",
                        message : language_message("mandatory-unsatisfied"),
                        data : {},
                    });

                    return false;
                }else{

                    removeMessage({
                        obj : obj,
                        section : "error",
                        exception : "isset-unsatisfied",
                    });

                    return true;
                }

            }
        });
        //checkbox
        classObject.constraint.set({
            key : "checkbox",
            value : function(obj){

                var value = $(obj.element).val();

                if(
                    obj.config != undefined
                    && obj.config.reference != undefined
                    && value == obj.config.reference
                ){
                    removeMessage({
                        obj : obj,
                        section : "error",
                        exception : "checkbox-unsatisfied",
                        data : {},
                    });
                    return true;
                }else{

                    addMessage({
                        obj : obj,
                        section : "error",
                        exception : "checkbox-unsatisfied",
                        message : language_message("checkbox-unsatisfied"),
                        data : {},
                    });

                    return false;
                }

            }
        });
        //email
        classObject.constraint.set({
            key : "email",
            value : function(obj){

                var value = $(obj.element).val();

                var pattern = new RegExp(/^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/);

				if(
					pattern.test(value) == false
				){
                    addMessage({
                        obj : obj,
                        section : "error",
                        exception : "email-invalid",
                        message : language_message("email-invalid"),
                        data : {},
                    });

                    return false;
				}else{

                    removeMessage({
                        obj : obj,
                        section : "error",
                        exception : "email-invalid",
                    });

					return true;
				}

            }
        });
        //clear
        classObject.constraint.set({
            key : "clear",
            value : function(obj){

                if(
                    obj.config.entity == undefined
                ){
                    addMessage({
                        obj : obj,
                        section : "error",
                        exception : "clear-param-missing",
                        message : language_message("clear-param-missing"),
                        data : {},
                    });

                    return false;
                }else{

                    removeMessage({
                        obj : obj,
                        section : "error",
                        exception : "clear-param-missing",
                    });

                    var data = classObject.getDefinition({
                        entity : obj.config.entity
                    });

                    if(
                        data[obj.config.entity] == undefined
                    ){
                        addMessage({
                            obj : obj,
                            section : "error",
                            exception : "clear-data-missing",
                            message : language_message("clear-data-missing"),
                            data : {},
                        });

                        return false;
                    }else{

                        removeMessage({
                            obj : obj,
                            section : "error",
                            exception : "clear-data-missing",
                        });

                        $(classObject.interface[obj.config.entity].attachment.gateway.element).val("").trigger("change").trigger("checkInterfaceConstraint");
                        return true;
                    }
                }

            }
        });
        //equal
        classObject.constraint.set({
            key : "equal",
            value : function(obj){

                if(
                    obj.config.entity == undefined
                ){
                    addMessage({
                        obj : obj,
                        section : "error",
                        exception : "equal-param-missing",
                        message : language_message("equal-param-missing"),
                        data : {},
                    });

                    return false;
                }else{
                    removeMessage({
                        obj : obj,
                        section : "error",
                        exception : "equal-param-missing",
                    });

                     var data = classObject.getDefinition({
                        entity : obj.config.entity
                    });

                    if(
                        data[obj.config.entity] == undefined
                    ){
                        addMessage({
                            obj : obj,
                            section : "error",
                            exception : "equal-data-missing",
                            message : language_message("equal-data-missing"),
                            data : {},
                        });
                        return false;
                    }else{
                        removeMessage({
                            obj : obj,
                            section : "error",
                            exception : "equal-data-missing",
                        });
                        if(
                            data[obj.config.entity].value != $(obj.element).val()
                        ){
                            addMessage({
                                obj : obj,
                                section : "error",
                                exception : "equal-invalid",
                                message : language_message("equal-invalid", {label:data[obj.config.entity].label}),
                                data : {},
                            });
                            return false;
                        }else{
                            removeMessage({
                                obj : obj,
                                section : "error",
                                exception : "equal-invalid",
                            });

                            return true;
                        }
                    }
                }

            }
        });
        //is
        classObject.constraint.set({
            key : "is",
            value : function(obj){

                var result = true;

                var value = $(obj.element).val();

                if(
                    obj.config.value != undefined
                    && obj.config.value != value
                ){
                    addMessage({
                        obj : obj,
                        section : "error",
                        exception : "is-value",
                        message : language_message("is-value", {value:obj.config.value}),
                        data : {},
                    });
                    result = false;

                }else{
                    removeMessage({
                        obj : obj,
                        section : "error",
                        exception : "is-value",
                    });
                }

                return result;

            }
        });
        //int-value
        classObject.constraint.set({
            key : "int-value",
            value : function(obj){

                var result = true;

                var value = $(obj.element).val();
                value = parseInt(value);

                obj.config.min = parseInt(obj.config.min);
                obj.config.max = parseInt(obj.config.max);

                if(
                    obj.config.min != undefined
                    && value.length < obj.config.min
                ){
                    addMessage({
                        obj : obj,
                        section : "error",
                        exception : "int-value-invalid-min",
                        message : language_message("int-value-invalid-min", {min:obj.config.min}),
                        data : {},
                    });
                    result = false;
                }else{
                    removeMessage({
                        obj : obj,
                        section : "error",
                        exception : "int-value-invalid-min",
                    });
                }

                if(
                    obj.config.max != undefined
                    && value.length > obj.config.max
                ){
                    addMessage({
                        obj : obj,
                        section : "error",
                        exception : "int-value-invalid-max",
                        message : language_message("int-value-invalid-max", {max:obj.config.max}),
                        data : {},
                    });
                    result = false;
                }else{
                    removeMessage({
                        obj : obj,
                        section : "error",
                        exception : "int-value-invalid-max",
                    });
                }

                return result;

            }
        });
        //string-length
        classObject.constraint.set({
            key : "string-length",
            value : function(obj){

                var result = true;

                var value = $(obj.element).val();

                if(
                    obj.config.min != undefined
                    && value.length < obj.config.min
                ){
                    addMessage({
                        obj : obj,
                        section : "error",
                        exception : "string-length-invalid-min",
                        message : language_message("string-length-invalid-min", {min:obj.config.min}),
                        data : {},
                    });
                    result = false;
                }else{
                    removeMessage({
                        obj : obj,
                        section : "error",
                        exception : "string-length-invalid-min",
                    });
                }

                if(
                    obj.config.max != undefined
                    && value.length > obj.config.max
                ){
                    addMessage({
                        obj : obj,
                        section : "error",
                        exception : "string-length-invalid-max",
                        message : language_message("string-length-invalid-max", {max:obj.config.max}),
                        data : {},
                    });
                    result = false;
                }else{
                    removeMessage({
                        obj : obj,
                        section : "error",
                        exception : "string-length-invalid-max",
                    });
                }

                return result;

            }
        });
        //string-has
        classObject.constraint.set({
            key : "string-has",
            value : function(obj){

                var pattern = {
                    number : [new RegExp(/\d+/g), "Zahlen"],
                    uppercased : [new RegExp(/[A-Z]/), "Kleinbuchstaben"],
                    lowercased : [new RegExp(/[a-z]/), "Großbuchstaben"],
                    special : [new RegExp(/[-!$%^#&*()_+|~=`{}\[\]:";'<>?,.\/]/), "Sonderzeichen (-!$%^#&*()_+|={}\[\]:;<>?,.)"],
                };

                var value = $(obj.element).val();

                if(
                    obj.config.type == undefined
                ){
                    addMessage({
                        obj : obj,
                        section : "error",
                        exception : "string-has-param",
                        message : language_message("string-has-param"),
                        data : {},
                    });
                    return false;
                }else{

                    removeMessage({
                        obj : obj,
                        section : "error",
                        exception : "string-has-param",
                    });
                    if(
                        pattern[obj.config.type] == undefined
                    ){
                        addMessage({
                            obj : obj,
                            section : "error",
                            exception : "string-has-pattern",
                            message : language_message("string-has-pattern"),
                            data : {},
                        });
                        return false;
                    }else{
                        removeMessage({
                            obj : obj,
                            section : "error",
                            exception : "string-has-pattern",
                        });
                        if(
                            pattern[obj.config.type][0].test(value) == true
                        ){
                            removeMessage({
                                obj : obj,
                                section : "error",
                                exception : "string-has-failed-" + obj.config.type,
                            });
                            return true;
                        }else{
                            addMessage({
                                obj : obj,
                                section : "error",
                                exception : "string-has-failed-" + obj.config.type,
                                message : language_message("string-has-failed", {type:pattern[obj.config.type][1]}),
                                data : {},
                            });
                            return false;

                        }
                    }
                }





            }
        });
        //string-only
        classObject.constraint.set({
            key : "string-only",
            value : function(obj){

                var pattern = {
                    number : [new RegExp(/\d+/g), "Zahlen"],
                };

                var value = $(obj.element).val();

                if(
                    obj.config.type == undefined
                ){
                    addMessage({
                        obj : obj,
                        section : "error",
                        exception : "string-only-param",
                        message : language_message("string-only-param"),
                        data : {},
                    });
                    return false;
                }else{
                    removeMessage({
                        obj : obj,
                        section : "error",
                        exception : "string-only-param",
                    });
                    if(
                        pattern[obj.config.type] == undefined
                    ){
                        addMessage({
                            obj : obj,
                            section : "error",
                            exception : "string-only-pattern",
                            message : language_message("string-only-pattern"),
                            data : {},
                        });
                        return false;
                    }else{
                        removeMessage({
                            obj : obj,
                            section : "error",
                            exception : "string-only-pattern",
                            data : {},
                        });
                        if(
                            pattern[obj.config.type][0].test(value) == false
                        ){
                            addMessage({
                                obj : obj,
                                section : "error",
                                exception : "string-only-invalid",
                                message : language_message("string-only-invalid",{type:pattern[obj.config.type][1]}),
                                data : {},
                            });
                            return false;
                        }else{
                            removeMessage({
                                obj : obj,
                                section : "error",
                                exception : "string-only-invalid",
                                data : {},
                            });
                            return true;
                        }
                    }
                }

            }
        });
    }

	Class.prototype.getDefinition = function(methodParam){

		var classObject = this;

		var thisParam = defaultize(methodParam, {
			entity : undefined,
            callback : undefined
		});

		var definition = new Surfable.Property;

    		$.each(
    			classObject.definition.get({
    				entity : thisParam.entity
    			}),
    			function(entity, thisObject){

    				if(
    					thisObject.value != undefined
    				){
    					for(
    						var paramName in thisObject.value
    					){

    						if(
    							thisObject.value.isProto(paramName) == false
    						){

    							definition.prepair({
    								key : entity
    							}).set({
    								key : paramName,
    								value : thisObject.value[paramName].value
    							});

    						}
    					}

    				}

    		});

		if(
			thisParam.entity == undefined
		){
			return definition;
		}else{

			return definition.get({
				entity : thisParam.entity
			});

		}
	}

	Class.prototype.setDefinition = function(methodParam){

		var classObject = this;

		var thisParam = defaultize(methodParam, {
			entity : undefined,
			key : undefined,
			value : undefined,
            add : false
		});

		if(
			thisParam.entity == undefined
		){
			Surfable.log.push("object("+className+") method(setDefinition) key(entity) issue(missing)");
			return false;
		}else if(
			thisParam.key == undefined
		){
			Surfable.log.push("object("+className+") method(setDefinition) key(key) issue(missing)");
			return false;
		}else{

			var definition = classObject.definition.get();

			if(
				definition[thisParam.entity] == undefined
			){

				Surfable.log.push("object("+className+") method(setDefinition) key(entity) value("+thisParam.entity+") issue(unknown)");
				return false;

            }else if(
				definition[thisParam.entity].value[thisParam.key] == undefined
			){
				Surfable.log.push("object("+className+") method(setDefinition) key(key) value("+thisParam.key+") issue(unknown)");
				return false;
			}else{

                $(definition[thisParam.entity].value[thisParam.key].element).attr("value", thisParam.value).change();
                return thisParam.value;

			}

		}
	}

	Class.prototype.findDefinition = function(methodParam){

		var classObject = this;

		var thisParam = defaultize(methodParam, []);

		var found = classObject.definition.find(thisParam);

		var result = {};

		$.each(found, function(key, value){

			var entity = $(value).attr(classObject.property.get().definitionAttr);

			result[entity] = classObject.getDefinition({
				entity : entity
			})[entity];

		});

		return result;
	}

    Class.prototype.stageInterface = function(methodParam){

		var classObject = this;

		var thisParam = defaultize(methodParam, {
			entity : undefined,
		});

		if(
			thisParam.entity == undefined
		){

            var array = {};

			$.each(classObject.findDefinition(), function(entity, entityData){

				array[entity] = classObject.stageInterface({
					entity : entity
				});

			});

            return array;

		}else{

            var interface = classObject.interface.prepair({
                key : thisParam.entity
            });

			$("["+classObject.property.get().interfaceAttr+"=\""+thisParam.entity+"\"]").each(function(key, interfaceElement){

                interface.prepair({
                    key : "attachment"
                });

                if(
                    interface.get().element == undefined
                ){
                    interface.set({
                        key : "element",
                        value : interfaceElement
                    });

                    interface.set({
                        key : "entity",
                        value : thisParam.entity
                    });
                }


            });

            return classObject.interface.get()[thisParam.entity];
        }
    }

    Class.prototype.deployInterface = function(methodParam){

        var classObject = this;

        var thisParam = defaultize(methodParam, {
            entity : undefined,
        });

       if(
            thisParam.entity == undefined
        ){

            $.each(classObject.interface, function(entity, interfaceObject){

                if(
                    classObject.interface.isProto(entity) == false
                ){
                    classObject.deployInterface({
                        entity : entity
                    });

                }

            });

            return true;

        }else if(
            classObject.interface != undefined
            && classObject.interface[thisParam.entity] != undefined
            && classObject.interface[thisParam.entity].attachment != undefined
        ){

            var interfaceObject = classObject.interface[thisParam.entity];

            $.each(interfaceObject.attachment, function(attachmentKey, componentObject){

                if(
                    interfaceObject.attachment.isProto(attachmentKey) == false
                ){

                    componentObject.deploy({
                        parent : interfaceObject.element,
                    });

                }

            });

            return true;

        }
    }

    Class.prototype.defineInterface = function(methodParam){

		var classObject = this;

		var thisParam = defaultize(methodParam, {
			condition : function(param){},
            definition : function(param){},
            entity : undefined
		});

        var closure = function(entity, interfaceObject){

            if(
                classObject.interface.isProto(entity) == false
            ){

                if(
                    thisParam.condition(interfaceObject) == true
                ){
                    thisParam.definition(interfaceObject);
                }

            }

        }

        if(
            thisParam.entity == undefined
        ){
            $.each(classObject.interface, function(entity, interfaceObject){

                closure(entity, interfaceObject);

            });
        }else if(
            classObject.interface != undefined
            && classObject.interface[thisParam.entity] != undefined
        ){
            closure(thisParam.entity, classObject.interface[thisParam.entity]);
        }
	}

    Class.prototype.defineInterfaceDefault = function(methodParam){

		var classObject = this;

		var thisParam = defaultize(methodParam, {
            entity : undefined
        });

        if(
            thisParam.entity == undefined
        ){
            $.each(classObject.interface, function(entity, interfaceObject){

                classObject.defineInterfaceDefault({
                    entity : entity
                });

            });

        }else{

            var thisEntity = thisParam.entity;

            //assessment
            classObject.defineInterface({
                condition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    if(
                        data == undefined
                    ){
                        return false;
                    }else{
                        return true;
                    }

                },
                definition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    var attachment = new Surfable.Component(data);

                    var Assessment = function(classParam){

                        var classObject = this;

                        var thisParam = defaultize(methodParam, {});

                        if(
                            data.label != undefined
                        ){
                            //classObject.title = "\""+data.label+"\"-Info:";
                            classObject.title = data.label;
                        }else{
                            classObject.title = "Info";
                        }

                        classObject.info = new Surfable.Property({});
                        classObject.info.prepair({
                            key: "error"
                        });
                        classObject.info.prepair({
                            key: "success"
                        });
                        classObject.info.prepair({
                            key: "info"
                        });

                    }

                    Assessment.prototype.info = {};
                    Assessment.prototype.add = function(methodParam){

                        var classObject = this;

                        var thisParam = defaultize(methodParam, {
                            exception : undefined,
                            section : undefined,
                            message : undefined,
                            data : {},
                        });

                        thisParam.data.message = thisParam.message;

                        if(
                            thisParam.exception == undefined
                        ){
                            console.debug("Assessment exception \"" + thisParam.exception + "\" missing");
                            return false;

                        }else if(
                            thisParam.section == undefined
                        ){

                            $.each(classObject.info, function(section, info){

                                classObject.add({
                                    section : section,
                                    exception : thisParam.exception,
                                    message : thisParam.message,
                                    data : thisParam.data
                                });

                            });

                            return true;

                        }else if(
                            classObject.info.get()[thisParam.section] == undefined
                        ){

                            console.debug("Assessment cant find section \"" + thisParam.section + "\"");
                            return false;

                        }else{

                            classObject.info.get()[thisParam.section].set({
                                key : thisParam.exception,
                                value : thisParam.data,
                            });

                            return true;

                        }

                    }
                    Assessment.prototype.remove = function(methodParam){

                        var classObject = this;

                        var thisParam = defaultize(methodParam, {
                            exception : undefined,
                            section : undefined,
                        });

                        if(
                            thisParam.exception == undefined
                        ){
                            console.debug("Assessment exception \"" + thisParam.exception + "\" missing");
                            return false;

                        }else if(
                            thisParam.section == undefined
                        ){

                            $.each(classObject.info, function(section, info){

                                classObject.remove({
                                    section : section,
                                    exception : thisParam.exception,
                                    data : thisParam.data
                                });

                            });

                            return true;

                        }else if(
                            classObject.info.get()[thisParam.section] == undefined
                        ){

                            console.debug("Assessment cant find section \"" + thisParam.section + "\"");
                            return false;

                        }else if(
                            classObject.info.get()[thisParam.section][thisParam.exception] != undefined
                        ){

                            delete classObject.info[thisParam.section][thisParam.exception];
                            return true;

                        }

                    }

                    Assessment.prototype.clear = function(methodParam){

                        var classObject = this;

                        classObject.info = new Surfable.Property({});
                        classObject.info.prepair({
                            key: "error"
                        });
                        classObject.info.prepair({
                            key: "success"
                        });
                        classObject.info.prepair({
                            key: "info"
                        });

                    }

                    attachment.content = new Assessment({});

                    var markup = "";
                    markup += "<div data-cinc-reference=\"{{entity}}\" data-cinc-attachment=\"constraint modal\" class=\"modal\" tabindex=\"-1\" role=\"dialog\">";
                        markup += "<div class=\"modal-wrapper\">";
                            markup += "<div class=\"modal-dialog\">";
                                markup += "<div class=\"modal-content\">";
                                    markup += "<div class=\"modal-header\">";
                                        markup += "<button type=\"button\" class=\"modal-close\"><span class=\"glyphicon glyphicon-remove\"></span></button>";
                                        markup += "<h3 class=\"modal-title\"></h3>";
                                    markup += "</div>";
                                    markup += "<div class=\"modal-body\">";
                                        markup += "";
                                    markup += "</div>";
                                    markup += "<div class=\"modal-footer\">";
                                        markup += "<button type=\"button\" class=\"modal-close\">Schließen</button>";
                                    markup += "</div>";
                                markup += "</div><!-- /.modal-content -->";
                            markup += "</div><!-- /.modal-dialog -->";
                        markup += "</div><!-- /.modal-wrapper -->";
                    markup += "</div><!-- /.modal -->";

                    attachment.template.set({
                        status : "ready",
                        template : markup
                    });

                    attachment.event.add({
                        trigger : ["show"],
                        onTrigger : function(paramElement){

                            $(paramElement).trigger("render").modal("show");

                        },
                        onReady : function(paramElement){

                            $(paramElement).find(".modal-close").click(function(){
                                $(paramElement).modal("hide");
                            });

                        }
                    });

                    attachment.event.add({
                        trigger : ["render"],
                        onTrigger : function(paramElement){

                            $(attachment.element).find(".modal-title").html(attachment.content.title);

                            $(attachment.element).find(".modal-body").each(function(){


                                var content = {};
                                var countMessages = 0;

                                var sectionList = attachment.content.info.object({});

                                $.each(sectionList, function(sectionName, sectionObject){

                                    var listMarkup = "";

                                    var exceptionList = sectionObject.object({});

                                    $.each(exceptionList, function(exceptionName, exceptionObject){

                                        countMessages++;

                                        if(
                                            (typeof exceptionObject) == "object"
                                        ){
                                            if(
                                                exceptionObject.message != undefined
                                                && exceptionObject.message.length > 0
                                            ){
                                                listMarkup += "<li class=\"hideCode\">"+ exceptionObject.message + " <kbd>" + exceptionName + "</kbd></li>";
                                            }else if(
                                                exceptionObject.config != undefined
                                                && exceptionObject.config.message != undefined
                                                && exceptionObject.config.message.length > 0
                                            ){
                                                listMarkup += "<li class=\"hideCode\">"+ exceptionObject.config.message + " <kbd>" + exceptionName + "</kbd></li>";
                                            }else if(
                                                exceptionName.indexOf("premise-entity:") >= 0
                                                || exceptionName.indexOf("implies-entity:") >= 0
                                            ){
                                                var command = exceptionName.split(":")[0];
                                                var entity = exceptionName.split(":")[1];

                                                var thisData = classObject.getDefinition({
                                                    entity : entity
                                                })[entity];

                                                listMarkup += "<li class=\"hideCode\">";

                                                if(
                                                    command == "premise-entity"
                                                ){
                                                    listMarkup += "Feld wird blockiert durch";
                                                }else{
                                                    listMarkup += "Dieses Feld blockiert das Feld";
                                                }

                                                listMarkup += " \"" + thisData.label + "\".";
                                                listMarkup += " <kbd>" + exceptionName + "</kbd>";
                                                listMarkup += "</li>";

                                            }else{
                                                listMarkup += "<li>"+ exceptionName + "<pre>" + JSON.stringify(exceptionObject) + "</pre></li>";
                                            }
                                        }


                                    });
                                    var speech = {
                                        info : "Hintergrund-Infos:",
                                        error : "Fehler:",
                                        success : "Erfolgsmeldungen:",
                                    };

                                    content[sectionName] = "";
                                    if(
                                        listMarkup != ""
                                    ){
                                        if(
                                            speech[sectionName] != undefined
                                        ){
                                            content[sectionName] += "<h3>" + speech[sectionName] + "</h3>";
                                        }else{
                                            content[sectionName] += "<h3>Sonstiges:</h3>";
                                        }
                                        content[sectionName] += "<ul class=\"" + sectionName + "\">" + listMarkup + "</ul><br>";
                                    }




                                });

                                var markup = "";

                                $.each(content, function(section, content){

                                    markup += content;

                                });

                                if(
                                    countMessages == 0
                                ){
                                    markup = "Keine Infos vorhanden.";
                                }

                                $(this).html(markup);


                            });

                        },
                        onReady : function(paramElement){

                        }
                    });

                    interfaceObject.attachment.set({
                        key : "assessment",
                        value : attachment
                    });

                },
                entity : thisEntity,
            });

            //assessmentTrigger
            classObject.defineInterface({
                condition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    if(
                        data == undefined
                    ){
                        return false;
                    }

                    return (
                            data.type == "field"
                    );

                },
                definition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    var attachment = new Surfable.Component(data);

                    attachment.template.set({
                        status : "ready",
                        template : "<div data-cinc-reference=\"{{entity}}\" data-cinc-attachment=\"constraint assessment {{field}}\" class=\"info\"><span class=\"symbol info glyphicon glyphicon-info-sign\"></span><span class=\"symbol working glyphicon glyphicon-pencil\"></span><span class=\"symbol error glyphicon glyphicon-flag\"></span><span class=\"symbol success glyphicon glyphicon-ok\"></span><span class=\"symbol disabled glyphicon glyphicon-lock\"></span></div>"
                    });

                    attachment.event.add({
                        trigger : ["click"],
                        onTrigger : function(paramElement){

                          if(
                              interfaceObject.attachment.assessment != undefined
                              && interfaceObject.attachment.assessment.element != undefined
                          ){
                               $(interfaceObject.attachment.assessment.element).trigger("show");
                          }

                        },
                        onReady : function(paramElement){

                        }
                    });

                    attachment.event.add({
                        trigger : ["error"],
                        onTrigger : function(paramElement){

                            if(
                                data.constraint == undefined
                                || data.mandatory != "true"
                            ){
                                return false;
                            }
                          $(paramElement).attr("data-state", "error");

                        },
                        onReady : function(paramElement){

                        }
                    });

                    attachment.event.add({
                        trigger : ["success"],
                        onTrigger : function(paramElement){

                            if(
                                data.constraint == undefined
                                || data.mandatory != "true"
                            ){
                                return false;
                            }
                          $(paramElement).attr("data-state", "success");
                        },
                        onReady : function(paramElement){

                        }
                    });

                    attachment.event.add({
                        trigger : ["progress"],
                        onTrigger : function(paramElement){
                            if(
                                data.constraint == undefined
                                || data.mandatory != "true"
                            ){
                                return false;
                            }
                          $(paramElement).attr("data-state", "progress");
                        },
                        onReady : function(paramElement){

                        }
                    });

                    interfaceObject.attachment.set({
                        key : "assessmentTrigger",
                        value : attachment
                    });

                },
                entity : thisEntity,
            });

            //gateway
            classObject.defineInterface({
                condition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    if(
                        data == undefined
                        || data.field == undefined
                    ){
                        return false;
                    }else{
                        return (data.type == "field");
                    }

                },
                definition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    var attachment = new Surfable.Component(data);

                    attachment.template.set({
                        status : "ready",
                        template : "<input data-cinc-interface=\"{{entity}}\" data-cinc-attachment=\"field gateway\" type=\"hidden\"/>"
                    });

                    attachment.event.add({
                        trigger : ["resetValue"],
                        onTrigger : function(paramElement){

                            var data = classObject.getDefinition({
                                entity : interfaceObject.entity
                            })[interfaceObject.entity];

                            var value;

                            if(
                                data.field == "dropdown"
                            ){
                                value = "nn";
                            }else if(
                                data.field == "checkbox"
                            ){
                                value = false;
                            }else{
                                value = "";
                            }

                            if(
                                $(paramElement).val() != value
                            ){
                               $(paramElement).val(value).trigger("change").trigger("checkInterfaceConstraint");
                            }

                        },
                        onReady : function(paramElement){},
                    });

                    attachment.event.add({
                        trigger : ["resetAssessmentTrigger"],
                        onTrigger : function(paramElement){

                            $(interfaceObject.attachment.assessmentTrigger.element).removeClass("success").removeClass("progress").removeClass("error");
                        },
                        onReady : function(paramElement){},
                    });



                    attachment.event.add({
                        trigger : ["feature"],
                        onTrigger : function(paramElement){

                            var data = classObject.getDefinition({
                                entity : interfaceObject.entity
                            })[interfaceObject.entity];

                            var features = [];

                            $.each(data.feature, function(key, feature){

                                if(
                                    data.feature.isProto(key) == false
                                ){
                                    features.push(breakParam(feature));
                                }
                            });

                            $.each(features, function(featureIndex, feature){

                                if(
                                    feature.type == "service"
                                ){
                                    var serviceData = {};

                                    var objectIssue = ["service_host", "service_command", "service_binding"];

                                    $.each(objectIssue, function(issueIndex, issue){

                                        if(
                                            feature.param[issue] != undefined
                                        ){
                                            serviceData[issue] = classObject.getDefinition({
                                                entity : feature.param[issue]
                                            })[feature.param[issue]];
                                        }

                                    });

                                    if(
                                        serviceData.service_binding != undefined
                                    ){

                                        var dispatches = {};

                                        var dispatchIssue = ["input", "output", "modify", "success"];

                                        $.each(dispatchIssue, function(dispatchKey, issue){

                                            if(
                                                serviceData.service_binding[issue] != undefined
                                            ){
                                                dispatches[issue] = [];

                                                $.each(serviceData.service_binding[issue], function(thisDispatchIndex, binding){
                                                    if(
                                                        serviceData.service_binding[issue].isProto(thisDispatchIndex) == false
                                                    ){
                                                        dispatches[issue].push(breakParam(binding));
                                                    }
                                            });
                                            }

                                        });
                                    }

                                    var body = {};

                                    if(
                                        dispatches != undefined
                                    ){
                                        if(
                                            dispatches.input != undefined
                                        ){
                                            $.each(dispatches.input, function(inputIndex, inputParam){

                                                var thisData = classObject.getDefinition({
                                                    entity : inputParam.param[0]
                                                });

                                                if(
                                                    thisData[inputParam.param[0]] != undefined
                                                ){
                                                    body[inputParam.type] = thisData[inputParam.param[0]].value;
                                                }

                                            });
                                        }

                                        if(
                                            dispatches.modify != undefined
                                        ){
                                            $.each(dispatches.modify, function(modifyIndex, modifyParam){

                                                if(
                                                    modifyParam.type != undefined
                                                ){
                                                    if(
                                                        modifyParam.type == "crypt"
                                                    ){
                                                        $.each(modifyParam.param, function(key, type){

                                                            if(
                                                                type != undefined
                                                                && key != undefined
                                                                && body != undefined
                                                                && body[key] != undefined
                                                                && CryptoJS != undefined
                                                                && CryptoJS[type] != undefined
                                                            ){
                                                                body[key] = CryptoJS[type](body[key]).toString();
                                                            }
                                                        });
                                                    }
                                                }

                                            });
                                        }
                                    }
                                    if(
                                        serviceData.service_host != undefined
                                        && serviceData.service_host.entity != undefined
                                        && classObject.interface != undefined
                                        && classObject.interface[serviceData.service_host.entity] != undefined
                                        && classObject.interface[serviceData.service_host.entity].service_host != undefined
                                        && classObject.interface[serviceData.service_host.entity].service_host.call != undefined
                                        && serviceData.service_command != undefined
                                        && serviceData.service_command.command != undefined
                                    ){
                                        classObject.interface[serviceData.service_host.entity].service_host.clearCallback();
                                        classObject.interface[serviceData.service_host.entity].service_host.call({
                                            command : serviceData.service_command.command,
                                            body : body,
                                            callback : {
                                                before: {
                                                    enableCover : function(arg){

                                                        $(classObject.interface[serviceData.service_command.entity].attachment.cover.element).trigger("enable");

                                                    }
                                                },
                                                error: {
                                                    errorConnectivity : function(arg){

                                                        classObject.interface[serviceData.service_command.entity].attachment.assessment.content.add({
                                                            exception : "service-failed",
                                                            section : "error",
                                                            message : language_message("service-failed"),
                                                            data : {
                                                                config : {}
                                                            }
                                                        });

                                                        $(classObject.interface[serviceData.service_command.entity].attachment.assessment.element).trigger("show");
                                                        $(classObject.interface[serviceData.service_command.entity].attachment.cover.element).trigger("disable");
                                                    }
                                                },
                                                success: {
                                                    appendTypes : function(arg){

                                                        if(
                                                            arg != undefined
                                                            && arg.response != undefined
                                                            && arg.response.body != undefined
                                                        ){
                                                            var assessmentConfig = {
                                                                error : true,
                                                                success : true,
                                                                notice : false
                                                            };

                                                            if(
                                                                arg.response.body.status == true
                                                            ){

                                                                if(
                                                                    dispatches.output != undefined
                                                                ){
                                                                    $.each(dispatches.output, function(index, binding){

                                                                        if(
                                                                            binding != undefined
                                                                            && binding.type != undefined
                                                                            && binding.param != undefined
                                                                            && binding.param[0] != undefined
                                                                            && arg != undefined
                                                                            && arg.response != undefined
                                                                            && arg.response.body != undefined
                                                                            && arg.response.body.data != undefined
                                                                            && arg.response.body.data[binding.type] != undefined
                                                                            && classObject.interface != undefined
                                                                            && classObject.interface[binding.param[0]] != undefined
                                                                            && classObject.interface[binding.param[0]].attachment != undefined
                                                                            && classObject.interface[binding.param[0]].attachment.gateway != undefined
                                                                            && classObject.interface[binding.param[0]].attachment.gateway.element != undefined
                                                                        ){


                                                                            $(classObject.interface[binding.param[0]].attachment.gateway.element)
                                                                                .val(arg.response.body.data[binding.type])
                                                                                .trigger("change")
                                                                                .trigger("checkInterfaceConstraint")
                                                                                ;
                                                                        }

                                                                    });
                                                                }

                                                                if(
                                                                    dispatches.success != undefined
                                                                ){

                                                                    $.each(dispatches.success, function(index, binding){
                                                                        if(
                                                                            binding != undefined
                                                                            && binding.type != undefined
                                                                            && binding.param != undefined
                                                                        ){
                                                                            if(
                                                                                binding.type == "clear"
                                                                                && binding.param[0] != undefined
                                                                                && classObject.interface != undefined
                                                                                && classObject.interface[binding.param[0]] != undefined
                                                                                && classObject.interface[binding.param[0]].attachment != undefined
                                                                                && classObject.interface[binding.param[0]].attachment.gateway != undefined
                                                                                && classObject.interface[binding.param[0]].attachment.gateway.element != undefined
                                                                            ){
                                                                                $(classObject.interface[binding.param[0]].attachment.gateway.element).trigger("resetValue");
                                                                            }else if(
                                                                                binding.type == "callback"
                                                                                && binding.param!= undefined
                                                                            ){

                                                                                var name;
                                                                                if(
                                                                                    binding.param[0] != undefined
                                                                                ){
                                                                                    name = binding.param[0];
                                                                                }else if(
                                                                                    binding.param.name != undefined
                                                                                ){
                                                                                    name = binding.param.name;
                                                                                }else{
                                                                                    return false;
                                                                                }

                                                                                classObject.triggerFeature({
                                                                                    name : name,
                                                                                    argument : {
                                                                                        classObject : classObject,
                                                                                        elementParam : arg,
                                                                                    },
                                                                                });

                                                                            }
                                                                        }

                                                                    });
                                                                }


                                                            }


                                                            var trigger = handleMessages({
                                                                response : arg.response.body,
                                                                assessment : classObject.interface[serviceData.service_command.entity].attachment.assessment,
                                                                config : assessmentConfig
                                                            });


                                                            if(
                                                                trigger == true
                                                            ){
                                                                $(classObject.interface[serviceData.service_command.entity].attachment.assessment.element).trigger("show");
                                                            }

                                                        }else{
                                                            console.log(arg);

                                                            

                                                            classObject.interface[serviceData.service_command.entity].attachment.assessment.content.add({
                                                                exception : "service-response-invalid",
                                                                section : "error",
                                                                message : language_message("service-response-invalid"),
                                                                data : {
                                                                    config : {}
                                                                }
                                                            });

                                                            $(classObject.interface[serviceData.service_command.entity].attachment.assessment.element).trigger("show");
                                                        }

                                                        $(classObject.interface[serviceData.service_command.entity].attachment.cover.element).trigger("disable");
                                                    }
                                                },
                                                timeout: {
                                                    errorTimeout : function(arg){

                                                        classObject.interface[serviceData.service_command.entity].attachment.assessment.content.add({
                                                            exception : "service-timeout",
                                                            section : "error",
                                                            message : language_message("service-timeout"),
                                                            data : {
                                                                config : {}
                                                            }
                                                        });

                                                        $(classObject.interface[serviceData.service_command.entity].attachment.assessment.element).trigger("show");
                                                        $(classObject.interface[serviceData.service_command.entity].attachment.cover.element).trigger("disable");

                                                    }
                                                },
                                            }
                                        });

                                    }
                                }else if(
                                    feature.type == "callback"
                                ){

                                    if(
                                        feature.param.name != undefined
                                        && classObject.feature != undefined
                                        && classObject.feature.get() != undefined
                                        && classObject.feature.get()[feature.param.name] != undefined
                                    ){

                                        classObject.feature.get()[feature.param.name]({
                                            classObject : classObject,
                                            interfaceObject : interfaceObject,
                                            paramElement : paramElement,
                                            featureObject : feature
                                        });
                                    }
                                }
                            });

                        },
                        onReady : function(paramElement){

                            if(
                                data.feature != undefined
                            ){
                                $.each(data.feature, function(index, feature){

                                    var thisFeature;

                                    if(
                                        data.feature.isProto(index) == false
                                    ){

                                        thisFeature = breakParam(feature);

                                        if(
                                            thisFeature.param != undefined
                                            && thisFeature.param.moment != undefined
                                            && thisFeature.param.moment == "ready"
                                        ){

                                            if(
                                                thisFeature.type != undefined
                                            ){
                                                if(
                                                    thisFeature.type == "callback"
                                                ){

                                                    if(
                                                        thisFeature.param.name != undefined
                                                        && classObject.feature != undefined
                                                        && classObject.feature.get() != undefined
                                                        && classObject.feature.get()[thisFeature.param.name] != undefined
                                                    ){

                                                        classObject.feature.get()[thisFeature.param.name]({
                                                            classObject : classObject,
                                                            interfaceObject : interfaceObject,
                                                            paramElement : paramElement,
                                                            featureObject : thisFeature
                                                        });
                                                    }

                                                }else if(
                                                    thisFeature.type == "autoTrigger"
                                                ){
                                                    if(
                                                        thisFeature.param.type != undefined
                                                        && thisFeature.param.type == "button"
                                                        && interfaceObject.attachment != undefined
                                                        && interfaceObject.attachment["triggerField"] != undefined
                                                    ){
                                                        $(interfaceObject.attachment["triggerField"].element).trigger("click");
                                                    }
                                                }else{
                                                    console.debug("feature \""+thisFeature.type+"\" is unknown");
                                                }
                                            }
                                        }

                                    }

                                });
                            }

                        },
                    });
                    attachment.event.add({
                        trigger : ["setupInterfaceAssessment"],
                        onTrigger : function(paramElement){

                                if(
                                    classObject.status.entity == undefined
                                ){
                                    classObject.status.entity = {};
                                }

                                classObject.status.entity[interfaceObject.entity] = {
                                    mandatory : false,
                                    value : true
                                };

                                if(
                                    data.mandatory == "true"
                                ){
                                    classObject.status.entity[interfaceObject.entity].mandatory = true;
                                }

                                if(
                                    data.constraint != ""
                                ){
                                    classObject.status.entity[interfaceObject.entity].value = false;
                                }

                                if(
                                    data.section != undefined
                                ){
                                    if(
                                        classObject.status.section == undefined
                                    ){
                                        classObject.status.section = {};
                                    }

                                    if(
                                        classObject.status.section[data.section] == undefined
                                    ){
                                        classObject.status.section[data.section] = {};
                                    }

                                    classObject.status.section[data.section][interfaceObject.entity] = classObject.status.entity[interfaceObject.entity];

                                }

                                if(
                                    data.premise != undefined
                                ){
                                    $.each(data.premise, function(key, thisPremise){

                                        if(
                                            data.premise.isProto(key) == false
                                        ){
                                            thisPremise = breakParam(thisPremise);

                                            var handlePremise = function(functionParam){

                                                    var referedInterface = classObject.findDefinition(
                                                        [
                                                            [
                                                                {
                                                                    key : "name",
                                                                    value : "reference"
                                                                },
                                                                {
                                                                    key : "value",
                                                                    value : functionParam.target
                                                                },


                                                            ],

                                                        ]
                                                    );
                                                    $.each(referedInterface, function(entity, value){

                                                        handlePremise({
                                                            source : functionParam.source,
                                                            target : entity
                                                        });
                                                    });

                                                if(
                                                    functionParam.target != functionParam.source
                                                ){

                                                    var targetData = classObject.getDefinition({
                                                        entity : functionParam.target
                                                    })[functionParam.target];


                                                    if(
                                                        targetData.reference != undefined
                                                    ){
                                                        var targetEntity = targetData.entity;
                                                        targetData = classObject.getDefinition({
                                                            entity : targetData.reference
                                                        })[targetData.reference];
                                                        targetData.entity = targetEntity;

                                                    }

                                                    var sourceData = classObject.getDefinition({
                                                        entity : functionParam.source
                                                    })[functionParam.source];

                                                    if(
                                                        sourceData.reference != undefined
                                                    ){
                                                        var sourceEntity = sourceData.entity;
                                                        sourceData = classObject.getDefinition({
                                                            entity : sourceData.reference
                                                        })[sourceData.reference];
                                                        sourceData.entity = sourceEntity;
                                                    }

                                                    if(
                                                        targetData.mandatory == "true"
                                                        || sourceData.mandatory == "true"

                                                    ){

                                                        classObject.interface[sourceData.entity].attachment.assessment.content.add({
                                                            exception : "premise-entity:"+targetData.entity,
                                                            section : "info",
                                                            data : functionParam
                                                        });
                                                        $(classObject.interface[sourceData.entity].attachment.assessment.element).trigger("render");

                                                    }

                                                    if(
                                                        targetData.mandatory != undefined
                                                        && targetData.mandatory == "true"
                                                        && classObject.interface[targetData.entity] != undefined
                                                        && classObject.interface[targetData.entity].attachment != undefined
                                                        && classObject.interface[targetData.entity].attachment.assessment != undefined
                                                    ){

                                                        classObject.interface[targetData.entity].attachment.assessment.content.add({
                                                            exception : "implies-entity:"+sourceData.entity,
                                                            section : "info",
                                                            data : functionParam
                                                        });
                                                        $(classObject.interface[targetData.entity].attachment.assessment.element).trigger("render");

                                                    }

                                                }
                                            }

                                            if(
                                                thisPremise.type == "section"
                                            ){

                                                var relatedInterface = classObject.findDefinition(
                                                    [
                                                        [
                                                            {
                                                                key : "name",
                                                                value : "section"
                                                            },
                                                            {
                                                                key : "value",
                                                                value : thisPremise.param.name
                                                            },


                                                        ],

                                                    ]
                                                );

                                                $.each(relatedInterface, function(entity, thisInterface){


                                                    handlePremise({
                                                        source : data.entity,
                                                        target : entity
                                                    });

                                                });

                                            }else if(
                                                thisPremise.type == "entity"
                                            ){

                                                handlePremise({
                                                    source : data.entity,
                                                    target : thisPremise.param.name
                                                });

                                            }

                                        }
                                    });
                                }

                        },
                        onReady : function(paramElement){

                            $(paramElement).trigger("setupInterfaceAssessment");

                        }
                    });

                    attachment.event.add({
                        trigger : ["sync"],
                        onTrigger : function(paramElement){

                            if(
                                data.value != $(paramElement).val()
                            ){
                                $(paramElement).val(data.value).trigger("change").trigger("checkInterfaceConstraint");

                            }

                        },
                        onReady : function(paramElement){

                            $(paramElement).trigger("sync");

                        }
                    });

                    attachment.event.add({
                        trigger : ["change"],
                        onTrigger : function(paramElement){

                            if(
                                interfaceObject.attachment.gateway.element.disabled != true
                            ){
                                var currentValue = $(paramElement).val();
                                classObject.setDefinition({
                                    entity : data.entity,
                                    key : "value",
                                    value : currentValue,
                                });

                                if(
                                    data.feature != undefined
                                ){
                                    $.each(data.feature, function(key, feature){
                                        if(
                                            data.feature.isProto(key) == false
                                        ){
                                            thisFeature = breakParam(feature);

                                            if(
                                                thisFeature.param != undefined
                                                && thisFeature.param.moment != undefined
                                                && thisFeature.param.moment == "change"
                                            ){

                                                if(
                                                    thisFeature.type != undefined
                                                ){
                                                    if(
                                                        thisFeature.type == "callback"
                                                    ){

                                                        if(
                                                            thisFeature.param.name != undefined
                                                            && classObject.feature != undefined
                                                            && classObject.feature.get() != undefined
                                                            && classObject.feature.get()[thisFeature.param.name] != undefined
                                                        ){

                                                            classObject.feature.get()[thisFeature.param.name]({
                                                                classObject : classObject,
                                                                interfaceObject : interfaceObject,
                                                                paramElement : paramElement,
                                                                featureObject : thisFeature
                                                            });
                                                        }

                                                    }
                                                }
                                            }
                                        }
                                    });
                                }
                            }

                            $(paramElement).trigger("triggerInterfaceAttachment");

                        },
                        onReady : function(paramElement){

                        }
                    });

                    attachment.event.add({
                        trigger : ["triggerInterfaceAttachment"],
                        onTrigger : function(paramElement){

                            $.each(interfaceObject.attachment, function(key, attachment){

                                if(
                                    interfaceObject.attachment.isProto(key) == false
                                    && key.indexOf("Field") >= 0
                                    && attachment != undefined
                                ){
                                    $(attachment.element).trigger("sync");
                                }

                                if(
                                    interfaceObject.attachment.isProto(key) == false
                                    && key.indexOf("Display") >= 0
                                    && attachment != undefined
                                ){
                                    $(attachment.element).trigger("check");
                                }

                            });

                        },
                        onReady : function(paramElement){

                        }
                    });

                    attachment.event.add({
                        trigger : ["triggerRelatedInterfaceConstraintCheck"],
                        onTrigger : function(paramElement){


                            $.each(data.premise, function(key, premise){
                                if(
                                    data.premise.isProto(key) == false
                                ){
                                    premise = breakParam(premise);


                                    if(
                                        premise.type == "section"
                                    ){

                                        var related = classObject.findDefinition(
                                            [
                                                [
                                                    {
                                                        key : "name",
                                                        value : "section"
                                                    },
                                                    {
                                                        key : "value",
                                                        value : premise.param.name
                                                    },


                                                ],

                                            ]
                                        );
                                        $.each(related, function(entity, data){

                                            if(
                                                classObject.interface[entity] != undefined
                                                && classObject.interface[entity].attachment != undefined
                                                && classObject.interface[entity].attachment.gateway != undefined
                                                && classObject.interface[entity].attachment.gateway.element != undefined
                                            ){
                                                $(classObject.interface[entity].attachment.gateway.element).trigger("checkInterfaceConstraint");
                                            }

                                        });



                                    }else if(
                                        premise.type == "entity"
                                    ){

                                        if(
                                            classObject.interface[premise.param.name] != undefined
                                            && classObject.interface[premise.param.name].attachment != undefined
                                            && classObject.interface[premise.param.name].attachment.gateway != undefined
                                            && classObject.interface[premise.param.name].attachment.gateway.element != undefined
                                        ){
                                            $(classObject.interface[premise.param.name].attachment.gateway.element).trigger("checkInterfaceConstraint");
                                        }

                                    }

                                }
                            });


                        },
                        onReady : function(paramElement){

                        },
                    });

                    attachment.event.add({
                        trigger : ["disableInterfaceAttachment"],
                        onTrigger : function(paramElement){

                            interfaceObject.attachment.gateway.element.disabled = true;

                            $.each(interfaceObject.attachment, function(key, attachment){

                                if(
                                    interfaceObject.attachment.isProto(key) == false
                                    && $(attachment.element).hasClass("disabled") == false
                                ){

                                    $(attachment.element).addClass("disabled");
                                }

                            });

                        },
                        onReady : function(paramElement){

                            $(paramElement).trigger("disableInterfaceAttachment");
                        },
                    });

                    attachment.event.add({
                        trigger : ["enableInterfaceAttachment"],
                        onTrigger : function(paramElement){

                            interfaceObject.attachment.gateway.element.disabled = false;

                            $.each(interfaceObject.attachment, function(key, attachment){

                                if(
                                    interfaceObject.attachment.isProto(key) == false
                                    && $(attachment.element).hasClass("disabled") == true
                                ){

                                    $(attachment.element).removeClass("disabled");
                                }

                            });

                        },
                        onReady : function(paramElement){
                        },
                    });

                   attachment.event.add({
                        trigger : ["checkInterfaceConstraint"],
                        onTrigger : function(paramElement){

                            var data = classObject.getDefinition({
                                entity : interfaceObject.entity
                            })[interfaceObject.entity];

                            paramElement.constraint = interfaceObject.attachment.gateway.element.constraint;

                            if(
                                paramElement.constraint == undefined
                            ){
                                paramElement.constraint = {
                                    token : 0,
                                    status : {},
                                    report : true
                                };
                            }


                            if(
                                data.reference != undefined
                            ){
                                var refEntity = data.entity;
                                data = classObject.getDefinition({
                                    entity : data.reference
                                })[data.reference];
                                data.original = refEntity;
                            }else{
                                data.original = data.entity;
                            }

                            paramElement.constraint.report = true;
                            paramElement.constraint.token++;

                            $.each(data.constraint, function(key, constraint){

                                if(
                                    data.constraint.isProto(key) == true
                                ){
                                    return false;
                                }else{


                                    var type = constraint.split("(")[0];
                                    var backing = constraint.split("(")[1];

                                    if(
                                        backing != undefined
                                    ){
                                        backing = backing.replace(")", "");
                                        backing = backing.split(",");
                                    }else{
                                        backing = [];
                                    }

                                    var param = {};

                                    if(
                                        backing.length > 0
                                    ){

                                        $.each(backing, function(index, backing){

                                            if(
                                                backing.split(":")[1] != undefined
                                            ){
                                                param[backing.split(":")[0]] = backing.split(":")[1];
                                            }else{
                                                param[index] = backing;
                                            }

                                        });

                                    }

                                    if(
                                        classObject.constraint.get()[type] == undefined
                                    ){
                                        paramElement.constraint.status[type] = false;

                                    }else{

                                        paramElement.constraint.status[type] = classObject.constraint.get()[type]({
                                            config : param,
                                            element : paramElement,
                                            interface : interfaceObject,
                                            token : paramElement.constraint.token
                                        });


                                    }

                                    if(
                                        paramElement.constraint.status[type] == false
                                    ){
                                        paramElement.constraint.report = false;
                                    }
                                }

                            });

                            if(
                                data.mandatory != undefined
                                && classObject.status != undefined
                                && classObject.status.entity != undefined
                                && classObject.status.entity[interfaceObject.entity] != undefined

                            ){

                                if(
                                    paramElement.constraint != undefined
                                    && (
                                        paramElement.constraint.report == undefined
                                        || paramElement.constraint.report == false
                                    )
                                ){

                                    classObject.status.entity[interfaceObject.entity].value = paramElement.constraint.report;
                                }else{

                                    classObject.status.entity[interfaceObject.entity].value = true;
                                }

                                if(
                                    data.section != undefined
                                    && classObject.status.section[data.section] != undefined
                                ){

                                    classObject.status.section[data.section][interfaceObject.original] = classObject.status.entity[interfaceObject.entity];
                                }
                            }

                            interfaceObject.attachment.gateway.element.constraint = paramElement.constraint;



                            if(
                                interfaceObject.attachment.assessmentTrigger == undefined
                            ){
                                return false;

                            }else{

                                $(interfaceObject.attachment.assessmentTrigger.element).trigger("progress");

                                if(
                                    paramElement.constraint.report == false
                                ){
                                    var trigger = "error";

                                }else{
                                    var trigger = "success";
                                    $(interfaceObject.attachment.assessmentTrigger.element).trigger("success");

                                }

                                var checkStatus = function(trigger, token){

                                    if(
                                        token == paramElement.constraint.token
                                    ){
                                        $(interfaceObject.attachment.assessmentTrigger.element).trigger(trigger);
                                    }

                                }


                                var closure = function(currentToken, currentTrigger){

                                    var currentToken = currentToken;
                                    var currentTrigger = currentTrigger;

                                    setTimeout(function(){

                                        checkStatus(currentTrigger, currentToken);

                                    }, 250);

                                }

                                closure(paramElement.constraint.token, trigger);
                            }

                            $(paramElement).trigger("checkInterfaceAccess");


                            if(
                                data.section != undefined
                            ){
                                var refSection = classObject.findDefinition(
                                    [
                                        [
                                            {
                                                key : "name",
                                                value : "premise"
                                            },
                                            {
                                                key : "value",
                                                value : "section(name:"+data.section+")"
                                            },


                                        ]

                                    ]
                                );
                                $.each(refSection, function(entity, thisData){

                                    if(
                                        classObject.interface[entity] != undefined
                                    ){
                                       $(classObject.interface[entity].attachment.gateway.element).trigger("checkInterfaceAccess");
                                    }

                                });
                            }

                            var refEntity = classObject.findDefinition(
                                    [
                                        [
                                            {
                                                key : "name",
                                                value : "premise"
                                            },
                                            {
                                                key : "value",
                                                value : "entity(name:"+data.entity+")"
                                            },


                                        ]

                                    ]
                                );
                            $.each(refEntity, function(entity, thisData){

                                    if(
                                        classObject.interface[entity] != undefined
                                    ){
                                       $(classObject.interface[entity].attachment.gateway.element).trigger("checkInterfaceAccess");
                                    }

                                });




                        },
                        onReady : function(paramElement){
                        }
                    });

                    attachment.event.add({
                        trigger : ["checkInterfaceAccess"],
                        onTrigger : function(paramElement){

                            paramElement.premise = interfaceObject.attachment.gateway.element.premise;

                            if(
                                paramElement.premise == undefined
                            ){
                                paramElement.premise = {
                                    token : 0,
                                    status : {},
                                    report : true
                                };
                            }

                            paramElement.premise.token++;

                            var data = classObject.getDefinition({
                                entity : interfaceObject.entity
                            })[interfaceObject.entity];


                            if(
                                data.premise != undefined
                                && Object.keys(data.premise).length > 0
                            ){

                                $.each(data.premise, function(key, premise){


                                    if(
                                        data.premise.isProto(key) == false
                                    ){
                                        var thisPremise = breakParam(premise);

                                        if(
                                            thisPremise.type == "entity"
                                            && thisPremise.param.name != undefined
                                            && classObject.status.entity != undefined
                                            && classObject.status.entity[thisPremise.param.name] != undefined
                                            && classObject.status.entity[thisPremise.param.name].value == false
                                        ){
                                            paramElement.premise.report = false;
                                        }else if(
                                            thisPremise.type == "section"
                                            && thisPremise.param.name != undefined
                                            && classObject.status.section != undefined
                                            && classObject.status.section[thisPremise.param.name] != undefined
                                        ){

                                            $.each(classObject.status.section[thisPremise.param.name], function(entity, status){

                                                if(
                                                    status.value == false
                                                    && status.mandatory == true
                                                ){
                                                    paramElement.premise.report = false;
                                                }

                                            });
                                        }

                                    }


                                });
                            }

                            if(
                                paramElement.premise.report == false
                            ){
                                $(paramElement).trigger("disableInterfaceAttachment");
                            }else{
                                $(paramElement).trigger("enableInterfaceAttachment");
                            }

                            interfaceObject.attachment.gateway.premise = paramElement.premise;

                        },
                        onReady : function(paramElement){

                            $(paramElement).trigger("checkInterfaceAccess");

                        }
                    });

                    interfaceObject.attachment.set({
                        key : "gateway",
                        value : attachment
                    });

                },
                entity : thisEntity,
            });

            //placeholderDisplay
            classObject.defineInterface({
                condition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    if(
                        data == undefined
                    ){
                        return false;
                    }

                    return (data.type == "field" && (data.field == "text" || data.field == "password" || data.field == "textarea" || data.field == "dropdown"));

                },
                definition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    var attachment = new Surfable.Component(data);

                    attachment.template.set({
                        status : "ready",
                        template : "<label data-cinc-reference=\"{{entity}}\" data-cinc-attachment=\"placeholder\" >{{label}}</label>"
                    });

                    attachment.event.add({
                        trigger : ["check"],
                        onTrigger : function(paramElement){

                            var data = classObject.getDefinition({
                                entity : interfaceObject.entity
                            })[interfaceObject.entity];

                            if(
                                 paramElement.animation == undefined
                            ){
                                 paramElement.animation = {};
                            }

                            var fade = function(element, type, time){

                                element.animation.fading = true;

                                $(element)["slide"+type](time,function(){
                                    element.animation.fading = false;
                                });

                            }

                            if(
                                data.value != ""
                                || data.field == "dropdown"
                            ){

                                fade(paramElement, "Down", 250);

                            }else{

                                fade(paramElement, "Up", 250);
                            }

                        },
                        onReady : function(paramElement){

                            $(paramElement).trigger("check");

                        }
                    });

                    interfaceObject.attachment.set({
                        key : "placeholderDisplay",
                        value : attachment
                    });

                },
                entity : thisEntity,
            });

            //textField
            classObject.defineInterface({
                condition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    if(
                        data == undefined
                    ){
                        return false;
                    }

                    return (data.type == "field" && (data.field == "text" || data.field == "password" || data.field == "textarea" || data.field == "hidden"));

                },
                definition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    var attachment = new Surfable.Component(data);

                    if(
                        data.field == "textarea"
                    ){
                        attachment.template.set({
                            status : "ready",
                            template : "<textarea data-cinc-reference=\"{{entity}}\" data-cinc-attachment=\"field text area\" placeholder=\"{{label}}\">{{value}}</textarea>"
                        });
                    }else{
                        attachment.template.set({
                            status : "ready",
                            template : "<input data-cinc-reference=\"{{entity}}\" data-cinc-attachment=\"field text input\" type=\"{{field}}\" placeholder=\"{{label}}\">"
                        });
                    }


                    attachment.event.add({
                        trigger : ["change", "keypress", "keyup", "keydown", "focusout"],
                        onTrigger : function(paramElement){

                            if(
                                $(paramElement).val() != $(interfaceObject.attachment.gateway.element).val()
                            ){
                                $(interfaceObject.attachment.gateway.element).val($(paramElement).val()).trigger("change").trigger("checkInterfaceConstraint");
                            }

                        },
                        onReady : function(paramElement){

                            $(paramElement).trigger("sync");

                        }
                    });

                    attachment.event.add({
                        trigger : ["click", "focusin"],
                        onTrigger : function(paramElement){

                            $(interfaceObject.attachment.gateway.element).trigger("triggerRelatedInterfaceConstraintCheck");

                        },
                        onReady : function(paramElement){

                        }
                    });

                    attachment.event.add({
                        trigger : ["sync"],
                        onTrigger : function(paramElement){

                          if(
                            paramElement != undefined
                            && paramElement[0] != undefined
                          ){

                            var change;

                            if(
                              paramElement[0].type == "password"
                            ){
                              change = [" ", ""];
                            }else{
                              change = ["  ", " "];
                            }


                              //filer empty spaces from string
                              var i = 0;
                              while ($(paramElement).val().indexOf(change[0])>0 && i < 100) {
                                var phrase = $(paramElement).val();
                                $(paramElement).val(phrase.replace(change[0], change[1])).trigger("change");
                                i++;
                              }

                              var checkTrim = $(paramElement).val();
                              if(checkTrim.length != undefined && checkTrim[0] == " "){
                                $(paramElement).val($(paramElement).val().trim()).trigger("change");
                              }



                          }

                            var data = classObject.getDefinition({
                                entity : interfaceObject.entity
                            })[interfaceObject.entity];


                            if(
                                $(paramElement).val() != data.value
                            ){
                                $(paramElement).val(data.value).trigger("change");
                            }

                        },
                        onReady : function(paramElement){
                        }
                    });

                    interfaceObject.attachment.set({
                        key : "textField",
                        value : attachment
                    });

                },
                entity : thisEntity,
            });

            //dropdownField
            classObject.defineInterface({
                condition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    if(
                        data == undefined
                    ){
                        return false;
                    }

                    return (data.type == "field" && data.field == "dropdown");

                },
                definition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    var attachment = new Surfable.Component(data);


                    attachment.template.set({
                        status : "ready",
                        template : "<select data-cinc-reference=\"{{entity}}\" data-cinc-attachment=\"field dropdown\"></select>"
                    });

                    attachment.event.add({
                        trigger : ["sync"],
                        onTrigger : function(paramElement){
                            var data = classObject.getDefinition({
                                entity : interfaceObject.entity
                            })[interfaceObject.entity];

                            $.each(attachment.options, function(entity, object){

                                if(
                                    object.element == undefined
                                ){
                                    object.element = new Surfable.Component(object.data);
                                    object.element.template.set({
                                        status : "ready",
                                        template : "<option data-cinc-reference=\"{{entity}}\" data-cinc-attachment=\"field dropdown option\" value=\"{{value}}\">{{label}}</option>"
                                    });

                                    object.element.deploy({
                                        parent : paramElement,
                                    });
                                }

                            });

                            var selectedOption = $(paramElement).find("[value=\"" + data.value + "\"]");

                            if(
                                selectedOption.length == 1
                            ){
                                $(selectedOption).prop("selected", true);
                            }else{

                                if(
                                    selectedOption.length == 1
                                ){
                                    //none
                                }else{
                                    //many
                                }

                            }


                        },
                        onReady : function(paramElement){

                        }
                    });
                    attachment.event.add({
                        trigger : ["click"],
                        onTrigger : function(paramElement){

                            $(interfaceObject.attachment.gateway.element).trigger("triggerRelatedInterfaceConstraintCheck");

                        },
                        onReady : function(paramElement){

                        }
                    });

                    attachment.event.add({
                        trigger : ["change"],
                        onTrigger : function(paramElement){

                            if(
                                $(paramElement).val() != $(interfaceObject.attachment.gateway.element).val()
                                && interfaceObject.attachment.gateway.element.disabled != true
                            ){
                                $(interfaceObject.attachment.gateway.element).val($(paramElement).val()).trigger("change").trigger("checkInterfaceConstraint");
                            }

                            $("[data-cinc-option=\"" + data.entity + "\"]").trigger("check").trigger("checkInterfaceConstraint");
                            $(paramElement).trigger("sync");

                        },
                        onReady : function(paramElement){

                            $(paramElement).trigger("setupOptions");

                        },
                    });

                    attachment.event.add({
                        trigger : ["setupOptions"],
                        onTrigger : function(paramElement){

                            attachment.options = {};

                            var subs = classObject.findDefinition(
                                [
                                    [
                                        {
                                            key : "name",
                                            value : "field"
                                        },
                                        {
                                            key : "value",
                                            value : "option"
                                        },


                                    ],
                                    [
                                        {
                                            key : "name",
                                            value : "reference"
                                        },
                                        {
                                            key : "value",
                                            value : data.entity
                                        },


                                    ]

                                ]
                            );

                            $.each(subs, function(entity, data){

                                var test = classObject.getDefinition({
                                    entity : entity
                                });

                                attachment.options[entity] = {
                                    element : undefined,
                                    data : data
                                };

                            });

                            $(paramElement).trigger("sync");

                            watch(attachment.options, function(prop, action, difference, oldvalue){

                                $(paramElement).trigger("sync");

                            }, 0, true);
                        },
                        onReady : function(paramElement){
                        },
                    });

                    interfaceObject.attachment.set({
                        key : "dropdownField",
                        value : attachment
                    });

                },
                entity : thisEntity,
            });

            //optionField
            classObject.defineInterface({
                condition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    if(
                        data == undefined
                    ){
                        return false;
                    }

                    return (data.type == "field" && data.field == "option");

                },
                definition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    var attachment = new Surfable.Component(data);


                    attachment.template.set({
                        status : "ready",
                        template : "<button data-cinc-reference=\"{{entity}}\" data-cinc-option=\"{{reference}}\" data-cinc-attachment=\"field box radio\" value=\{{value}}\"><span class=\"box\"><span class=\"symbol glyphicon glyphicon-ok\"></span></span><label>{{body}}</label></button>"
                    });

                    attachment.event.add({
                        trigger : ["check"],
                        onTrigger : function(paramElement){

                            var data = classObject.getDefinition({
                                entity : interfaceObject.entity
                            })[interfaceObject.entity];

                             var refs = classObject.findDefinition(
                                [
                                    [
                                        {
                                            key : "name",
                                            value : "entity"
                                        },
                                        {
                                            key : "value",
                                            value : data.reference
                                        },


                                    ],

                                ]
                            );

                            $.each(refs, function(refEntity, refData){

                                var refOptions = classObject.findDefinition(
                                    [
                                        [
                                            {
                                                key : "name",
                                                value : "reference"
                                            },
                                            {
                                                key : "value",
                                                value : refEntity
                                            },


                                        ],
                                        [
                                            {
                                                key : "name",
                                                value : "field"
                                            },
                                            {
                                                key : "value",
                                                value : "option"
                                            },


                                        ],

                                    ]
                                );

                                $.each(refOptions, function(optionEntity, optionData){

                                    if(
                                        optionEntity != data.entity
                                    ){

                                    }else{

                                        var refData = classObject.getDefinition({
                                            entity : refEntity
                                        })[refEntity];

                                        var optionData = classObject.getDefinition({
                                            entity : optionEntity
                                        })[optionEntity];

                                        if(
                                            optionData.value != refData.value
                                        ){
                                            $(paramElement).removeClass("active");
                                        }else{
                                            $(paramElement).addClass("active");
                                        }

                                    }

                                });

                            });


                        },
                        onReady : function(paramElement){

                            $(paramElement).trigger("check");

                        }
                    });

                    attachment.event.add({
                        trigger : ["click"],
                        onTrigger : function(paramElement){



                            var data = classObject.getDefinition({
                                entity : interfaceObject.entity
                            })[interfaceObject.entity];

                             var refs = classObject.findDefinition(
                                [
                                    [
                                        {
                                            key : "name",
                                            value : "entity"
                                        },
                                        {
                                            key : "value",
                                            value : data.reference
                                        },


                                    ],

                                ]
                            );

                            $.each(refs, function(refEntity, refData){

                                if(
                                    data.value != refData.value
                                    && interfaceObject.attachment.gateway.element.disabled != true
                                ){
                                    $(classObject.interface[refEntity].attachment.gateway.element).val(data.value).trigger("change").trigger("checkInterfaceConstraint");
                                }

                            });

                            $("[data-cinc-option=\"" + data.reference + "\"]").trigger("check").trigger("checkInterfaceConstraint");
                            $(interfaceObject.attachment.gateway.element).trigger("triggerRelatedInterfaceConstraintCheck").trigger("checkInterfaceConstraint");
                        },
                        onReady : function(paramElement){

                        }
                    });


                    interfaceObject.attachment.set({
                        key : "optionField",
                        value : attachment
                    });

                },
                entity : thisEntity,
            });

            //triggerField
            classObject.defineInterface({
                condition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    if(
                        data == undefined
                    ){
                        return false;
                    }

                    return (data.type == "field" && data.field == "button");

                },
                definition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    var attachment = new Surfable.Component(data);

                    attachment.template.set({
                        status : "ready",
                        template : "<button data-cinc-reference=\"{{entity}}\" data-cinc-attachment=\"field button milestone finish\" value=\"{{value}}\"><span class=\"symbol unlocked glyphicon glyphicon-chevron-right\"></span><span class=\"symbol locked glyphicon glyphicon-lock\"></span><label>{{label}}</label></button>"
                    });

                    attachment.event.add({
                        trigger : ["click"],
                        onTrigger : function(paramElement){

                            if(
                                interfaceObject.attachment.gateway.element.disabled == true
                            ){

                                $(interfaceObject.attachment.gateway.element).trigger("triggerRelatedInterfaceConstraintCheck");
                                $(interfaceObject.attachment.assessment.element).trigger("show");

                            }else{

                                $(interfaceObject.attachment.gateway.element).trigger("feature");

                            }


                        },
                        onReady : function(paramElement){

                        }
                    });

                    interfaceObject.attachment.set({
                        key : "triggerField",
                        value : attachment
                    });

                },
                entity : thisEntity,
            });

            //checkboxField
            classObject.defineInterface({
                condition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    if(
                        data == undefined
                    ){
                        return false;
                    }

                    return (data.type == "field" && data.field == "checkbox");

                },
                definition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    var attachment = new Surfable.Component(data);

                    attachment.template.set({
                        status : "ready",
                        template : "<button data-cinc-reference=\"{{entity}}\" data-cinc-attachment=\"field box checkbox\" value=\"{{value}}\"><span class=\"box\"><span class=\"symbol glyphicon glyphicon-ok\"></span></span><label>{{body}}</label></button>"
                    });

                    attachment.event.add({
                        trigger : ["click"],
                        onTrigger : function(paramElement){

                            $(interfaceObject.attachment.gateway.element).trigger("triggerRelatedInterfaceConstraintCheck");

                            if(
                                interfaceObject.attachment.gateway.element.disabled == true
                            ){
                                return false;
                            }

                            var data = classObject.getDefinition({
                                entity : interfaceObject.entity
                            })[interfaceObject.entity];

                            if(
                                data.value != "true"
                            ){
                                $(interfaceObject.attachment.gateway.element).val("true").trigger("change").trigger("checkInterfaceConstraint");
                            }else{
                                $(interfaceObject.attachment.gateway.element).val("false").trigger("change").trigger("checkInterfaceConstraint");
                            }

                            $(paramElement).trigger("check");

                        },
                        onReady : function(paramElement){

                            $(paramElement).trigger("check");

                        }
                    });

                    attachment.event.add({
                        trigger : ["check"],
                        onTrigger : function(paramElement){

                            var data = classObject.getDefinition({
                                entity : interfaceObject.entity
                            })[interfaceObject.entity];

                            if(
                                data.value == "true"
                            ){
                                $(paramElement).addClass("active");
                            }else{
                                $(paramElement).removeClass("active");
                            }

                        },
                        onReady : function(paramElement){

                            $(paramElement).trigger("check");

                        }
                    });

                    attachment.event.add({
                        trigger : ["sync"],
                        onTrigger : function(paramElement){

                            $(paramElement).trigger("check");

                        },
                        onReady : function(paramElement){

                        }
                    });

                    interfaceObject.attachment.set({
                        key : "checkboxField",
                        value : attachment
                    });

                },
                entity : thisEntity,
            });
//cover
            classObject.defineInterface({
                condition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    if(
                        data == undefined
                    ){
                        return false;
                    }

                    return (data.type == "service_host" || data.type == "service_command" || (data.cover != undefined && data.cover != false && data.cover != "false"));

                },
                definition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    if(
                        data.icon == undefined
                    ){
                        data.icon = classObject.setDefinition({
                           entity : data.entity,
                           key : "icon",
                           value : "globe",
                       });
                    }

                    if(
                        data.style == undefined
                    ){

                       data.style = classObject.setDefinition({
                           entity : data.entity,
                           key : "style",
                           value : "static",
                       });

                    }

                    var attachment = new Surfable.Component(data);

                    attachment.template.set({
                        status : "ready",
                        template : "<div data-cinc-reference=\"{{entity}}\" data-cinc-attachment=\"cover\" class=\"{{style}}\"><span class=\"glyphicon glyphicon-{{icon}}\"></span></div>"
                    });

                    attachment.event.add({
                        trigger : ["disable"],
                        onTrigger : function(paramElement){

                            $(paramElement).hide(0);

                        },
                        onReady : function(paramElement){

                            $(paramElement).trigger("disable");

                        }
                    });

                    attachment.event.add({
                        trigger : ["enable"],
                        onTrigger : function(paramElement){

                            $(paramElement).show();

                        },
                        onReady : function(paramElement){

                        }
                    });

                    interfaceObject.attachment.set({
                        key : "cover",
                        value : attachment
                    });

                },
                entity : thisEntity,
            });
            //cover
            classObject.defineInterface({
                condition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    if(
                        data == undefined
                    ){
                        return false;
                    }

                    return (data.type == "service_host" || data.type == "service_command" || (data.cover != undefined && data.cover != false && data.cover != "false"));

                },
                definition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    if(
                        data.icon == undefined
                    ){
                        data.icon = classObject.setDefinition({
                           entity : data.entity,
                           key : "icon",
                           value : "globe",
                       });
                    }

                    if(
                        data.style == undefined
                    ){

                       data.style = classObject.setDefinition({
                           entity : data.entity,
                           key : "style",
                           value : "static",
                       });

                    }

                    var attachment = new Surfable.Component(data);

                    attachment.template.set({
                        status : "ready",
                        template : "<div data-cinc-reference=\"{{entity}}\" data-cinc-attachment=\"cover\" class=\"{{style}}\"><span class=\"glyphicon glyphicon-{{icon}}\"></span></div>"
                    });

                    interfaceObject.store = {
                        animation : {
                            speed : 0,//1,
                            threshold : 0.25,
                        }
                    };

                    attachment.event.add({
                        trigger : ["disable"],
                        onTrigger : function(paramElement){

                            var time = new Date;
                            var now = time.getTime();

                            interfaceObject.store.animation["cover-disable"] = now;
                            $(paramElement).fadeOut(interfaceObject.store.animation.speed*1000);



                        },
                        onReady : function(paramElement){

                            $(paramElement).trigger("disable");

                        }
                    });

                    attachment.event.add({
                        trigger : ["enable"],
                        onTrigger : function(paramElement){

                            var time = new Date;
                            var now = time.getTime();

                            interfaceObject.store.animation["cover-enable"] = now;

                            $(paramElement).fadeIn(interfaceObject.store.animation.speed*1000);

                        },
                        onReady : function(paramElement){

                        }
                    });

                    interfaceObject.attachment.set({
                        key : "cover",
                        value : attachment
                    });

                },
                entity : thisEntity,
            });

            //barrier
            classObject.defineInterface({
                condition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    if(
                        data == undefined
                    ){
                        return false;
                    }

                    return (data.type == "service_host" || data.type == "service_command" || (data.cover != undefined && data.cover != false && data.cover != "false"));

                },
                definition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    if(
                        data.icon == undefined
                    ){
                        data.icon = classObject.setDefinition({
                           entity : data.entity,
                           key : "icon",
                           value : "globe",
                       });
                    }

                    if(
                        data.style == undefined
                    ){

                       data.style = classObject.setDefinition({
                           entity : data.entity,
                           key : "style",
                           value : "static",
                       });

                    }

                    var attachment = new Surfable.Component(data);

                    attachment.template.set({
                        status : "ready",
                        template : "<div data-cinc-reference=\"{{entity}}\" data-cinc-attachment=\"barrier\" class=\"error\"><span class=\"glyphicon glyphicon-lock\"></span></div>"
                    });

                    attachment.event.add({
                        trigger : ["disable"],
                        onTrigger : function(paramElement){

                            $(paramElement).hide(0);

                        },
                        onReady : function(paramElement){

                            $(paramElement).trigger("disable");

                        }
                    });

                    attachment.event.add({
                        trigger : ["enable"],
                        onTrigger : function(paramElement){

                            $(paramElement).show();

                        },
                        onReady : function(paramElement){

                        }
                    });

                    interfaceObject.attachment.set({
                        key : "barrier",
                        value : attachment
                    });

                },
                entity : thisEntity,
            });

            //service_host
            classObject.defineInterface({
                condition : function(interfaceObject){

                    var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                    if(
                        data == undefined
                    ){
                        return false;
                    }

                    return (data.type == "service_host");

                },
                definition : function(interfaceObject){

                   var data = classObject.getDefinition({
                        entity : interfaceObject.entity
                    })[interfaceObject.entity];

                   interfaceObject.service_host = new Surfable.API({
                        url : data.url,
                        auth : {
                            account : data.account,
                            secret : data.secret,
                            group : data.group,
                        },
                   });

                   var attachment = new Surfable.Component(data);

                    attachment.template.set({
                        status : "ready",
                        template : "<div data-cinc-reference=\"{{entity}}\" data-cinc-attachment=\"api\"></div>"
                    });

                   attachment.event.add({
                        trigger : ["setup"],
                        onTrigger : function(paramElement){

                            interfaceObject.service_host.setup({
                                callback : {
                                    before: {
                                        enableCover : function(arg){

                                            $(interfaceObject.attachment.cover.element).trigger("enable");

                                        }
                                    },
                                    error: {
                                        errorConnectivity : function(arg){

                                            interfaceObject.attachment.assessment.content.add({
                                                exception : "service-failed",
                                                section : "error",
                                                message : language_message("service-failed"),
                                                data : {
                                                    config : interfaceObject.service_host.config
                                                }
                                            });

                                            $(interfaceObject.attachment.assessment.element).trigger("show");

                                        }
                                    },
                                    success: {
                                        disableCover : function(arg){

                                            $(interfaceObject.attachment.cover.element).trigger("disable");

                                        }
                                    },
                                    timeout: {
                                        errorTimeout : function(arg){

                                            interfaceObject.attachment.assessment.content.add({
                                                exception : "service-timeout",
                                                section : "error",
                                                message : language_message("service-timeout"),
                                                data : {
                                                    config : interfaceObject.service_host.config
                                                }
                                            });

                                            $(interfaceObject.attachment.assessment.element).trigger("show");
                                            $(interfaceObject.attachment.cover.element).trigger("disable");

                                        }
                                    }
                                }
                            });

                        },
                        onReady : function(paramElement){

                            $(paramElement).trigger("setup");

                        }
                    });

                   interfaceObject.attachment.set({
                        key : "service_host",
                        value : attachment
                    });

                },
                entity : thisEntity,
            });
        }
	}


	global[objectName][className] = Class;

}(window));
(function(global){

	var objectName = "Surfable";
	var className = "Assessment";

    var Private = {
        title : "Info: &quot;{{label}}&quot;",
        body : "",
    };

	var Class = function(methodParam){

		var classObject = this;

        var thisParam = defaultize(methodParam, {
		});

		return classObject;

	}

    Class.prototype.render = function(mathodParam){

        var markup = "";
        markup += "<div data-cinc-reference=\"{{entity}}\" data-cinc-attachment=\"constraint modal\" class=\"modal\" tabindex=\"-1\" role=\"dialog\">";
            markup += "<div class=\"modal-wrapper\">";
                markup += "<div class=\"modal-dialog\">";
                    markup += "<div class=\"modal-content\">";
                        markup += "<div class=\"modal-header\">";
                            markup += "<button type=\"button\" class=\"modal-close\"><span class=\"glyphicon glyphicon-remove\"></span></button>";
                            markup += "<h3 class=\"modal-title\">" + Private.title + "</h3>";
                        markup += "</div>";
                        markup += "<div class=\"modal-body\">" + Private.body + "</div>";
                        markup += "<div class=\"modal-footer\">";
                            markup += "<button type=\"button\" class=\"modal-close\">Schließen</button>";
                        markup += "</div>";
                    markup += "</div><!-- /.modal-content -->";
                markup += "</div><!-- /.modal-dialog -->";
            markup += "</div><!-- /.modal-wrapper -->";
        markup += "</div><!-- /.modal -->";

    }



    Class.prototype.deploy = function(mathodParam){

        var attachment = new Surfable.Component(data);



                attachment.template.set({
                    status : "ready",
                    template : markup
                });

                attachment.event.add({
                    trigger : ["show"],
                    onTrigger : function(paramElement){
                        $(paramElement).trigger("render");
                        $(paramElement).modal("show");

                    },
                    onReady : function(paramElement){

                        $(paramElement).find(".modal-close").click(function(){
                            $(paramElement).modal("hide");
                        });

                    }
                });

                attachment.event.add({
                    trigger : ["render"],
                    onTrigger : function(paramElement){

                        $(attachment.element).find(".modal-body").each(function(){

                            var list = "<ul>";
                            var items = "";

                            $.each(attachment.messages, function(code, data){

                                var pre;

                                if(
                                    data.config != undefined
                                ){
                                    pre = {
                                        value : $(data.element).val(),
                                        config : data.config,
                                    };

                                }else{
                                    pre = JSON.stringify(pre);
                                }

                                items += "<li>"+ code + "<pre>" + JSON.stringify(pre) + "</pre></li>";
                            });

                            if(
                                items.length == 0
                            ){
                                items += "<li>no-messages</li>";
                            }

                            list += items;
                            list += "</ul>";

                            $(this).html(list);


                        });

                    },
                    onReady : function(paramElement){

                    }
                });


    }



	global[objectName][className] = Class;

}(window));