function play() {
    Ext.Ajax.request(
    {
        waitMsg	: 'Initialiseren...',
        url	: '/member/get-club',
        method	: 'GET',
        callback: function (options, success, response) {
            var data = Ext.util.JSON.decode(response.responseText);
            if (data.msg.length > 0) {
                Ext.MessageBox.alert('Opgepast', data.msg);
            } else {
                go(data.wisselPeriode);
            }
        },
        failure:function(response,options){
            Ext.MessageBox.alert('Ogepast','Oops, er ging iets fout. Probeer opnieuw of neem contact op met de webmaster');
        }
    });
}

function go(wisselPeriode) {
    var wissels = 2;
    var wisselSpeler1 = "";
    var wisselSpeler2 = "";
    var wisselWissel1 = "";
    var wisselWissel2 = "";

    var keepers;
    var verdedigers;
    var middenvelders;
    var aanvallers;
    var keepersR;
    var verdedigersR;
    var middenveldersR;
    var aanvallersR;
    
    var max;
    var min;

    var selectedTeams = new Array();

    Ext.QuickTips.init();
    var xg = Ext.grid;

    /**
     * checkbox plugin
     */
    Ext.grid.CheckColumn = function(config){
        Ext.apply(this, config);
        if(!this.id){
            this.id = Ext.id();
        }
        this.renderer = this.renderer.createDelegate(this);
    };
    Ext.grid.CheckColumn.prototype ={
        init : function(grid){
            this.grid = grid;
            this.grid.on('render', function(){
                var view = this.grid.getView();
                view.mainBody.on('mousedown', this.onMouseDown, this);
            }, this);
        },

        onMouseDown : function(e, t){
            if(t.className && t.className.indexOf('x-grid3-cc-'+this.id) != -1){
                e.stopEvent();
                var index = this.grid.getView().findRowIndex(t);
                var record = this.grid.store.getAt(index);
                if (typeof(record.data.reserve) == "undefined" ||record.data.reserve == false) {
                    if (addCheckbox(record)) {
                        record.set(this.dataIndex, !record.data[this.dataIndex]);
                    }
                } else {
                    record.set(this.dataIndex, !record.data[this.dataIndex]);
                }
                counter();
            }
        },

        renderer : function(v, p, record){
            if (wisselPeriode) {
                return '<input class=" x-form-checkbox x-form-field" type="checkbox" autocomplete="off" value="1" disabled=""' + (v?'checked="checked"':'') + ' />';
            } else {
                p.css += ' x-grid3-check-col-td';
                return '<div class="x-grid3-check-col'+(v?'-on':'')+' x-grid3-cc-'+this.id+'">&#160;</div>';
            }
        }
    };

    // first grid
    var fields = Ext.data.Record.create([
        {name: 'speler_id',	type: 'int'}
        ,{name: 'team_id',	type: 'int'}
        ,{name: 'team',		type: 'string'}
        ,{name: 'voornaam',	type: 'string'}
        ,{name: 'achternaam',	type: 'string'}
        ,{name: 'type',		type: 'int'}
        ,{name: 'positie',	type: 'string'}
    ]);

    var firstGridStore = new Ext.data.GroupingStore({
        id: 'firstGridStore'
        ,proxy: new Ext.data.HttpProxy({
            url     : '/member/get-left-grid'
            ,method : 'GET'
        })
        ,groupField: 'team_id'
        ,reader: new Ext.data.JsonReader({
            root            : 'results',
            totalProperty   : 'total',
            id              : 'speler_id'
        },fields)
        ,autoLoad	: true
        ,remoteGroup: true
        ,remoteSort : true
        ,listeners	: {'load' : function() {
            var teams = [];
            var count = 0
            this.data.each(function() {
                if(!teams[this.data.team_id]) { // max en min berekenen;
                    teams[this.data.team_id] = this.data.achternaam;
                    count++;
                }
            });
            max = Math.ceil(15 / count);
            min = Math.floor(15 / count);
            templateApply();

            
            /* delay opzetten want zeer uitzonderlijk kan het zijn dat second grid store geladen is voor first grid store */
            compute = new Ext.util.DelayedTask(function(){
                /** hacky way start **/
                secondGridStore.data.each(function(record) {
                    rm = firstGridStore.getById(this.data.speler_id);
                    if(rm) {
                        firstGridStore.remove(rm);
                    }
                });
                /** hacky way end **/
            },this);
            compute.delay(1000);
        }}
    });
	
    var cellActions = new Ext.ux.grid.CellActions({
        listeners: {
            action: function (grid, record, action, value) {
                addRowRight(record);
            }
            ,beforeaction: function () {	}
        }
        ,callbacks: { }
        ,align: 'left'
    });

    var resultsColumnModel1 = new xg.ColumnModel(
    [
        {
            header	: '#'
            ,hidden	: true
            ,dataIndex	: 'speler_id'
            ,width      : 50
        },{
            header	: 'Teams_Id'
            ,hidden	: true
            ,dataIndex	: 'team_id'
            ,width	: 50
        },{
            header	: 'Voornaam'
            ,dataIndex	: 'voornaam'
            ,width	: 110
            ,sortable	: true
        },{
            header	: 'Achternaam'
            ,dataIndex	: 'achternaam'
            ,width	: 110
            ,sortable	: true
        },{
            header	: 'Positie'
            ,dataIndex	: 'positie'
            ,width	: 75
            ,sortable	: true
        },{
            header	: ""
            ,width	: 25
            ,sortable	: true
            ,cellActions: [{
                iconCls	: 'add'
            }]
            ,dataIndex	: 'empty'
            ,hidden     : wisselPeriode
        }
    ]);
    resultsColumnModel1.defaultSortable= true;

    var filters = new Ext.ux.grid.GridFilters({
        filters	: [
            {type: 'string',	dataIndex: 'voornaam'}
            ,{type: 'string',	dataIndex: 'achternaam'}
            ,{type: 'string',	dataIndex: 'positie'}
        ]
        ,local	: true
    });
	
    var groupingview = new Ext.grid.GroupingView({
        startCollapsed      : false
        ,showGroupName      : false
        ,hideGroupedColumn  : false
        ,enableGroupingMenu : false
        ,groupTextTpl       : '{[values.rs[0].data["team"]]}'
        ,startCollapsed     : true
    });

    var firstGrid =  new xg.GridPanel({
        id                  : 'firstGrid'
        ,enableColumnHide   : false
        ,view               : groupingview
        ,ddGroup            : 'secondGridDDGroup'
        ,store              : firstGridStore
        ,cm                 : resultsColumnModel1
        ,sm                 : new Ext.grid.RowSelectionModel({singleSelect: true})
        ,enableDragDrop     : true
        ,title              : 'Spelers'
        ,plugins            : [filters,cellActions]
        ,height             : 520
        ,width              : 345
        ,region             : 'west'
        ,stripeRows         : true
    });

    // second grid
    var checkColumn = new Ext.grid.CheckColumn({
        header		: "Reserve"
        ,dataIndex	: 'reserve'
        ,width		: 55
        ,sortable	: true
    });

    var fields1 = Ext.data.Record.create([
        {name: 'speler_id',	type: 'int'}
        ,{name: 'team_id',	type: 'int'}
        ,{name: 'team',		type: 'string'}
        ,{name: 'voornaam',	type: 'string'}
        ,{name: 'achternaam',	type: 'string'}
        ,{name: 'type',		type: 'int'}
        ,{name: 'positie',	type: 'string'}
        ,{name: 'reserve',	type: 'bool'}
        ,{name: 'empty',	type: 'string'}
    ]);

    var secondGridStore = new Ext.data.Store({
        id      : 'secondGridStore',
        proxy   : new Ext.data.HttpProxy({
            url	: '/member/get-right-grid',
            method: 'GET'
        }),
        baseParams  : {wisselPeriode: wisselPeriode},
        reader: new Ext.data.JsonReader({
            root            : 'results',
            totalProperty   : 'total',
            id              : 'speler_id'
        }, fields1)
        ,autoLoad   : true
        ,listeners  : {
            load : function() {
                /* delay opzetten want zeer uitzonderlijk kan het zijn dat second grid store geladen is voor first grid store */
                compute = new Ext.util.DelayedTask(function(){
                    /* teams initialiseren */
                    firstGridStore.data.each(function(record) {
                        selectedTeams[record.data.team_id] = 0; // teams initialiseren om aantal spelers per team te tellen;
                    });

                    this.data.each(function() {
                        if(this.data.reserve) {addCheckbox(this);}

                        /* aantal geslecteerde spelers per team */
                        selectedTeams[this.data.team_id]++;

                        /** hacky way start **/
                        rm = firstGridStore.getById(this.data.speler_id);
                        if(rm) {
                            firstGridStore.remove(rm);
                        }
                        /** hacky way end **/
                    });
                    counter();
                },this);
                compute.delay(1000);
            }
        }
    });

    var cellActions = new Ext.ux.grid.CellActions({
        listeners: {
            action: function (grid, record, action, value) {
                removeRowRight(record);
            }
            ,beforeaction: function () {	}
        }
        ,callbacks: { }
        ,align: 'left'
    });

    resultsColumnModel2 = new xg.ColumnModel(
    [
        {
            header	: '#'
            ,hidden	: true
            ,dataIndex	: 'speler_id'
            ,width	: 50
        },{
            header	: 'Teams_Id'
            ,hidden	: true
            ,dataIndex	: 'team_id'
            ,width	: 50
        },{
            header	: 'Team'
            ,dataIndex	: 'team'
            ,width	: 150
            ,sortable	: true
        },{
            header	: 'Voornaam'
            ,dataIndex	: 'voornaam'
            ,width	: 125
            ,sortable	: true
        },{
            header	: 'Achternaam'
            ,dataIndex	: 'achternaam'
            ,width	: 125
            ,sortable	: true
        },{
            header	: 'Positie'
            ,dataIndex	: 'positie'
            ,width	: 75
            ,sortable	: true
        }
        ,checkColumn
        ,{
            header	: ""
            ,width	: 25
            ,sortable	: false
            ,cellActions: [{
                iconCls	: 'delete'
            }]
            ,dataIndex	: 'empty'
            ,hidden     : wisselPeriode
        }
    ]);
    resultsColumnModel2.defaultSortable= true;

    var secondGrid = new xg.GridPanel({
    	id		: 'secondGrid'
    	,enableColumnHide   : false
        ,ddGroup	: 'firstGridDDGroup'
        ,store		: secondGridStore
        ,cm		: resultsColumnModel2
        ,sm		: new Ext.grid.RowSelectionModel({singleSelect: true})
        ,enableDragDrop	: true
        ,title		: 'Dreamteam'
        ,plugins	: [checkColumn, cellActions]
        ,collapsible	: false
        ,animCollapse	: false
        ,region		: 'center'
        ,stripeRows	: true
        ,clicksToEdit	: 1
        ,tbar: [{
            'text'	: 'Opslaan'
            ,'handler'	: save
            ,'iconCls'	: 'save'
            ,'tooltip'	: 'Dreamteam opslaan'
            ,'id'	: 'save'
        },{
            'text'      : 'Wissel spelers'
            ,'handler'  : wissel
            ,'iconCls'  : 'change'
            ,'tooltip'  : 'Wissel spelers'
            ,'id'       : 'wissel'
            ,'hidden'   : !wisselPeriode
        },{
            'text'      : 'Wissels ongedaan maken'
            ,'handler'  : ongedaan
            ,'iconCls'  : 'undo'
            ,'tooltip'  : 'Wissels ongedaan maken'
            ,'id'       : 'ongedaan'
            ,'hidden'   : !wisselPeriode
        }]
    });
    if (!wisselPeriode) {
        secondGrid.on('rowdblclick', function(grid, rowIndex, e) {removeRowRight(grid.getStore().getAt(rowIndex));});
    }
    
    /* wissels opslaan */
    function save() {
        if ( !(keepers == 0 && verdedigers == 0 && middenvelders == 0 && aanvallers == 0
             && keepersR == 0 && verdedigersR == 0 && middenveldersR == 0 && aanvallersR == 0) )
        {
            Ext.MessageBox.alert('Opgepast', 'U dient 15 spelers te selecteren, waarvan 4 reserve spelers.<br />Zoals aangegeven in het infovenster');
            return false;
        }

        for(team in selectedTeams) {
            if(selectedTeams[team] < min) {
                Ext.MessageBox.alert('Opgepast', 'U dient van elk team minstens ' + min + ' spelers te selecteren.<br />Zoals aangegeven in het infovenster');
                return false;
            }
        }

        for(team in selectedTeams) {
            if(selectedTeams[team] > max) {
                Ext.MessageBox.alert('Opgepast', 'U mag maximum ' + max + ' spelers uit een team selecteren.<br />Zoals aangegeven in het infovenster');
                return false;
            }
        }

        commitSave();
    }
    function commitSave() {
        var count=0;
        var spelerArray = [];
        var serializedSpelers = false;

        secondGridStore.data.each(function() {
            speler = this.data;
            spelerArray[count++] = speler;
        });
        serializedSpelers = Ext.encode(spelerArray);

        Ext.Ajax.request({
            waitMsg	: 'Wijzigingen opslaan...',
            url		: '/member/save',
            method	: 'POST',
            params	: {
                spelers         : serializedSpelers
                ,wisselPeriode  : wisselPeriode
            },
            callback	: function (options, success, response) {
                Ext.Msg.show({
                    title	:'Opslaan'
                    ,msg	: 'Uw dreamteam werd succesvol opgeslagen'
                    ,buttons    : Ext.Msg.OK
                    ,fn		: function() { window.location = "/member/team_bekijken"; }
                    ,animEl	: 'elId'
                    ,icon	: Ext.MessageBox.INFO
                });
            },
            failure:function(response,options){
                Ext.MessageBox.alert('Ogepast','Oops, er ging iets fout. Probeer opnieuw of neem contact op met de webmaster');
            }
        });
    }

    /* wissel-knop klik */
    function wissel() {
        leftRecord = firstGrid.getSelectionModel().getSelected();
        rightRecord = secondGrid.getSelectionModel().getSelected();

        if (wissels == 0) {
            Ext.MessageBox.alert('Opgepast','U heeft reeds twee wissels doorgevoerd');return false;
        }
        if (!leftRecord || !rightRecord) {
            Ext.MessageBox.alert('Opgepast','Selecteer een speler in het linker overzicht en een speler met dezelfde positie in het rechter overzicht');return false;
        }
        if (leftRecord.data.type != rightRecord.data.type) {
            Ext.MessageBox.alert('Opgepast','De spelers die u wilt wisselen dienen op dezelfde positie te spelen');return false;
        }
        
        naamSpeler = rightRecord.data.voornaam + " " + rightRecord.data.achternaam;
        naamWissel = leftRecord.data.voornaam + " " + leftRecord.data.achternaam;
        if (naamWissel == wisselSpeler1 || naamWissel == wisselSpeler2 || naamSpeler == wisselWissel1 ||naamSpeler == wisselWissel2) {
            Ext.MessageBox.alert('Opgepast','U heeft reeds een wissel uitgevoerd met deze speler(s)');return false;
        }

        leftRecord.data.reserve = rightRecord.data.reserve;

        removeRowRight(rightRecord);
        if (!addRowRight(leftRecord)) {
            addRowRight(rightRecord);
        } else {
            if (wisselSpeler1.length > 0 && wisselWissel1.length > 0) {
                wisselSpeler2 = naamSpeler;
                wisselWissel2 = naamWissel;
            } else {
                wisselSpeler1 = naamSpeler;
                wisselWissel1 = naamWissel;
            }
            wissels--;
        }
    }

    /* wissels ongedaan maken */
    function ongedaan() {
        wissels = 2;

        keepers = 1;
        verdedigers = 4;
        middenvelders = 3;
        aanvallers = 3;
        keepersR = 1;
        verdedigersR = 1;
        middenveldersR = 1;
        aanvallersR = 1;

        Ext.Ajax.request({
            waitMsg : 'Wijzigingen opslaan...',
            url     : '/member/undo-wissel',
            method  : 'GET',
            callback: function (options, success, response) {
                Ext.Msg.show({
                    title	:'Opslaan'
                    ,msg	: 'Alle wissels werden ongedaan gemaakt'
                    ,buttons    : Ext.Msg.OK
                    ,animEl	: 'elId'
                    ,icon	: Ext.MessageBox.INFO
                });
                firstGridStore.load();
                secondGridStore.load();
                getWissels();
            },
            failure:function(response,options){
                Ext.MessageBox.alert('Ogepast','Oops, er ging iets fout. Probeer opnieuw of neem contact op met de webmaster');
            }
        });
    }

    /* kijken of er reeds wissels gebeurd zijn */
    function getWissels() {
        Ext.Ajax.request({
            waitMsg : 'Get wisselspelers',
            url     : '/member/get-wisselspelers',
            method  : 'GET',
            callback: function (options, success, response) {
                var data = Ext.util.JSON.decode(response.responseText);
                if (data.speler1.length > 0 && data.wissel1.length > 0) {
                    wisselSpeler1 = data.speler1;
                    wisselWissel1 = data.wissel1;
                    wissels--;
                }
                if (data.speler2.length > 0 && data.wissel2.length > 0){
                    wisselSpeler2 = data.speler2;
                    wisselWissel2 = data.wissel2;
                    wissels--;
                }
                if (data.speler2.length == 0 && data.speler1.length == 0) {
                    wissels = 2;
                    wisselSpeler1 = "";
                    wisselWissel1 = "";
                    wisselSpeler2 = "";
                    wisselWissel2 = "";
                }
            }
        });
    }
    if (wisselPeriode) {
        getWissels();
    }

    // infopanel
    var panel = new Ext.Panel({
        id              : 'panel'
        ,title          : 'info'
        ,height         : 250
        ,region         : 'south'
        ,bodyCssClass   : 'infoBox'
    });

    // create panel
    var displayPanel = new Ext.Panel({
        layout  : 'border'
        ,items  : [
            firstGrid
            ,secondGrid
            ,panel
        ]
    });
	
    // show window
    var win = new Ext.Window({
        layout  : 'fit'
        ,y	: 10
        ,width	: 972
        ,height	: 670
        ,closable   : true
        ,resizable  : false
        ,plain	: true
        ,modal	: true
        ,shadow	: true
        ,items	: [displayPanel]
    });
    win.show();

    secondGridStore.sort('type', 'ASC');

    // drag&drop
    if (!wisselPeriode) {
        var firstGridDropTargetEl =  firstGrid.getView().el.dom.childNodes[0].childNodes[1];
        var firstGridDropTarget = new Ext.dd.DropTarget(firstGridDropTargetEl, {
            ddGroup    : 'firstGridDDGroup',
            copy       : false,
            notifyDrop : function(ddSource, e, data){
                function addRow(record, index, allItems) {
                   removeRowRight(record)
                }
                Ext.each(ddSource.dragData.selections ,addRow);
                return(true);
            }
        });
        var secondGridDropTargetEl = secondGrid.getView().el.dom.childNodes[0].childNodes[1]
        var destGridDropTarget = new Ext.dd.DropTarget(secondGridDropTargetEl, {
            ddGroup    : 'secondGridDDGroup',
            copy       : false,
            notifyDrop : function(ddSource, e, data){
                function addRow(record, index, allItems) {
                    addRowRight(record);
                }
                Ext.each(ddSource.dragData.selections ,addRow);
                return(true);
            }
        });
    }

    // actions
    var addRowRight = function(record) {
        if (selectedTeams[record.data.team_id] == max) {
            Ext.MessageBox.alert('Opgepast','U mag maximum ' + max + ' spelers uit 1 team selecteren');return false;
        }

        selectedTeams[record.data.team_id]++;

        firstGridStore.remove(record);
        secondGridStore.add(record);

        currentSort = secondGridStore.getSortState();
        secondGridStore.sort(currentSort.field, currentSort.direction);

        counter();
        return true;
    }
	
    var removeRowRight = function(record) {
        selectedTeams[record.data.team_id]--;

        firstGridStore.load();
        secondGridStore.remove(record);

        counter();
        return true;
    }

    // checkbox click
    var addCheckbox = function(record) {
        switch(record.data.type) {
            case 1:
                if (keepersR == 0) {Ext.MessageBox.alert('Opgepast','maximum aantal reserve keepers reeds bereikt');return false;}
                break;
            case 2:
                if (verdedigersR == 0) {Ext.MessageBox.alert('Opgepast','maximum aantal reserve verdedigers reeds bereikt');return false;}
                break;
            case 3:
                if (middenveldersR == 0) {Ext.MessageBox.alert('Opgepast','maximum aantal reserve middenvelders reeds bereikt');return false;}
                break;
            case 4:
                if (aanvallersR == 0) {Ext.MessageBox.alert('Opgepast','maximum aantal reserve aanvallers reeds bereikt');return false;}
                break;
        }
        return true;
    }
	
    // counter
    var counter = function() {
        keepers = 1;
        verdedigers = 4;
        middenvelders = 3;
        aanvallers = 3;
        keepersR = 1;
        verdedigersR = 1;
        middenveldersR = 1;
        aanvallersR = 1;

        secondGridStore.data.each(function() {
            speler	= this.data;
            switch(speler.type) {
                case 1:
                    if (speler.reserve) keepersR--;	else keepers--;
                    break;
                case 2:
                    if (speler.reserve) verdedigersR--; else verdedigers--;
                    break;
                case 3:
                    if (speler.reserve) middenveldersR--; else middenvelders--;
                    break;
                case 4:
                    if (speler.reserve) aanvallersR--; else aanvallers--;
                    break;
            }
        });
        templateApply();
    }
	
    // template
    var templateApply = function() {
        if (wisselPeriode) {
            txt = "<table style='width:100%'><tr><td valign='top' style='width:50%'>";
            txt += "U kan nog {wissels} wissels doorvoeren<br /><br />";
            txt += "wissel 1: {wisselSpeler1} => {wisselWissel1}<br />";
            txt += "wissel 2: {wisselSpeler2} => {wisselWissel2}<br /><br />";
            txt += "Heeft u een fout gemaakt, dan kan u altijd terug naar uw oorspronkelijk team door op de knop 'wissels ongedaan maken' te klikken";
            txt += "</td></tr></table>";

            var template = new Ext.XTemplate(txt);
            html = template.apply({
                'wissels' : wissels
                ,'wisselSpeler1' : wisselSpeler1
                ,'wisselSpeler2' : wisselSpeler2
                ,'wisselWissel1' : wisselWissel1
                ,'wisselWissel2' : wisselWissel2
            });
        } else {
            txt = "<table style='width:100%'><tr><td valign='top' style='width:50%'>"
            txt += keepers<0?"<font color='red'>U heeft {keepers * (-1)} keeper(s) teveel geselecteerd</font><br />":"U dient nog {keepers} keeper(s) te selecteren<br />"
            txt += "U dient nog {keepersR} reserve keeper te selecteren<br /><br />";
            txt += verdedigers<0?"<font color='red'>U heeft {verdedigers * (-1)} verdediger(s) teveel geselecteerd</font><br />":"U dient nog {verdedigers} verdediger(s) te selecteren<br />"
            txt += "U dient nog {verdedigersR} reserve verdediger te selecteren<br /><br />";
            txt += middenvelders<0?"<font color='red'>U heeft {middenvelders * (-1)} middenvelder(s) teveel geselecteerd</font><br />":"U dient nog {middenvelders} middenvelder(s) te selecteren<br />"
            txt += "U dient nog {middenveldersR} reserve middenvelder te selecteren<br /><br />";
            txt += aanvallers<0?"<font color='red'>U heeft {aanvallers * (-1)} aanvaller(s) teveel geselecteerd</font><br />":"U dient nog {aanvallers} aanvaller(s) te selecteren<br />"
            txt += "U dient nog {aanvallersR} reserve aanvaller te selecteren<br />";
            txt += "</td><td valign='top'>";
            txt += "Minimum {min} uit elk team selecteren<br />";
            txt += "Maximum {max} uit elk team selecteren<br />";
            txt += "</td></tr></table>";

            var template = new Ext.XTemplate(txt);
            html = template.apply({
                    'keepers' : keepers
                    ,'keepersR' : keepersR
                    ,'verdedigers' : verdedigers
                    ,'verdedigersR' : verdedigersR
                    ,'middenvelders' : middenvelders
                    ,'middenveldersR' : middenveldersR
                    ,'aanvallers' : aanvallers
                    ,'aanvallersR' : aanvallersR
                    ,'min' : min
                    ,'max' : max
            });
        }
        panel.body.update(html);
    }
}

function nieuwseizoen() {
    Ext.Ajax.request({
        url     : '/member/nieuwseizoen',
        method	: 'GET',
        callback: function (options, success, response) {
            var data = Ext.util.JSON.decode(response.responseText);
            Ext.get('nieuw_seizoen').remove();
            Ext.MessageBox.alert('Opgepast', "U bent succesvol aangemeld voor seizoen 2011-2012. U kunt uw Dreamteam samenstellen van " + data.begindatum + " tot " + data.einddatum);
        },
        failure:function(response,options){
            Ext.MessageBox.alert('Ogepast','Oops, er ging iets fout. Probeer opnieuw of neem contact op met de webmaster');
        }
    });
}