/**********************************************************/
/* 
/* ClimaController - Client logic. 
/* Miracle Projects 2008 (c)
/* 
/**********************************************************/

/**********************************************************/
/* Initialization
/**********************************************************/

/*Sets the JSON communication protocol*/ //
Ext.onReady(function() {  
    Ext.lib.Ajax.defaultPostHeader = 'application/json';
    //try{
    InitClimaSettings()    
    //ClimaController.Actions.Request.Init();
})

/*Create the ClimaController JS logic. */
var ClimaController = {
    version: "1.0",

    State: { Login: "Login",
        NewUser: "NewUser",
        UserCreated: "UserCreated",
        Front: "Front",
        LostPassword: "LostPassword",
        EditUser: "EditUser",
        Help: "Help",
        Help2: "Help2",
        ReportEdit: "ReportEdit",
        ReductionTarget: "ReductionTarget",
        ReportFocus0: "ReportFocus0",
        ReportFocus1: "ReportFocus1",
        ReportFocus2: "ReportFocus2",
        ReportFocus3: "ReportFocus3",
        ReportFocus4: "ReportFocus4",
        ReportFocus5: "ReportFocus5",
        ReportFocus6: "ReportFocus6",
        ReportFocus7: "ReportFocus7",
        ReportFocus8: "ReportFocus8",
        Navigation: "Navigation",
        Admin: "Admin",
        AdminText: "AdminText",
        AdminConstants: "AdminConstants",
        UserInfo: "UserInfo",
        MyData: "MyData",
        ConstantList: "ConstantList",
        Graph: "Graph",
        EditTransportChain: "EditTransportChain",
        TransportChains: "TransportChains"
    },

    Order: { Name: "Name",
        Created: "Created",
        Updated: "Updated"
    },

    /**********************************************************/
    /* Settings -- LOADED BY CLIENT
    /**********************************************************/
    Settings: {
        SystemURI: '',
        JSProxyURI: '',
        Initiated: false,
        ShowAlerts: false,
        ShowErrorAlerts: false,
        CrossDomain: false,
        FormNavigation: false,
        SessionID: ''
    },

    Actions: {
        /**********************************************************/
        /* Request Section - Handles the requests to the server
        /**********************************************************/


        Request: {

            /*
            Method for checking user login uniqueness
            */
            UsernameUnique: function(username) {
                if (username == "") { ClimaController.Validation.UsernameExists(false); return; }

                //Build request object
                var request = Ext.util.JSON.encode(ClimaController.Factory.CreateUniqueUsernameRequest(username));

                ClimaController.Communication.SendRequest({
                    action: "UsernameUnique",
                    success: 'ClimaController.Actions.Response.UsernameUniqueComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            AutoLogin: function() {
                var request = Ext.util.JSON.encode(ClimaController.Factory.CreateInitLoginRequest());
                ClimaController.Actions.Request.DoLogin(request);
            },

            /*
            Method for logging into the system - Called by the login button. 
            */
            DoLogin: function(req) {
                //Reset validation text
                ClimaController.Validation.LoginReset();

                //Check field validation. 
                if (!ClimaController.Validation.ValidUsername()) return;

                //Build request object
                var request = (!req) ? Ext.util.JSON.encode(ClimaController.Factory.CreateLoginRequest()) : req;

                ClimaController.Communication.SendRequest({
                    action: "Login",
                    success: 'ClimaController.Actions.Response.LoginComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            DoLogout: function() {
                ClimaController.Utils.SetCookie("ClimaPassword", "");

                ClimaController.Communication.SendRequest({
                    action: "Logout",
                    success: 'ClimaController.Actions.Response.LogoutComplete',
                    failure: 'ClimaController.Exception'
                });
            },

            CreateUser: function() {
                //Check field validation. 
                if (!ClimaController.Validation.NewUserFields(true)) return;

                //Build request object
                var request = Ext.util.JSON.encode(ClimaController.Factory.CreateUser());

                ClimaController.Communication.SendRequest({
                    action: "CreateUser",
                    success: 'ClimaController.Actions.Response.UserCreateComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },
            CreateAnonymousUser: function() {

                ClimaController.Communication.SendRequest({
                    action: "CreateAnonymousUser",
                    success: 'ClimaController.Actions.Response.UserCreateAnonymousComplete',
                    failure: 'ClimaController.Exception'
                    //,params: request
                });
            },

            LostPassword: function() {
                //Reset validation text
                ClimaController.Validation.LoginReset();

                //Check field validation. 
                if (!ClimaController.Validation.ValidUsername()) return;


                //Build request object
                var request = Ext.util.JSON.encode(ClimaController.Factory.CreateLostPassword());


                ClimaController.Communication.SendRequest({
                    action: "LostPassword",
                    success: 'ClimaController.Actions.Response.EmailPasswordComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            UpdateUser: function() {
                //Check field validation. 
                if (!ClimaController.Validation.NewUserFields(true)) { return; }

                //Build request object
                var request = Ext.util.JSON.encode(ClimaController.Factory.CreateUser());

                ClimaController.Communication.SendRequest({
                    action: "UpdateUser",
                    success: 'ClimaController.Actions.Response.UserUpdateComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            DeleteUser: function() {
                Ext.Msg.confirm(
                    'Slet brugerprofil',
                    'Er du sikker på, at du vil slette din brugerprofil? Alle data vil blive slettet.',
                    function(button) {
                        if (button == 'yes') {
                            //build request object
                            //var req = ClimaController.Factory.DeleteUserRequest();
                            //if (!req) return;

                            //var request = Ext.util.JSON.encode(req);

                            ClimaController.Communication.SendRequest({
                                action: "DeleteUser",
                                success: 'ClimaController.Actions.Response.DeleteUserComplete',
                                failure: 'ClimaController.Exception'//,
                                //params: request
                            });
                        }
                    }
                );
            },

            CreateOrUpdateReport: function(reportid) {
                //validateFields
                if (!ClimaController.Validation.CreateUpdateReport()) { return; }

                //Build request object
                var req = ClimaController.Factory.CreateOrUpdateReportRequest(reportid);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "CreateOrUpdateReport",
                    success: 'ClimaController.Actions.Response.CreateOrUpdateReportComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });

            },

            DeleteReport: function(reportId) {
                //show yes-no box before deleting report
                Ext.Msg.confirm(
                    'Slet beregning',
                    'Er du sikker på, at du vil slette beregningen?',
                    function(button) {
                        if (button == 'yes') {
                            //build request object
                            var req = ClimaController.Factory.DeleteReportRequest(reportId);
                            if (!req) return;

                            var request = Ext.util.JSON.encode(req);

                            ClimaController.Communication.SendRequest({
                                action: "DeleteReport",
                                success: 'ClimaController.Actions.Response.DeleteReportComplete',
                                failure: 'ClimaController.Exception',
                                params: request
                            });
                        }
                    }
                );
            }, //DeleteReport

            SortReports: function(columnName) {
                //build request object
                var req = ClimaController.Factory.SortReportsRequest(columnName);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "SortReports",
                    success: 'ClimaController.Actions.Response.SortReportsComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            CreateOrUpdateReductionTarget: function(reportid, reductionTargetId) {
                //validateFields
                if (!ClimaController.Validation.CreateUpdateReductionTarget()) { return; }

                //Build request object
                var req = ClimaController.Factory.CreateOrUpdateReductionTargetRequest(reportid, reductionTargetId);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "CreateOrUpdateReductionTarget",
                    success: 'ClimaController.Actions.Response.CreateOrUpdateReductionTargetComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });

            },

            UpdateSection: function(updateobject) {
                var request = Ext.util.JSON.encode(updateobject);

                ClimaController.Communication.SendRequest({
                    action: "UpdateTransportation",
                    success: 'ClimaController.Actions.Response.UpdateTransportationComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            UpdateElectricityAndHeat: function(updateobject) {
                var request = Ext.util.JSON.encode(updateobject);

                ClimaController.Communication.SendRequest({
                    action: "UpdateElectricityAndHeat",
                    success: 'ClimaController.Actions.Response.UpdateElectricityAndHeatComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            UpdateTravelInfo: function(updateobject) {
                var request = Ext.util.JSON.encode(updateobject);

                ClimaController.Communication.SendRequest({
                    action: "UpdateTravelInfo",
                    success: 'ClimaController.Actions.Response.UpdateTravelInfoComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            UpdateFossileData: function(updateobject) {
                var request = Ext.util.JSON.encode(updateobject);

                ClimaController.Communication.SendRequest({
                    action: "UpdateFossileData",
                    success: 'ClimaController.Actions.Response.UpdateFossileDataComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            UpdateOutsourced: function(updateObject) {
                var request = Ext.util.JSON.encode(updateObject);

                ClimaController.Communication.SendRequest({
                    action: "UpdateOutsourced",
                    success: 'ClimaController.Actions.Response.UpdateOutsourcedComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            UpdateSectionWithDescriptionAndAmount: function(updateObject) {
                var request = Ext.util.JSON.encode(updateObject);

                ClimaController.Communication.SendRequest({
                    action: 'UpdateSectionWithDescriptionAndAmount',
                    success: 'ClimaController.Actions.Response.UpdateSectionWithDescriptionAndAmountComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            AddInput: function(reportAreaId, areaType, inputJSON, formulaId, callbackMethod) {
                var req = ClimaController.Factory.AddInputRequest(reportAreaId, areaType, inputJSON, formulaId, callbackMethod);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "AddInput1",
                    success: 'ClimaController.Actions.Response.AddInput1Complete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            AddInput1: function(reportAreaId, areaType, inputJSON, formulaId, callbackMethod) {
                var req = ClimaController.Factory.AddInputRequest(reportAreaId, areaType, inputJSON, formulaId, callbackMethod);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "AddInput1",
                    success: 'ClimaController.Actions.Response.AddInput1Complete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            ClearItem: function(clearObject) {
                var request = Ext.util.JSON.encode(clearObject);

                ClimaController.Communication.SendRequest({
                    action: "ClearTransportationItem",
                    success: 'ClimaController.Actions.Response.ClearTransportationItemComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });

            },

            ClearTravelInfoItem: function(clearObject) {
                var request = Ext.util.JSON.encode(clearObject);

                ClimaController.Communication.SendRequest({
                    action: "ClearTravelInfoItem",
                    success: 'ClimaController.Actions.Response.ClearTravelInfoItemComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });

            },

            ClearFossileItem: function(clearObject) {
                var request = Ext.util.JSON.encode(clearObject);

                ClimaController.Communication.SendRequest({
                    action: "ClearFossileItem",
                    success: 'ClimaController.Actions.Response.ClearFossileItemComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });

            },

            ClearProcessItems: function(clearObject) {
                var request = Ext.util.JSON.encode(clearObject);

                ClimaController.Communication.SendRequest({
                    action: "ClearProcessItems",
                    success: 'ClimaController.Actions.Response.ClearProcessItemsComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });

            },

            ClearOutsourcedItem: function(clearObject) {
                var request = Ext.util.JSON.encode(clearObject);

                ClimaController.Communication.SendRequest({
                    action: "ClearOutsourcedItem",
                    success: 'ClimaController.Actions.Response.ClearOutsourcedItemComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            ClearSectionWithDescriptionAndAmountItem: function(clearObject) {
                var request = Ext.util.JSON.encode(clearObject);

                ClimaController.Communication.SendRequest({
                    action: "ClearSectionWithDescriptionAndAmountItem",
                    success: 'ClimaController.Actions.Response.ClearSectionWithDescriptionAndAmountItemComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            UpdateReportAreaInput: function(reportAreaId, key, value) {


                var req = ClimaController.Factory.CreateInputRequest(reportAreaId, key, value);

                if (!req) return;

                var request = Ext.util.JSON.encode(req);


                ClimaController.Communication.SendRequest({
                    action: "UpdateReportAreaInput",
                    success: 'ClimaController.Actions.Response.UpdateReportAreaInputComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });

            },
            ClearVechicleData: function(reportAreaId) {
                var req = ClimaController.Factory.ClearReportAreaRequest(reportAreaId);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "ClearVehicle",
                    success: 'ClimaController.Actions.Response.ClearAllTransportationItemCarComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },
            ClearPlaneData: function(reportAreaId) {
                var req = ClimaController.Factory.ClearReportAreaRequest(reportAreaId);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "ClearPlane",
                    success: 'ClimaController.Actions.Response.ClearAllTransportationPlaneItemComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });

            },

            ClearUseVechicleData: function(reportAreaId) {
                var req = ClimaController.Factory.ClearReportAreaRequest(reportAreaId);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "ClearUseVehicle",
                    success: 'ClimaController.Actions.Response.ClearAllTravelInfoItemCarComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },
            ClearUsePlaneData: function(reportAreaId) {
                var req = ClimaController.Factory.ClearReportAreaRequest(reportAreaId);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "ClearUsePlane",
                    success: 'ClimaController.Actions.Response.ClearAllTravelInfoItemPlaneComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },
            ClearUsePublicTransData: function(reportAreaId) {
                var req = ClimaController.Factory.ClearReportAreaRequest(reportAreaId);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "ClearUsePublicTrans",
                    success: 'ClimaController.Actions.Response.ClearAllTravelInfoItemPublicTransComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },
            ClearUseTaxiData: function(reportAreaId) {
                var req = ClimaController.Factory.ClearReportAreaRequest(reportAreaId);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "ClearUseTaxi",
                    success: 'ClimaController.Actions.Response.ClearAllTravelInfoItemTaxiComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },
            ClearUseCommutingData: function(reportAreaId) {
                var req = ClimaController.Factory.ClearReportAreaRequest(reportAreaId);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "ClearUseCommuting",
                    success: 'ClimaController.Actions.Response.ClearAllTravelInfoItemCommutingComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            ClearOutsourcedData: function(reportAreaId) {
                var req = ClimaController.Factory.ClearReportAreaRequest(reportAreaId);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "ClearOutsourcedData",
                    success: 'ClimaController.Actions.Response.ClearAllOutsourcedItemComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            ClearAllSectionWithDescriptionAndAmountItems: function(reportAreaId) {
                var req = ClimaController.Factory.ClearReportAreaRequest(reportAreaId);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "ClearAllSectionWithDescriptionAndAmountItems",
                    success: 'ClimaController.Actions.Response.ClearAllSectionWithDescriptionAndAmountItemsComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },


            DeleteInputByReportAreaIdAndAreaCalculationId: function(reportAreaId, areaCalculationId, callbackMethod) {
                var req = ClimaController.Factory.DeleteInputByReportAreaIdAndAreaCalculationIdRequest(reportAreaId, areaCalculationId, callbackMethod);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "DeleteInputByReportAreaIdAndAreaCalculationId",
                    success: 'ClimaController.Actions.Response.DeleteInputByReportAreaIdAndAreaCalculationIdComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            DeleteInputByReportAreaIdAndAreaType: function(reportAreaId, areaType, callbackMethod) {
                var req = ClimaController.Factory.DeleteInputByReportAreaIdAndAreaTypeRequest(reportAreaId, areaType, callbackMethod);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "DeleteInputByReportAreaIdAndAreaType",
                    success: 'ClimaController.Actions.Response.DeleteInputByReportAreaIdAndAreaTypeComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            ClearFossileData: function(reportAreaId) {
                var req = ClimaController.Factory.ClearReportAreaRequest(reportAreaId);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "ClearFossileData",
                    success: 'ClimaController.Actions.Response.ClearAllFossileItemComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            CreateOrUpdateConstant: function(constantCode) {
                //Build request object
                var req = ClimaController.Factory.CRUDConstantRequest(constantCode);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "CreateOrUpdateConstant",
                    success: 'ClimaController.Actions.Response.CreateOrUpdateConstantComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });

            },

            DeleteConstant: function(constantCode) {
                //Build request object
                var req = ClimaController.Factory.CRUDConstantRequest(constantCode);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "DeleteConstant",
                    success: 'ClimaController.Actions.Response.DeleteConstantComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });

            },


            CreateOrUpdateText: function(key) {
                //Build request object

                var req = ClimaController.Factory.CRUDTextRequest(key);
                if (!req) return;
                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "CreateOrUpdateText",
                    success: 'ClimaController.Actions.Response.CreateOrUpdateTextComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });

            },

            ClearPurchasedMaterialsData: function(reportAreaId) {
                var req = ClimaController.Factory.ClearReportAreaRequest(reportAreaId);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "ClearPurchasedMaterials",
                    success: 'ClimaController.Actions.Response.ClearAllPurchasedMaterialsItemsComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },
            UpdatePurchasedMaterial: function(updateobject) {
                var request = Ext.util.JSON.encode(updateobject);

                ClimaController.Communication.SendRequest({
                    action: "UpdatePurchasedMaterial",
                    success: 'ClimaController.Actions.Response.UpdatePurchasedMaterialComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },
            ClearPurchasedMaterialItem: function(clearObject) {
                var request = Ext.util.JSON.encode(clearObject);

                ClimaController.Communication.SendRequest({
                    action: "ClearPurchasedMaterialItem",
                    success: 'ClimaController.Actions.Response.ClearPurchasedMaterialItemComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });

            },
            GetDefaultValues: function(requestObject) {
                var request = Ext.util.JSON.encode(requestObject);

                ClimaController.Communication.SendRequest({
                    action: "GetDefaultValues",
                    success: 'ClimaController.Actions.Response.GetDefaultValuesComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            ClearRemovalWasteData: function(reportAreaId, areaType) {
                var req = ClimaController.Factory.ClearReportAreaRequest(reportAreaId);
                req.AreaType = areaType;
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "ClearAllRemovalWaste",
                    success: 'ClimaController.Actions.Response.ClearAllRemovalWasteItemsComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },
            UpdateRemovalWaste: function(updateobject) {
                var request = Ext.util.JSON.encode(updateobject);

                ClimaController.Communication.SendRequest({
                    action: "UpdateRemovalWaste",
                    success: 'ClimaController.Actions.Response.UpdateRemovalWasteComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },
            ClearRemovalWasteItem: function(clearObject) {
                var request = Ext.util.JSON.encode(clearObject);

                ClimaController.Communication.SendRequest({
                    action: "ClearRemovalWasteItem",
                    success: 'ClimaController.Actions.Response.ClearRemovalWasteItemComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });

            },

            CreateOrUpdateTransportChain: function(transportChainId) {
                //validateFields
                if (!ClimaController.Validation.CreateUpdateTransportChain()) { return; }

                //Build request object
                var req = ClimaController.Factory.CreateOrUpdateTransportChainRequest(transportChainId);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "CreateOrUpdateTransportChain",
                    success: 'ClimaController.Actions.Response.CreateOrUpdateTransportChainComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });

            },

            DeleteTransportChain: function(transportChainId) {
                //show yes-no box before deleting report
                Ext.Msg.confirm(
                    'Slet transportkæde',
                    'Er du sikker på, at du vil slette transportkæden?',
                    function(button) {
                        if (button == 'yes') {
                            //build request object
                            var req = ClimaController.Factory.DeleteTransportChainRequest(transportChainId);
                            if (!req) return;

                            var request = Ext.util.JSON.encode(req);

                            ClimaController.Communication.SendRequest({
                                action: "DeleteTransportChain",
                                success: 'ClimaController.Actions.Response.DeleteTransportChainComplete',
                                failure: 'ClimaController.Exception',
                                params: request
                            });
                        }
                    }
                );
            },

            SortTransportChains: function(columnName) {
                //build request object
                var req = ClimaController.Factory.SortTransportChainsRequest(columnName);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "SortTransportChains",
                    success: 'ClimaController.Actions.Response.SortTransportChainsComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            ToggleActivateTransportChain: function(transportChainId) {
                //build request object
                var req = ClimaController.Factory.ToggleActivateTransportChainRequest(transportChainId);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "ToggleActivateTransportChain",
                    success: 'ClimaController.Actions.Response.ToggleActivateTransportChainComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            CopyTransportChain: function(transportChainId, newName) {
                //build request object
                var req = ClimaController.Factory.CopyTransportChainRequest(transportChainId, newName);

                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "CopyTransportChain",
                    success: 'ClimaController.Actions.Response.CopyTransportChainComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            CopyTransportChainExceptOneLink: function(transportChainId, newName, transportChainLinkId) {
                //build request object
                var req = ClimaController.Factory.CopyTransportChainExceptOneLinkRequest(transportChainId, newName, transportChainLinkId);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "CopyTransportChainExceptOneLink",
                    success: 'ClimaController.Actions.Response.CopyTransportChainExceptOneLinkComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            CopyTransportChainCreateUpdateLink: function(transportChainId, newName, transportChainLinkId) {
                //validateFields
                if (!ClimaController.Validation.CreateUpdateTransportChainLink()) { return; }

                //build request object
                var req = ClimaController.Factory.CopyTransportChainCreateUpdateLinkRequest(transportChainId, newName, transportChainLinkId);

                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "CopyTransportChainCreateUpdateLink",
                    success: 'ClimaController.Actions.Response.CopyTransportChainCreateUpdateLinkComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            CreateOrUpdateTransportChainLink: function(transportChainId, transportChainLinkId) {
                //validateFields
                if (!ClimaController.Validation.CreateUpdateTransportChainLink()) { return; }

                //Build request object
                var req = ClimaController.Factory.CreateOrUpdateTransportChainLinkRequest(transportChainId, transportChainLinkId);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "CreateOrUpdateTransportChainLink",
                    success: 'ClimaController.Actions.Response.CreateOrUpdateTransportChainLinkComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });

            },

            DeleteTransportChainLink: function(transportChainLinkId) {
                //show yes-no box before deleting report
                Ext.Msg.confirm(
                    'Slet transportkædeben',
                    'Er du sikker på, at du vil slette transportkædebenet?',
                    function(button) {
                        if (button == 'yes') {
                            //build request object
                            var req = ClimaController.Factory.DeleteTransportChainLinkRequest(transportChainLinkId);
                            if (!req) return;

                            var request = Ext.util.JSON.encode(req);

                            ClimaController.Communication.SendRequest({
                                action: "DeleteTransportChainLink",
                                success: 'ClimaController.Actions.Response.DeleteTransportChainLinkComplete',
                                failure: 'ClimaController.Exception',
                                params: request
                            });
                        }
                    }
                );
            },

            SortTransportChainLinks: function(columnName) {
                //build request object
                var req = ClimaController.Factory.SortTransportChainLinksRequest(columnName);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "SortTransportChainLinks",
                    success: 'ClimaController.Actions.Response.SortTransportChainLinksComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            GetTransportChainLink: function(transportChainId) {
                var req = ClimaController.Factory.GetTransportChainLinkRequest(transportChainId);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "GetTransportChainLink",
                    success: 'ClimaController.Actions.Response.GetTransportChainLinkComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            },

            CreateUpdateTransportChainLinkConstants: function(transportChainLinkId) {
                //validateFields
                if (!ClimaController.Validation.CreateUpdateTransportChainLinkConstants()) { return; }

                //Build request object
                var req = ClimaController.Factory.CreateUpdateTransportChainLinkConstantsRequest(transportChainLinkId);
                if (!req) return;

                var request = Ext.util.JSON.encode(req);

                ClimaController.Communication.SendRequest({
                    action: "CreateUpdateTransportChainLinkConstants",
                    success: 'ClimaController.Actions.Response.CreateUpdateTransportChainLinkConstantsComplete',
                    failure: 'ClimaController.Exception',
                    params: request
                });
            }

        }, //Request          

        /**********************************************************/
        /* Response Section - Handles the server responses to requested actions. 
        /**********************************************************/
        Response: {

            UsernameUniqueComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + result.responseText);

                var resultData = Ext.util.JSON.decode(result.responseText);

                ClimaController.Validation.UsernameExists(!resultData.UsernameUniqueResult);
            },

            /*
            Login Response
            */
            LoginComplete: function(result, request) {

                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                //If login success    
                if (resultData.LoginResult.Login) {

                    var oRemember = document.getElementById("RememberUser");

                    var oName = document.getElementById("LoginUsername");
                    var oPwd = document.getElementById("LoginPassword");

                    if (oRemember) {
                        if (oRemember.checked) {
                            var expdate = new Date();
                            expdate.setTime(expdate.getTime() + (24 * 60 * 60 * 1000 * 365));
                            ClimaController.Utils.SetCookie("ClimaUsername", oName.value, expdate);
                            ClimaController.Utils.SetCookie("ClimaPassword", oPwd.value, expdate);
                        }
                        else {
                            ClimaController.Utils.SetCookie("ClimaUsername", "");
                            ClimaController.Utils.SetCookie("ClimaPassword", "");
                        }
                    }
                    ClimaController.Actions.Client.FrontSection();
                }
                //Failure to login
                else {

                    ClimaController.Utils.SetCookie("ClimaUsername", "");
                    ClimaController.Utils.SetCookie("ClimaPassword", "");

                    /*Update error text*/
                    var oError = document.getElementById("LoginError");
                    var oLoginLeft = document.getElementById("LoginLeft");
                    if (oError) oError.style.display = "block";

                    var login = 3 - resultData.LoginResult.LoginAttempts;
                    if (oLoginLeft) oLoginLeft.innerHTML = 3 - resultData.LoginResult.LoginAttempts;
                    if (login == 0) window.location.reload();
                }
            },


            /*
            Logout Response
            */
            LogoutComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                ClimaController.Settings.SessionID = false;
                ClimaController.Actions.Client.FrontSection();
            },

            UpdateTransportationComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var requestData = Ext.util.JSON.decode(unescape(request.requestText));
                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area0.UpdateTransportationInfoComplete(resultData.UpdateTransportationResult);

                ClimaController.PageLogic.Area0.UpdateGUI(requestData.Params.UpdateTypeCar,
                              requestData.Params.RowId,
                              resultData.UpdateTransportationResult.ReportAreaId,
                              resultData.UpdateTransportationResult.AreaCalculationId);
            },

            UpdateElectricityAndHeatComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area2.UpdateElectricityAndHeatComplete(resultData.UpdateElectricityAndHeatResult);

            },

            UpdateTravelInfoComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var requestData = Ext.util.JSON.decode(unescape(request.requestText));
                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area3.UpdateTravelInfoComplete(resultData.UpdateTravelInfoResult);

                ClimaController.PageLogic.Area3.UpdateGUI(requestData.Params.RequestType,
                              requestData.Params.RowId,
                              resultData.UpdateTravelInfoResult.ReportAreaId,
                              resultData.UpdateTravelInfoResult.AreaCalculationId);
            },

            UpdateFossileDataComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var requestData = Ext.util.JSON.decode(unescape(request.requestText));
                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area1.UpdateFossileInfoComplete(resultData.UpdateFossileDataResult);

                if (requestData.Params.RequestType == 0) { //if fossile request
                    ClimaController.PageLogic.Area1.UpdateGUI(
                              requestData.Params.RowId,
                              resultData.UpdateFossileDataResult.ReportAreaId,
                              resultData.UpdateFossileDataResult.AreaCalculationId);
                }
            },

            UpdateOutsourcedComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts) {
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));
                }

                var requestData = Ext.util.JSON.decode(unescape(request.requestText));
                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area4.UpdateOutsourcedComplete(resultData.UpdateOutsourcedResult);

                ClimaController.PageLogic.Area4.UpdateGUI(requestData.Params.RowId,
                    resultData.UpdateOutsourcedResult.ReportAreaId,
                    resultData.UpdateOutsourcedResult.AreaCalculationId);
            },

            UpdateSectionWithDescriptionAndAmountComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts) {
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));
                }

                var requestData = Ext.util.JSON.decode(unescape(request.requestText));
                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.SectionWithDescriptionAndAmount.UpdateSectionWithDescriptionAndAmountComplete(requestData, resultData);
            },

            AddInputComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts) {
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));
                }

                var requestData = Ext.util.JSON.decode(unescape(request.requestText));
                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                eval(requestData.Params.CallbackMethod)(resultData);
            },

            AddInput1Complete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts) {
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));
                }

                var requestText1 = unescape(request.requestText);
                var requestText = requestText1.substring(0, requestText1.indexOf('['));
                requestText = requestText + requestText1.substring(requestText1.lastIndexOf(']') + 1);
                var requestData = Ext.util.JSON.decode(requestText);
                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                eval(requestData.Params.CallbackMethod)(resultData);
            },

            ClearTransportationItemComplete: function(result, request) {

                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area0.UpdateTransportationInfoComplete(resultData.ClearTransportationItemResult);
            },

            ClearTravelInfoItemComplete: function(result, request) {

                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area3.UpdateTravelInfoComplete(resultData.ClearTravelInfoItemResult);
            },

            ClearFossileItemComplete: function(result, request) {

                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area1.UpdateFossileInfoComplete(resultData.ClearFossileItemResult);
            },

            ClearProcessItemsComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area1.UpdateFossileInfoComplete(resultData.ClearProcessItemsResult);
            },

            ClearOutsourcedItemComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area4.UpdateOutsourcedComplete(resultData.ClearOutsourcedItemResult);
            },

            ClearSectionWithDescriptionAndAmountItemComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.SectionWithDescriptionAndAmount.ClearSectionWithDescriptionAndAmountItemComplete(resultData);
            },

            ClearAllTransportationItemCarComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area0.UpdateTransportationInfoComplete(resultData.ClearVehicleResult);
                ClimaController.PageLogic.Area0.ClearTransportationTable("Car");
            },


            ClearAllTransportationPlaneItemComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area0.UpdateTransportationInfoComplete(resultData.ClearPlaneResult);
                ClimaController.PageLogic.Area0.ClearTransportationTable("Plane");
            },

            ClearAllFossileItemComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area1.UpdateFossileInfoComplete(resultData.ClearFossileDataResult);
                ClimaController.PageLogic.Area1.ClearFossileTable();
            },

            ClearAllOutsourcedItemComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area4.UpdateOutsourcedComplete(resultData.ClearOutsourcedDataResult);
                ClimaController.PageLogic.Area4.ClearOutsourcedTable();
            },

            ClearAllSectionWithDescriptionAndAmountItemsComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.SectionWithDescriptionAndAmount.ClearAllSectionWithDescriptionAndAmountItemsComplete(resultData);
            },

            DeleteInputByReportAreaIdAndAreaCalculationIdComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var requestData = Ext.util.JSON.decode(unescape(request.requestText));
                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                eval(requestData.Params.CallbackMethod)(requestData, resultData);
            },

            DeleteInputByReportAreaIdAndAreaTypeComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var requestData = Ext.util.JSON.decode(unescape(request.requestText));
                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                eval(requestData.Params.CallbackMethod)(requestData, resultData);
            },

            ClearAllTravelInfoItemCarComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area3.UpdateTravelInfoComplete(resultData.ClearUseVehicleResult);
                ClimaController.PageLogic.Area3.ClearTravelInfoTable("Car");
            },

            ClearAllTravelInfoItemPlaneComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area3.UpdateTravelInfoComplete(resultData.ClearUsePlaneResult);
                ClimaController.PageLogic.Area3.ClearTravelInfoTable("Plane");
            },
            ClearAllTravelInfoItemPublicTransComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area3.UpdateTravelInfoComplete(resultData.ClearUsePublicTransResult);
                ClimaController.PageLogic.Area3.ClearTravelInfoTable("PublicTrans");
            },
            ClearAllTravelInfoItemTaxiComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area3.UpdateTravelInfoComplete(resultData.ClearUseTaxiResult);
                ClimaController.PageLogic.Area3.ClearTravelInfoTable("Taxi");
            },
            ClearAllTravelInfoItemCommutingComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area3.UpdateTravelInfoComplete(resultData.ClearUseCommutingResult);
                ClimaController.PageLogic.Area3.ClearTravelInfoTable("Commuting");
            },


            EmailPasswordComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.LostPasswordResult)
                    ClimaController.Actions.Client.OpenSection(ClimaController.State.LostPassword);
                else {
                    var oError = document.getElementById("NoUsername");
                    if (oError) oError.style.display = "block";
                }
            },

            UserCreateComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                //If created user success
                //alert(resultData.CreateUserResult.UserCreated) ;
                if (resultData.CreateUserResult.UserCreated)
                    ClimaController.Actions.Client.OpenSection(ClimaController.State.UserCreated);

                //Failure to create user
                else {
                    alert("Error!");
                }
            },
            UserCreateAnonymousComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                //If created user success
                //alert(resultData.CreateUserResult.UserCreated) ;
                if (resultData.CreateAnonymousUserResult.UserCreated)
                    ClimaController.Actions.Client.OpenSection(ClimaController.State.Front);

                //Failure to create user
                else {
                    alert("Error!");
                }
            },
            UserUpdateComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.UpdateUserResult) {
                    ClimaController.Actions.Client.FrontSection();
                }
            },

            DeleteUserComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.DeleteUserResult) {
                    ClimaController.Actions.Client.LoginSection();
                }
                else {
                    ClimaController.Exception("Delete failed...");
                }
            },

            CreateOrUpdateReportComplete: function(result, request) {

                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.CreateOrUpdateReportResult) {
                    ClimaController.Actions.Client.EditReport(ClimaController.State.Navigation, resultData.CreateOrUpdateReportResult.Id);
                }
                else {
                    ClimaController.Exception("Report update error.... ");
                }

            },


            DeleteReportComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.DeleteReportResult) {
                    ClimaController.Actions.Client.FrontSection();
                }
                else {
                    ClimaController.Exception("Delete failed...");
                }
            },

            SortReportsComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.SortReportsResult) {
                    ClimaController.Actions.Client.FrontSection();
                }
                else {
                    ClimaController.Exception("Sort failed...");
                }
            },

            CreateOrUpdateReductionTargetComplete: function(result, request) {

                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.CreateOrUpdateReductionTargetResult) {
                    ClimaController.Actions.Client.EditReport(ClimaController.State.Navigation, resultData.CreateOrUpdateReductionTargetResult.ReportId);
                }
                else {
                    ClimaController.Exception("Reduction target update error.... ");
                }

            },

            UpdateReportAreaInputComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

            },

            CreateOrUpdateConstantComplete: function(result, request) {

                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.CreateOrUpdateConstantResult) {
                    ClimaController.PageLogic.AdminConstants.CreateOrUpdateConstantComplete(resultData.CreateOrUpdateConstantResult);
                }
                else {
                    ClimaController.Exception("Constant update error.... ");
                }

            },

            DeleteConstantComplete: function(result, request) {

                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.DeleteConstantResult) {
                    ClimaController.PageLogic.AdminConstants.DeleteConstantComplete(resultData.DeleteConstantResult);
                }
                else {
                    ClimaController.Exception("Constant delete error.... ");
                }

            },

            CreateOrUpdateTextComplete: function(result, request) {

                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));
                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.CreateOrUpdateTextResult) {
                    ClimaController.PageLogic.AdminText.CreateOrUpdateTextComplete(resultData.CreateOrUpdateTextResult);
                }
                else {
                    ClimaController.Exception("Text update error.... ");
                }

            },

            ClearAllPurchasedMaterialsItemsComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area6.UpdatePurchasedMaterialsComplete(resultData.ClearPurchasedMaterialsResult);
                ClimaController.PageLogic.Area6.ClearPurchasedMaterialsTable();
            },

            UpdatePurchasedMaterialComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var requestData = Ext.util.JSON.decode(unescape(request.requestText));
                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area6.UpdatePurchasedMaterialsComplete(resultData.UpdatePurchasedMaterialResult);

                ClimaController.PageLogic.Area6.UpdateGUI(
                              requestData.Params.RowId,
                              resultData.UpdatePurchasedMaterialResult.ReportAreaId,
                              resultData.UpdatePurchasedMaterialResult.AreaCalculationId);
            },
            ClearPurchasedMaterialItemComplete: function(result, request) {

                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area6.UpdatePurchasedMaterialsComplete(resultData.ClearPurchasedMaterialItemResult);
            },

            GetDefaultValuesComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));
                var requestData = Ext.util.JSON.decode(unescape(request.requestText));
                eval(requestData.Params.CallbackMethod)(resultData.GetDefaultValuesResult.DefaultValues, requestData.Params.AreaType);
            },

            ClearAllRemovalWasteItemsComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var requestData = Ext.util.JSON.decode(unescape(request.requestText));
                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area8.UpdateRemovalWasteComplete(resultData.ClearAllRemovalWasteResult, requestData.Params.AreaType);
                ClimaController.PageLogic.Area8.ClearRemovalWasteTable(requestData.Params.AreaType);
            },
            UpdateRemovalWasteComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var requestData = Ext.util.JSON.decode(unescape(request.requestText));
                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area8.UpdateRemovalWasteComplete(resultData.UpdateRemovalWasteResult, requestData.Params.AreaType);

                ClimaController.PageLogic.Area8.UpdateGUI(
                              requestData.Params.RowId,
                              resultData.UpdateRemovalWasteResult.ReportAreaId,
                              resultData.UpdateRemovalWasteResult.AreaCalculationId,
                              requestData.Params.AreaType);
            },
            ClearRemovalWasteItemComplete: function(result, request) {

                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var requestData = Ext.util.JSON.decode(unescape(request.requestText));
                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                ClimaController.PageLogic.Area8.UpdateRemovalWasteComplete(resultData.ClearRemovalWasteItemResult, requestData.Params.AreaType);
            },

            DeleteTransportChainComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.DeleteTransportChainResult) {
                    ClimaController.Actions.Client.TransportChains();
                }
                else {
                    ClimaController.Exception("Delete failed...");
                }
            },

            SortTransportChainsComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.SortTransportChainsResult) {
                    ClimaController.Actions.Client.TransportChains();
                }
                else {
                    ClimaController.Exception("Sort failed...");
                }
            },

            ToggleActivateTransportChainComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.ToggleActivateTransportChainResult) {
                    ClimaController.Actions.Client.TransportChains();
                }
                else {
                    ClimaController.Exception("(De)activation failed...");
                }
            },

            CopyTransportChainComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.CopyTransportChainResult) {
                    ClimaController.Actions.Client.TransportChains();
                }
                else {
                    ClimaController.Exception("Copy failed...");
                }
            },

            CopyTransportChainExceptOneLinkComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.CopyTransportChainExceptOneLinkResult) {
                    ClimaController.Actions.Client.EditTransportChain(resultData.CopyTransportChainExceptOneLinkResult.Id);

                }
                else {
                    ClimaController.Exception("Copy failed...");
                }
            },

            CopyTransportChainCreateUpdateLinkComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.CopyTransportChainCreateUpdateLinkResult) {
                    ClimaController.Actions.Client.EditTransportChain(resultData.CopyTransportChainCreateUpdateLinkResult.Id);

                }
                else {
                    ClimaController.Exception("Copy failed...");
                }
            },

            CreateOrUpdateTransportChainComplete: function(result, request) {

                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.CreateOrUpdateTransportChainResult) {
                    ClimaController.PageLogic.TransportChains.CreateOrUpdateTransportChainComplete(resultData.CreateOrUpdateTransportChainResult);
                }
                else {
                    ClimaController.Exception("TransportChain update error.... ");
                }

            },

            CreateOrUpdateTransportChainLinkComplete: function(result, request) {

                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.CreateOrUpdateTransportChainLinkResult) {
                    ClimaController.Actions.Client.EditTransportChain(Page.TransportChainId);
                    //ClimaController.PageLogic.TransportChains.CreateOrUpdateTransportChainLinkComplete(resultData.CreateOrUpdateTransportChainLinkResult);
                }
                else {
                    ClimaController.Exception("TransportChainLink update error.... ");
                }

            },

            DeleteTransportChainLinkComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.DeleteTransportChainLinkResult) {
                    ClimaController.Actions.Client.EditTransportChain(Page.TransportChainId);
                }
                else {
                    ClimaController.Exception("Delete failed...");
                }
            },

            SortTransportChainLinksComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.SortTransportChainLinksResult) {
                    ClimaController.Actions.Client.TransportChainLinks();
                }
                else {
                    ClimaController.Exception("Sort failed...");
                }
            },

            GetTransportChainLinkComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.GetTransportChainLinkResult) {
                    ClimaController.PageLogic.TransportChains.GetTransportChainLinkComplete(resultData.GetTransportChainLinkResult);
                }
                else {
                    ClimaController.Exception("Get failed...");
                }
            },

            CreateUpdateTransportChainLinkConstantsComplete: function(result, request) {
                if (ClimaController.Settings.ShowAlerts)
                    Ext.MessageBox.alert('Success', 'Data return from the server: ' + unescape(result.responseText));

                var resultData = Ext.util.JSON.decode(unescape(result.responseText));

                if (resultData.CreateUpdateTransportChainLinkConstantsResult) {

                }
                else {
                    ClimaController.Exception("CreateUpdateTransportChainLinkConstants failed...");
                }
            },
            /*
            Handles errors when communicating with the backend service
            */
            ServiceCommunicationError: function(result, request) {
                if (ClimaController.Settings.ShowErrorAlerts)
                    Ext.MessageBox.alert('Failed', 'ERROR Data return from the server: ' + unescape(request.requestText));

            }

        }, //Response

        Client: {
            OpenSection: function(state, param, param2) {
                var search = ClimaController.Utils.ClearKeys();
                var newurl = ClimaController.Utils.ReplaceKeyValue(state, search);
                //if admin page and param is set Year url param
                if (state == ClimaController.State.AdminConstants && param && param2) {
                    newurl = ClimaController.Utils.ReplaceKeyValue(param, newurl.search, newurl.url, "Year");
                    newurl = ClimaController.Utils.ReplaceKeyValue(param2, newurl.search, newurl.url, "IntervalNo");
                }
                else if (state == ClimaController.State.Graph && param) {
                    newurl = ClimaController.Utils.ReplaceKeyValue(param, newurl.search, newurl.url, "Ids");
                }
                else if (state == ClimaController.State.AdminText && param) {
                    newurl = ClimaController.Utils.ReplaceKeyValue(param, newurl.search, newurl.url, "AdminLanguage");
                }
                else if (state == ClimaController.State.EditTransportChain && param) {
                    newurl = ClimaController.Utils.ReplaceKeyValue(param, newurl.search, newurl.url, "TransportChainId");
                }
                //else if param is greater than -1, set ReportId url param
                else if (param > -1) {
                    newurl = ClimaController.Utils.ReplaceKeyValue(param, newurl.search, newurl.url, "ReportId");
                }
                newurl = ClimaController.Settings.SessionID ? ClimaController.Utils.ReplaceKeyValue(ClimaController.Settings.SessionID, newurl.search, newurl.url, "Session") : newurl;
                newurl = ClimaController.Utils.ReplaceKeyValue(ClimaController.Utils.CreateUniqueId(), newurl.search, newurl.url, "Tick");
                window.open(newurl.url + newurl.search, "_self");
            },

            LoginSection: function() {
                ClimaController.Actions.Client.OpenSection(ClimaController.State.Login);
            },

            FrontSection: function() {
                ClimaController.Actions.Client.OpenSection(ClimaController.State.Front);
            },

            NewUser: function() {
                ClimaController.Actions.Client.OpenSection(ClimaController.State.NewUser);
            },

            EditUser: function() {
                ClimaController.Actions.Client.OpenSection(ClimaController.State.EditUser);
            },

            Help: function() {
                ClimaController.Actions.Client.OpenSection(ClimaController.State.Help);
            },
            HelpInner: function(reportid) {
                ClimaController.Actions.Client.OpenSection(ClimaController.State.Help2, reportid);
            },

            Admin: function() {
                ClimaController.Actions.Client.OpenSection(ClimaController.State.Admin);
            },

            AdminConstants: function(year, intervalNo) {
                ClimaController.Actions.Client.OpenSection(ClimaController.State.AdminConstants, year, intervalNo);
            },

            AdminText: function(language) {
                ClimaController.Actions.Client.OpenSection(ClimaController.State.AdminText, language);
            },

            UserInfo: function() {
                ClimaController.Actions.Client.OpenSection(ClimaController.State.UserInfo);
            },
            MyDataSection: function() {
                ClimaController.Actions.Client.OpenSection(ClimaController.State.MyData);
            },

            Graph: function() {
                var ids = "";
                var allCheckBoxes = Ext.query("input[id*=graph_]");
                for (var i = 0; i < allCheckBoxes.length; i++) {
                    var checkBox = allCheckBoxes[i];
                    if (checkBox && checkBox.checked) {
                        if (ids != "") ids = ids + ",";
                        ids = ids + checkBox.id.substring("Graph_".length, checkBox.id.length);
                    }
                }
                ClimaController.Actions.Client.OpenSection(ClimaController.State.Graph, ids);
            },

            NewReport: function() {
                ClimaController.Actions.Client.EditReport(ClimaController.State.ReportEdit, '0');
            },

            EditReport: function(section, reportid) {
                ClimaController.Actions.Client.OpenSection(section, reportid);
            },
            EditReductionTarget: function(reportid) {
                ClimaController.Actions.Client.OpenSection(ClimaController.State.ReductionTarget, reportid);
            },
            ViewReport: function(reportid) {
                var search = "?ReportId=" + reportid;
                search += "&Session=" + ClimaController.Settings.SessionID;
                search += "&Tick=" + ClimaController.Utils.CreateUniqueId();
                var newurl = ClimaController.Settings.SystemURI + "/../Report.aspx";
                window.open(newurl + search, "_self");
            },
            ViewCDPReport: function(reportid) {
                var search = "?ReportId=" + reportid;
                search += "&Session=" + ClimaController.Settings.SessionID;
                search += "&Tick=" + ClimaController.Utils.CreateUniqueId();
                var newurl = ClimaController.Settings.SystemURI + "/../CDPReport.aspx";
                window.open(newurl + search, "_self");
            },
            DownloadUserInfo: function() {
                var newurl = ClimaController.Settings.SystemURI + "/../UserInfoDownload.aspx";
                window.open(newurl, "_self");
            },
            NewTransportChain: function() {
                ClimaController.Actions.Client.EditTransportChain('0');
            },
            EditTransportChain: function(transportChainId) {
                ClimaController.Actions.Client.OpenSection(ClimaController.State.EditTransportChain, transportChainId);
            },
            TransportChains: function() {
                ClimaController.Actions.Client.OpenSection(ClimaController.State.TransportChains);
            }



}//Client

        }, //Action


        /**********************************************************/
        /* Factory methods - creates the domain types for communicating with the server. 
        /**********************************************************/
        Factory: {
            /*
            Create Unique Username request object. 
            */
            CreateUniqueUsernameRequest: function(username) {
                var request = {
                    username: Ext.util.Format.htmlEncode(username)
                };

                return request;
            },

            CreateInputRequest: function(reportAreaId, key, value) {
                var request = {
                    ReportAreaId: reportAreaId,
                    Key: key,
                    Value: Ext.util.Format.htmlEncode(value)
                };

                return request;
            },
            EditReportRequest: function(ReportId, ViewState) {
                var request = {
                    reportId: ReportId,
                    viewState: ViewState
                };

                return request;
            },

            CreateTransportCarRequest: function() {
                var updateobject = {
                    ReportArea: 0,
                    Year: 0,
                    RowId: 0,
                    FuelType: {
                        Key: ('Input9'),
                        Value: 0
                    },
                    BioFuel: {
                        Key: ('Input10'),
                        Value: 0
                    },
                    Usage: {
                        Key: ('Input11'),
                        Value: ''
                    },
                    Unit: {
                        Key: ('Input12'),
                        Value: 0
                    },
                    Avg: {
                        Key: ('Input13'),
                        Value: 0
                    },
                    Amount: {
                        Key: ('Input14'),
                        Value: 0
                    },
                    UpdateTypeCar: true
                }
                return updateobject;
            },

            CreateTransportPlaneRequest: function() {
                var updateobject = {
                    ReportArea: 0,
                    Year: 0,
                    RowId: 0,
                    FuelType: {
                        Key: ('Input19'),
                        Value: 0
                    },
                    BioFuel: {
                        Key: ('Input20'),
                        Value: 0
                    },
                    Usage: {
                        Key: ('Input21'),
                        Value: ''
                    },
                    Unit: {
                        Key: ('Input22'),
                        Value: 0
                    },
                    Avg: {
                        Key: (''),
                        Value: 0
                    },
                    Amount: {
                        Key: ('Input23'),
                        Value: 0
                    },
                    UpdateTypeCar: false
                }
                return updateobject;
            },

            CreateOutsourcedRequest: function() {
                var updateObject =
            {
                ReportArea: 4,
                Description: { Key: ('Input208'), Value: 0 },
                Amount: { Key: ('Input209'), Value: 0 }
            }
                return updateObject;
            },

            CreateFossileRequest: function() {
                var request = {
                    ReportArea: 0,
                    Year: 0,
                    RowId: 0,
                    FuelType: { Key: ('Input31'), Value: 0 },
                    Usage: { Key: ('Input32'), Value: 0 },
                    Unit: { Key: ('Input33'), Value: 0 },
                    Amount: { Key: ('Input34'), Value: 0 },
                    Gas: { Key: ('InputXXX'), Value: 0 },
                    RequestType: 0
                }
                return request;
            },

            CreateUseCarRequest: function() {
                var request = {
                    ReportArea: 0,
                    Year: 0,
                    RowId: 0,
                    BioFuel: { Key: ('Input68'), Value: 0 },
                    Usage: { Key: ('Input69'), Value: 0 },
                    Unit: { Key: ('Input70'), Value: 0 },
                    Distance: { Key: ('Input71'), Value: 0 },
                    Amount: { Key: ('Input72'), Value: 0 },
                    Type: { Key: ('Input67'), Value: 0 },
                    RequestType: 0
                }
                return request;
            },
            CreateUsePlaneRequest: function() {
                var request = {
                    ReportArea: 0,
                    Year: 0,
                    RowId: 0,
                    Usage: { Key: ('Input78'), Value: 0 },
                    //Distance: { Key: ('Input79'), Value: 0 },
                    Emission: { Key: ('Input1090'), Value: 0 },
                    //Type: { Key: ('Input77'), Value: 0 },
                    RequestType: 1
                }
                return request;
            },
            CreateUsePublicTransRequest: function() {
                var request = {
                    ReportArea: 0,
                    Year: 0,
                    RowId: 0,
                    Usage: { Key: ('Input85'), Value: 0 },
                    Distance: { Key: ('Input86'), Value: 0 },
                    Emission: { Key: ('Input1092'), Value: 0 },
                    Type: { Key: ('Input84'), Value: 0 },
                    RequestType: 2
                }
                return request;
            },
            CreateUseTaxiRequest: function() {
                var request = {
                    ReportArea: 0,
                    Year: 0,
                    RowId: 0,
                    Usage: { Key: ('Input90'), Value: 0 },
                    Distance: { Key: ('Input91'), Value: 0 },
                    RequestType: 3
                }
                return request;
            },
            CreateUseCommutingRequest: function() {
                var request = {
                    ReportArea: 0,
                    Year: 0,
                    RowId: 0,
                    FuelType: { Key: ('Input1093'), Value: 0 },
                    Avg: { Key: ('Input1096'), Value: 0 },
                    Distance: { Key: ('Input1082'), Value: 0 },
                    Type: { Key: ('Input1072'), Value: 0 },
                    RequestType: 4
                }
                return request;
            },

            ElectricityAndHeatRequest: function(requestType, inputFields) {
                var request = {
                    ReportArea: 2,
                    Year: 0,
                    Usage: {
                        Key: (inputFields[requestType].id),
                        Value: Ext.util.Format.htmlEncode(inputFields[requestType].value)
                    },
                    RequestType: requestType
                }
                return request;
            },


            CreateOrUpdateReportRequest: function(id) {
                var oReportName = document.getElementById("ReportEditReportName");
                //var oOwnOrg = document.getElementById("ReportEditOwnOrOtherOrg");
                var oOrgName = document.getElementById("ReportEditOrgName");
                var oContact = document.getElementById("ReportEditContact");
                var oEmail = document.getElementById("ReportEditEmail");
                var oOrgType = document.getElementById("ReportEditOrgType");
                //var oControlLimit = document.getElementById("ReportEditControlLimit");
                //var oControlLimitName = document.getElementById("ReportEditControlLimitName");
                var oMonth = document.getElementById("ReportEdit_ReportEditStartMonth");
                var oYear = document.getElementById("ReportEdit_ReportEditStartYear");
                var oMonthEnd = document.getElementById("ReportEdit_ReportEditEndMonth");
                var oYearEnd = document.getElementById("ReportEdit_ReportEditEndYear");
                //var oOrgLimit = document.getElementById("ReportEditOrgLimit");
                //var oUnit = document.getElementById("ReportEditUnit");
                var oEmployees = document.getElementById("ReportEditNumEmployees");
                var oKnowEco = document.getElementById("ReportEditKnownEconomy");
                var oEco = document.getElementById("ReportEditEconomy");
                //var oSourcesNotIncluded = document.getElementById("ReportEditSourcesNotIncluded");
                //var oSourcesNotIncludedName = document.getElementById("ReportEditSourcesNotIncludedName");

                //check they exist
                if (!oReportName /*|| !oOwnOrg*/ || !oOrgName || !oContact || !oEmail || !oOrgType || !oMonth || !oYear || !oMonthEnd || !oYearEnd /*||
                !oOrgLimit || !oUnit*/ || !oEmployees || !oKnowEco || !oEco /*|| !oControlLimit || !oControlLimitName || !oSourcesNotIncluded || !oSourcesNotIncludedName*/) return;

                var request = {
                    updateRequest: {
                        Id: id,
                        Name: Ext.util.Format.htmlEncode(oReportName.value),
                        //OwnOrOtherOrganisation: oOwnOrg.value,
                        OrganisationName: Ext.util.Format.htmlEncode(oOrgName.value),
                        ContactName: Ext.util.Format.htmlEncode(oContact.value),
                        Email: Ext.util.Format.htmlEncode(oEmail.value),
                        OrganisationType: oOrgType.value,
                        //LimitOfControl: oControlLimit.value,
                        //LimitOfControlName: Ext.util.Format.htmlEncode(oControlLimitName.value),
                        StartMonth: oMonth.value,
                        StartYear: oYear.value,
                        EndMonth: oMonthEnd.value,
                        EndYear: oYearEnd.value,
                        //LimitOfOrg: oOrgLimit.value,
                        //UnitName: Ext.util.Format.htmlEncode(oUnit.value),
                        NumberOfEmployees: Ext.util.Format.trim(oEmployees.value) == '' ? 0 : Ext.util.Format.trim(oEmployees.value),
                        KnowEconomy: oKnowEco.value,
                        Economy: oEco.value == '' ? 0 : oEco.value.replace(",", ".") //,
                        //SourcesNotIncluded: oSourcesNotIncluded.value,
                        //SourcesNotIncludedName: Ext.util.Format.htmlEncode(oSourcesNotIncludedName.value)
                    }
                };

                return request;
            },

            DeleteReportRequest: function(ReportId) {
                var request = {
                    reportId: ReportId
                }
                return request;
            },

            CreateOrUpdateReductionTargetRequest: function(reportId, reductionTargetId) {
                var oTotalTon = document.getElementById("ReductionTotalTon");
                var oScope1Ton = document.getElementById("ReductionTarget_ReductionScope1Ton");
                var oScope2Ton = document.getElementById("ReductionTarget_ReductionScope2Ton");
                var oScope3Ton = document.getElementById("ReductionTarget_ReductionScope3Ton");
                var oTotalPercent = document.getElementById("ReductionTotalPercent");
                var oScope1Percent = document.getElementById("ReductionScope1Percent");
                var oScope2Percent = document.getElementById("ReductionScope2Percent");
                var oScope3Percent = document.getElementById("ReductionScope3Percent");
                var oBaselineYear = document.getElementById("ReductionTarget_ReductionBaselineYear");
                var oYearUntillEnd = document.getElementById("ReductionYearsUntillEnd");
                var oManualScopeReduction = document.getElementById("ReductionTarget_cbxManuelReduction");

                //check they exist
                if (!oTotalTon || !oScope1Ton || !oScope2Ton || !oScope3Ton
                    || !oTotalPercent || !oScope1Percent || !oScope2Percent || !oScope3Percent
                    || !oBaselineYear || !oYearUntillEnd || !oManualScopeReduction) return;

                var request = {
                    updateRequest: {
                        Id: reductionTargetId,
                        ReportId: reportId,
                        ReductionTotalTon: oTotalTon.value == '' ? 0 : oTotalTon.value.replace(",", "."),
                        ReductionScope1Ton: oScope1Ton.innerHTML == '' ? 0 : oScope1Ton.innerHTML.replace(",", "."),
                        ReductionScope2Ton: oScope2Ton.innerHTML == '' ? 0 : oScope2Ton.innerHTML.replace(",", "."),
                        ReductionScope3Ton: oScope3Ton.innerHTML == '' ? 0 : oScope3Ton.innerHTML.replace(",", "."),
                        ReductionTotalPercent: oTotalPercent.value == '' ? 0 : oTotalPercent.value.replace(",", "."),
                        ReductionScope1Percent: oScope1Percent.value == '' ? 0 : oScope1Percent.value.replace(",", "."),
                        ReductionScope2Percent: oScope2Percent.value == '' ? 0 : oScope2Percent.value.replace(",", "."),
                        ReductionScope3Percent: oScope3Percent.value == '' ? 0 : oScope3Percent.value.replace(",", "."),
                        BaselineYear: oBaselineYear.value,
                        YearsUntillEnd: oYearUntillEnd.value == '' ? 0 : oYearUntillEnd.value,
                        ManualScopeReduction: oManualScopeReduction.checked
                    }
                };

                return request;
            },

            ClearReportAreaRequest: function(ReportAreaId) {
                var request = {
                    reportAreaId: ReportAreaId,
                    AreaType: 0
                }
                return request;
            },

            AddInputRequest: function(ReportAreaId, areaType, inputJSON, formulaId, callbackMethod) {
                var request = {
                    reportAreaId: ReportAreaId,
                    AreaType: areaType,
                    InputJSON: inputJSON,
                    FormulaId: formulaId,
                    CallbackMethod: callbackMethod
                }
                return request;
            },

            DeleteInputByReportAreaIdAndAreaCalculationIdRequest: function(ReportAreaId, areaCalculationId, callbackMethod) {
                var request = {
                    reportAreaId: ReportAreaId,
                    AreaCalculationId: areaCalculationId,
                    CallbackMethod: callbackMethod
                }
                return request;
            },

            DeleteInputByReportAreaIdAndAreaTypeRequest: function(ReportAreaId, areaType, callbackMethod) {
                var request = {
                    reportAreaId: ReportAreaId,
                    AreaType: areaType,
                    CallbackMethod: callbackMethod
                }
                return request;
            },

            SortReportsRequest: function(ColumnName) {
                var request = {
                    columnName: ColumnName
                }
                return request;
            },

            /*
            Create Login request. 
            */
            CreateLoginRequest: function() {
                /*Read from screen*/
                var oName = document.getElementById("LoginUsername");
                var oPwd = document.getElementById("LoginPassword");

                if (!oName || !oPwd) return;

                var request = {
                    username: Ext.util.Format.htmlEncode(oName.value),
                    password: Ext.util.Format.htmlEncode(oPwd.value)
                };

                return request;
            },

            CreateInitLoginRequest: function() {
                var req = ClimaController.Factory.CreateLoginRequest();
                req.username = ClimaController.Utils.GetCookie("ClimaUsername");
                req.password = ClimaController.Utils.GetCookie("ClimaPassword");
                return req;
            },


            CreateLostPassword: function() {
                /*Read from screen*/
                var oName = document.getElementById("LoginUsername");
                if (!oName) return;

                var request = {
                    username: Ext.util.Format.htmlEncode(oName.value)
                };

                return request;
            },

            /*
            Create New User request. 
            */
            CreateUser: function() {

                /*Read from screen*/
                var oName = document.getElementById("NewUserUsername");
                var oEmail = document.getElementById("NewUserEmail");
                var oFirstName = document.getElementById("NewUserFirstName");
                var oLastName = document.getElementById("NewUserLastName");
                var oOrgName = document.getElementById("NewUserOrgName");
                var oPwd = document.getElementById("NewUserPassword1");
                var oWantMail = document.getElementById("NewUserWantsMail");

                if (!oName || !oPwd || !oEmail || !oFirstName || !oLastName || !oOrgName || !oWantMail) return;

                var request = {
                    user: {
                        Username: Ext.util.Format.htmlEncode(oName.value),
                        Password: Ext.util.Format.htmlEncode(oPwd.value),
                        Email: Ext.util.Format.htmlEncode(oEmail.value),
                        FirstName: Ext.util.Format.htmlEncode(oFirstName.value),
                        LastName: Ext.util.Format.htmlEncode(oLastName.value),
                        OrganisationName: Ext.util.Format.htmlEncode(oOrgName.value),
                        WantMail: oWantMail.checked
                    }
                };

                return request;
            },

            CRUDConstantRequest: function(constantCode) {
                var oSelectYear = document.getElementById("ddlSelectYear");
                var oValue = document.getElementById(constantCode + 'Input');
                var oIndirectValue = document.getElementById(constantCode + 'IndirectInput');
                var oBeyondScopeValue = document.getElementById(constantCode + 'BeyondScopeInput');

                //check they exist
                if (!oSelectYear || !oValue || !oIndirectValue || !oBeyondScopeValue) return;

                var request = {
                    Year: oSelectYear.options[oSelectYear.selectedIndex].value,
                    ConstantCode: constantCode,
                    Value: oValue.value,
                    IndirectValue: oIndirectValue.value,
                    BeyondScopeValue: oBeyondScopeValue.value
                };

                return request;
            },

            CRUDTextRequest: function(key) {
                var oValue = document.getElementById(key + 'Input');
                var oSelectLanguage = document.getElementById("AdminText_ddlSelectlanguage");

                //check they exist
                if (!oValue || !oSelectLanguage) return;

                var request = {
                    Language: oSelectLanguage.value,
                    Key: key,
                    Value: Ext.util.Format.htmlEncode(oValue.value)
                };

                return request;
            },

            CreatePurchasedMaterialRequest: function(existing) {
                var request = {
                    ReportArea: 6,
                    Year: 0,
                    RowId: 0,
                    IsExistingMaterial: existing,
                    ExistingMaterialDropDownValue: { Key: 'Input911', Value: 0 },
                    NewMaterialName: { Key: 'Input946', Value: '' },
                    EmissionsFactor: { Key: existing ? 'Input950' : 'Input947', Value: 0 },
                    Amount: { Key: existing ? 'Input945' : 'Input948', Value: 0 }
                }
                return request;
            },

            CreateRemovalWasteRequest: function(existing, areaType) {
                var request = {
                    ReportArea: 8,
                    AreaType: areaType,
                    Year: 0,
                    RowId: 0,
                    IsExistingMaterial: existing,
                    IsWaterData: false,
                    ExistingMaterialDropDownValue: { Key: areaType == 0 ? 'Input953' : 'Input1002', Value: 0 },
                    NewMaterialName: { Key: areaType == 0 ? 'Input994' : 'Input1040', Value: '' },
                    Amount: { Key: areaType == 0 ? (existing ? 'Input952' : 'Input1053') : (existing ? 'Input1001' : 'Input1054'), Value: 0 },
                    LandfillEmissionsFactor: { Key: areaType == 0 ? (existing ? 'Input988' : 'Input995') : (existing ? 'Input1034' : 'Input1041'), Value: 0, BeyondScopeValue: 0 },
                    LandfillPercentage: { Key: areaType == 0 ? (existing ? 'Input989' : 'Input996') : (existing ? 'Input1035' : 'Input1042'), Value: 0 },
                    IncinerationEmissionsFactor: { Key: areaType == 0 ? (existing ? 'Input990' : 'Input997') : (existing ? 'Input1036' : 'Input1043'), Value: 0, BeyondScopeValue: 0 },
                    IncinerationPercentage: { Key: areaType == 0 ? (existing ? 'Input991' : 'Input998') : (existing ? 'Input1037' : 'Input1044'), Value: 0 },
                    RecyclingEmissionsFactor: { Key: areaType == 0 ? (existing ? 'Input992' : 'Input999') : (existing ? 'Input1038' : 'Input1045'), Value: 0, BeyondScopeValue: 0 },
                    RecyclingPercentage: { Key: areaType == 0 ? (existing ? 'Input993' : 'Input1000') : (existing ? 'Input1039' : 'Input1046'), Value: 0 }
                }

                return request;
            },

            DeleteTransportChainRequest: function(transportChainId) {
                var request = {
                    TransportChainId: transportChainId
                }
                return request;
            },

            SortTransportChainsRequest: function(columnName) {
                var request = {
                    columnName: columnName
                }
                return request;
            },

            CopyTransportChainRequest: function(transportChainId, newName) {
                var request = {
                    TransportChainId: transportChainId,
                    TransportChainName: newName
                }
                return request;
            },

            CopyTransportChainExceptOneLinkRequest: function(transportChainId, newName, transportChainLinkId) {
                var request = {
                    TransportChainId: transportChainId,
                    TransportChainName: newName,
                    TransportChainLinkId: transportChainLinkId
                }
                return request;
            },

            CopyTransportChainCreateUpdateLinkRequest: function(transportChainId, newName, transportChainLinkId) {
                var request = {
                    TransportChainId: transportChainId,
                    TransportChainName: newName
                };
                var createOrUpdateTransportChainRequest = ClimaController.Factory.CreateOrUpdateTransportChainLinkRequest(transportChainId, transportChainLinkId);

                request.TransportChainLink = createOrUpdateTransportChainRequest.updateRequest;
                return request;
            },

            ToggleActivateTransportChainRequest: function(transportChainId) {
                var request = {
                    TransportChainId: transportChainId
                }
                return request;
            },

            CreateOrUpdateTransportChainRequest: function(transportChainId) {
                var oTransportChainFrom = document.getElementById("TransportChainFrom");
                var oTransportChainTo = document.getElementById("TransportChainTo");
                var oTransportChainDescription = document.getElementById("TransportChainDescription");
                var oTransportChainName = document.getElementById("TransportChainName");

                //check they exist
                if (!oTransportChainFrom || !oTransportChainTo || !oTransportChainDescription || !oTransportChainName) return;

                var request = {
                    updateRequest: {
                        Id: transportChainId,
                        From: Ext.util.Format.htmlEncode(oTransportChainFrom.value),
                        To: Ext.util.Format.htmlEncode(oTransportChainTo.value),
                        Description: Ext.util.Format.htmlEncode(oTransportChainDescription.value),
                        Name: Ext.util.Format.htmlEncode(oTransportChainName.value)
                    }
                }
                return request;
            },

            CreateOrUpdateTransportChainLinkRequest: function(transportChainId, transportChainLinkId) {
                var oTransportChainLinkTransportType = document.getElementById("TransportChainLinkTransportType");
                var oTransportChainLinkTransportTypeDetail = document.getElementById("TransportChainLinkTransportTypeDetail");
                var oTransportChainLinkFrom = document.getElementById("TransportChainLinkFrom");
                var oTransportChainLinkTo = document.getElementById("TransportChainLinkTo");
                //var oTransportChainLinkName = document.getElementById("TransportChainLinkName");
                var oTransportChainLinkDistance = document.getElementById("TransportChainLinkDistance");

                //check they exist
                if (!oTransportChainLinkFrom || !oTransportChainLinkTo /*|| !oTransportChainLinkName*/ || !oTransportChainLinkDistance) return;

                var request = {
                    updateRequest: {
                        Id: transportChainLinkId,
                        From: Ext.util.Format.htmlEncode(oTransportChainLinkFrom.value),
                        To: Ext.util.Format.htmlEncode(oTransportChainLinkTo.value),
                        Distance: Ext.util.Format.htmlEncode(oTransportChainLinkDistance.value),
                        //Name: Ext.util.Format.htmlEncode(oTransportChainLinkName.value),
                        TransportChainId: transportChainId,
                        TransportType: oTransportChainLinkTransportType.value,
                        TransportTypeDetail: oTransportChainLinkTransportTypeDetail.value,
                        Constants: ClimaController.PageLogic.TransportChains.CurrentConstantsValues,
                        IsUsingDefaultValues: ClimaController.PageLogic.TransportChains.IsUsingDefaultValues(),
                        Year: Page.TransportChainLinkYear
                    }
                }

                return request;
            },

            DeleteTransportChainLinkRequest: function(transportChainLinkId) {
                var request = {
                    TransportChainLinkId: transportChainLinkId
                }
                return request;
            },

            SortTransportChainLinksRequest: function(columnName) {
                var request = {
                    columnName: columnName
                }
                return request;
            },

            GetTransportChainLinkRequest: function(transportChainLinkId) {
                var request = {
                    TransportChainLinkId: transportChainLinkId
                }
                return request;
            }



        }, //Factory


        Communication: {
            SendRequest: function(asyncParam) {
                if (ClimaController.Settings.CrossDomain) {
                    asyncParam.url = ClimaController.Settings.JSProxyURI;
                    ClimaController.Utils.JSRequest(asyncParam);
                }
                else {
                    asyncParam.url = ClimaController.Settings.SystemURI.concat("/" + asyncParam.action);
                    asyncParam.method = 'POST';
                    asyncParam.action = "";
                    asyncParam.success = eval(asyncParam.success);
                    asyncParam.failure = eval(asyncParam.failure);
                    Ext.Ajax.request(asyncParam);
                }
            }
        }, //Communication

        /**********************************************************/
        /* Validation routines. 
        /**********************************************************/
        Validation: {

            LoginReset: function() {
                var oError = document.getElementById("LoginError");
                var oError2 = document.getElementById("InsertUsername");
                var oError3 = document.getElementById("NoUsername");
                if (oError) oError.style.display = "none";
                if (oError2) oError2.style.display = "none";
                if (oError3) oError3.style.display = "none";
            },

            ValidUsername: function() {
                var oUsername = document.getElementById("LoginUsername");
                var oError2 = document.getElementById("InsertUsername");
                if (!oUsername || !oError2) return;

                if (ClimaController.Utils.Trim(oUsername.value) != "") return true;

                oError2.style.display = "block";
                return false;
            },

            /*
            Validates the create new user fields. 
            If fields do not validation highlight their titles (red) and return false. 
            */
            NewUserFields: function(validateUsername) {
                //get fields
                var oUsername = document.getElementById("NewUserUsername");
                var oEmail = document.getElementById("NewUserEmail");
                var oFirstName = document.getElementById("NewUserFirstName");
                var oLastName = document.getElementById("NewUserLastName");
                var oOrgName = document.getElementById("NewUserOrgName");
                var oPwd1 = document.getElementById("NewUserPassword1");
                var oPwd2 = document.getElementById("NewUserPassword2");

                //get error fields
                var oEmptyFieldsError = document.getElementById("NewUserEmptyFieldsError");
                var oPasswordError = document.getElementById("NewUserPasswordError");

                //check they exist
                if (!oUsername || !oEmail || !oFirstName || !oLastName || !oOrgName || !oPwd1 || !oPwd2) return;
                if (!oEmptyFieldsError || !oPasswordError) return;

                var oFields;
                if (validateUsername) oFields = new Array(oUsername, oEmail, oFirstName, oLastName, oOrgName, oPwd1, oPwd2);
                else oFields = new Array(oEmail, oFirstName, oLastName, oOrgName, oPwd1, oPwd2);
                var oErrorFields = new Array(oEmptyFieldsError, oPasswordError);


                //Reset previous validation
                ClimaController.Validation.Reset(oFields, oErrorFields);


                //Validate username, email, firstname, lastname, orgname, pwd1 and pwd2 not empty
                var oEmptyFields = ClimaController.Validation.ValidateNotEmpty(oFields);

                //Paint titles of empty fields red
                if (oEmptyFields.length > 0) {
                    ClimaController.Validation.HighlightTitles(oEmptyFields);
                    oEmptyFieldsError.style.display = "block";
                    return false;
                }
                //Validate pwd1 and pwd2 are equal
                oFields = new Array(oPwd1, oPwd2);
                if (!ClimaController.Validation.ValidateEqual(oFields)) {
                    //Paint titles of pwd1 and pwd2 red if not equal
                    ClimaController.Validation.HighlightTitles(oFields);
                    oPasswordError.style.display = "block";
                    return false;
                }

                return true;
            },

            CreateUpdateReport: function() {

                //get fields
                var oReportName = document.getElementById("ReportEditReportName");
                //var oOwnOrg = document.getElementById("ReportEditOwnOrOtherOrg");
                var oOrgName = document.getElementById("ReportEditOrgName");
                var oContact = document.getElementById("ReportEditContact");
                var oEmail = document.getElementById("ReportEditEmail");
                var oOrgType = document.getElementById("ReportEditOrgType");
                //var oControlLimit = document.getElementById("ReportEditControlLimit");
                //var oControlLimitName = document.getElementById("ReportEditControlLimitName");
                //var oOrgLimit = document.getElementById("ReportEditOrgLimit");
                //var oUnit = document.getElementById("ReportEditUnit");
                var oEmployees = document.getElementById("ReportEditNumEmployees");
                var oKnowEco = document.getElementById("ReportEditKnownEconomy");
                var oEco = document.getElementById("ReportEditEconomy");
                //var oSourcesNotIncluded = document.getElementById("ReportEditSourcesNotIncluded");
                //var oSourcesNotIncludedName = document.getElementById("ReportEditSourcesNotIncludedName");

                //get error fields 
                var oEmptyFieldsError = document.getElementById("ReportEditEmptyFieldsError");
                var oNoValueChosenError = document.getElementById("ReportEditNoValueChosenError");
                var oNumericValueError = document.getElementById("ReportEditNumericValueError");

                //check they exist
                if (!oReportName /*|| !oOwnOrg*/ || !oOrgName || !oContact || !oEmail || !oOrgType /*|| !oControlLimit || !oControlLimitName ||
                !oOrgLimit || !oUnit*/ || !oEmployees || !oKnowEco || !oEco /*|| !oSourcesNotIncluded || !oSourcesNotIncludedName*/) return;
                if (!oEmptyFieldsError || !oNoValueChosenError || !oNumericValueError) return;

                var oTextFieldsToValidate = new Array(oReportName/*, oOrgName*/, oContact, oEmail/*, oUnit, oEco, oSourcesNotIncludedName, oControlLimitName*/);
                var oDropDownsToValidate = new Array(oOrgType/*, oControlLimit, oSourcesNotIncluded*/);
                var oIntegerFieldsToValidate = new Array(oEmployees);
                var oNumericFieldsToValidate = new Array(oEco);
                var oErrorFields = new Array(oEmptyFieldsError, oNoValueChosenError, oNumericValueError);

                //Reset previous validation
                ClimaController.Validation.Reset(oTextFieldsToValidate.concat(oDropDownsToValidate).concat(oIntegerFieldsToValidate).concat(oNumericFieldsToValidate), oErrorFields);
                var oErrorFieldsToDisplay = new Array();
                var oFieldsToHighLightTitles = new Array();
                var isValid = true;

                //                //remove validation of LimitControlName textbox, if selectedindex is NOT 4 of LimitControl dropdown
                //                if (oControlLimit.selectedIndex != 4) {
                //                    oTextFieldsToValidate.pop();
                //                }

                //                //remove validation of oSourcesNotIncludedName textbox, if selectedindex is NOT 1 (YES value) of oSourcesNotIncluded dropdown
                //                if (oSourcesNotIncluded.selectedIndex != 1) {
                //                    oTextFieldsToValidate.splice(6, 1);
                //                }

                //remove validation of Economy textbox, if selectedindex is 2 of Economy dropdown
                if (oKnowEco.selectedIndex == 2) {
                    oTextFieldsToValidate.splice(5, 1);
                    oNumericFieldsToValidate.pop();
                }
                //                //remove validation of Unit textbox, if selected index is 0 of Limit dropdown
                //                if (oOrgLimit.selectedIndex == 0) {
                //                    oTextFieldsToValidate.splice(4, 1);
                //                }

                if (Ext.util.Format.trim(oEmployees.value) == '') {
                    oIntegerFieldsToValidate.pop();
                }

                //Validate oTextFieldsToValidate fields are not empty
                var oEmptyFields = ClimaController.Validation.ValidateNotEmpty(oTextFieldsToValidate);
                //Paint titles of empty fields red
                if (oEmptyFields.length > 0) {
                    oErrorFieldsToDisplay.push(oEmptyFieldsError);
                    for (var i = 0; i < oEmptyFields.length; i++) {
                        oFieldsToHighLightTitles.push(oEmptyFields[i]);
                    }
                    isValid = false;
                }

                //Validate oDropDownsToValidate dropdown have a value chosen
                var oNonValueDropDowns = ClimaController.Validation.ValidateValueChosen(oDropDownsToValidate);
                //Paint titles of empty fields red
                if (oNonValueDropDowns.length > 0) {
                    oErrorFieldsToDisplay.push(oNoValueChosenError);
                    for (var i = 0; i < oNonValueDropDowns.length; i++) {
                        oFieldsToHighLightTitles.push(oNonValueDropDowns[i]);
                    }
                    isValid = false;
                }

                //Validate oIntegerFieldsToValidate
                var oNonIntegerFields = ClimaController.Validation.ValidateInteger(oIntegerFieldsToValidate);
                if (oNonIntegerFields.length > 0) {
                    oErrorFieldsToDisplay.push(oNumericValueError);
                    for (var i = 0; i < oNonIntegerFields.length; i++) {
                        oFieldsToHighLightTitles.push(oNonIntegerFields[i]);
                    }
                    isValid = false;
                }

                //Validate oNumericFieldsToValidate 
                var oNonNumericFields = ClimaController.Validation.ValidateNumeric(oNumericFieldsToValidate);
                if (oNonNumericFields.length > 0) {
                    oErrorFieldsToDisplay.push(oNumericValueError);
                    for (var i = 0; i < oNonNumericFields.length; i++) {
                        oFieldsToHighLightTitles.push(oNonNumericFields[i]);
                    }
                    isValid = false;
                }

                //HighlightTitles and show errors
                if (!isValid) {
                    ClimaController.Validation.HighlightTitles(oFieldsToHighLightTitles, oErrorFieldsToDisplay);
                    if (oErrorFieldsToDisplay.length > 0) oErrorFieldsToDisplay[0].scrollIntoView(true);
                }

                return isValid;
            },

            CreateUpdateReductionTarget: function() {

                //get fields
                var oTotalTon = document.getElementById("ReductionTotalTon");
                //var oScope1Ton = document.getElementById("ReductionTarget_ReductionScope1Ton");
                //var oScope2Ton = document.getElementById("ReductionTarget_ReductionScope2Ton");
                //var oScope3Ton = document.getElementById("ReductionTarget_ReductionScope3Ton");
                var oTotalPercent = document.getElementById("ReductionTotalPercent");
                var oScope1Percent = document.getElementById("ReductionScope1Percent");
                var oScope2Percent = document.getElementById("ReductionScope2Percent");
                var oScope3Percent = document.getElementById("ReductionScope3Percent");
                var oYearUntillEnd = document.getElementById("ReductionYearsUntillEnd");

                //get error fields
                var oNumericValueError = document.getElementById("ReductionNumericValueError");
                var oNumericIntegerError = document.getElementById("ReductionIntegerValueError");
                var oNumericTotalError = document.getElementById("ReductionTotalError");
                var oNumericPercentagesError = document.getElementById("ReductionPercentagesError");

                //check they exist
                if (!oTotalTon
                //|| !oScope1Ton || !oScope2Ton || !oScope3Ton
                    || !oTotalPercent || !oScope1Percent || !oScope2Percent || !oScope3Percent
                    || !oYearUntillEnd) return;
                if (!oNumericValueError || !oNumericIntegerError || !oNumericPercentagesError || !oNumericTotalError) return;

                var oNumericFieldsToValidate = new Array(oTotalTon,
                //oScope1Ton, oScope2Ton, oScope3Ton, 
                    oTotalPercent, oScope1Percent, oScope2Percent, oScope3Percent);
                var oErrorFields = new Array(oNumericValueError, oNumericIntegerError, oNumericPercentagesError, oNumericTotalError);

                //Reset previous validation
                ClimaController.Validation.Reset(oNumericFieldsToValidate, oErrorFields);
                var oErrorFieldsToDisplay = new Array();
                var oFieldsToHighLightTitles = new Array();
                var isValid = true;

                //Validate oNumericFieldsToValidate 
                var oNonNumericFields = ClimaController.Validation.ValidateNumeric(oNumericFieldsToValidate);
                if (oNonNumericFields.length > 0) {
                    oErrorFieldsToDisplay.push(oNumericValueError);
                    for (var i = 0; i < oNonNumericFields.length; i++) {
                        oFieldsToHighLightTitles.push(oNonNumericFields[i]);
                    }
                    isValid = false;
                }

                //Validate for integer in oYearUntillEnd
                if (oYearUntillEnd.value.replace(",", ".") != parseInt(oYearUntillEnd.value.replace(",", "."))) {
                    oErrorFieldsToDisplay.push(oNumericIntegerError);
                    oFieldsToHighLightTitles.push(oYearUntillEnd);
                    isValid = false;
                }

                //Validate that  0 <= oTotalPercent <= 100
                if (parseFloat(oTotalPercent.value.replace(",", ".")) < 0.00 || parseFloat(oTotalPercent.value.replace(",", ".")) > 100.00) {
                    oErrorFieldsToDisplay.push(oNumericTotalError);
                    isValid = false;
                }

                var oCbxManuelReduction = document.getElementById('ReductionTarget_cbxManuelReduction');
                if (oCbxManuelReduction.checked == true) {
                    if (parseFloat(oScope1Percent.value.replace(",", "."))
                    + parseFloat(oScope2Percent.value.replace(",", "."))
                    + parseFloat(oScope3Percent.value.replace(",", ".")) != 100.00) {
                        oErrorFieldsToDisplay.push(oNumericPercentagesError);
                        isValid = false;
                    }

                }

                //HighlightTitles and show errors
                if (!isValid) {
                    ClimaController.Validation.HighlightTitles(oFieldsToHighLightTitles, oErrorFieldsToDisplay);
                    if (oErrorFieldsToDisplay.length > 0) oErrorFieldsToDisplay[0].scrollIntoView(true);
                }

                return isValid;
            },

            /*
            * Only validates 1 textfield at a time
            * Return true if it is valid
            */
            ReportFocus1ProcessPart: function(inputField) {
                var oErrorField = document.getElementById(inputField.id + 'Error');
                if (!oErrorField) return;

                //reset validation
                oErrorField.style.display = "none";

                if (inputField.value == "") inputField.value = 0;
                var oNonNumericValues = ClimaController.Validation.ValidateNumeric(new Array(inputField));
                if (oNonNumericValues.length > 0) oErrorField.style.display = "block";

                return oNonNumericValues.length == 0;
            },

            /*
            * Only validates 1 textfield at a time
            * Return true if it is valid
            */
            ReportFocus2: function(field) {
                //get fields
                var oTxtElecWest = document.getElementById('Input52');
                var oTxtElecEast = document.getElementById('Input54');
                var oTxtElecNeutral = document.getElementById('Input56');
                var oTxtHeat = document.getElementById('Input58');
                //var oTxtSurplusHeat = document.getElementById('Input60');
                //error field
                var oErrorField = document.getElementById('ReportFocus2Error');

                //check if they exist
                if (!oTxtElecEast
                    || !oTxtElecNeutral
                    || !oTxtElecWest
                    || !oTxtHeat
                //|| !oTxtSurplusHeat
                    ) return;
                if (!oErrorField) return;

                //reset validation
                var oFields = new Array(oTxtElecEast, oTxtElecNeutral, oTxtElecWest, oTxtHeat/*, oTxtSurplusHeat*/);
                ClimaController.Validation.Reset(oFields, new Array(oErrorField));

                if (!field) return;

                if (field.value == "") field.value = 0;
                var oNonNumericValues = ClimaController.Validation.ValidateNumeric(oFields);
                if (oNonNumericValues.length > 0) ClimaController.Validation.HighlightTitles(oNonNumericValues, new Array(oErrorField));

                return oNonNumericValues.length == 0;
            },

            ValidateValueChosen: function(dropdowns) {
                if (!dropdowns || dropdowns.length == null) return;

                var oNonValueDropDowns = new Array();
                for (var i = 0; i < dropdowns.length; i++) {
                    var dropdown = dropdowns[i];
                    if (!dropdown) return;

                    if (!dropdown.selectedIndex || dropdown.selectedIndex == 0)
                        oNonValueDropDowns.push(dropdown);
                }
                return oNonValueDropDowns;
            },

            ValidateNotEmpty: function(fields) {
                if (!fields || fields.length == null) return;

                var oEmptyFields = new Array();
                for (var i = 0; i < fields.length; i++) {
                    var field = fields[i];
                    if (!field) return;

                    if (!field.value || field.value.trim() == "")
                        oEmptyFields.push(field);
                }
                return oEmptyFields;
            },

            ValidateEqual: function(fields) {
                if (!fields || fields.length == null || fields.length < 2) return;

                var equal = true;
                var firstField = fields[0];
                if (!firstField) return;

                for (var i = 1; i < fields.length; i++) {
                    var nextField = fields[i];
                    if (!nextField) return;

                    if (firstField.value != nextField.value) {
                        equal = false;
                        break;
                    }
                }
                return equal;
            },

            ValidateInteger: function(fields) {
                var pattern = /^\d+$/g;
                return ClimaController.Validation.ValidateWithPattern(fields, pattern);
            },
            //        
            //        ValidateDouble : function(fields) {
            //            var pattern = /^(\d*,)?\d+$/g;     
            //            return ClimaController.Validation.ValidateWithPattern(fields, pattern);
            //        },

            ValidateNumeric: function(fields) {
                var oNonNumericFields = new Array();
                for (var i = 0; i < fields.length; i++) {
                    var field = fields[i];
                    if (!field) return;
                    var val = field.value.replace(",", ".");
                    if (isNaN(val)) { //isNan doesnt work with ',' so replaced to '.'
                        oNonNumericFields.push(field);
                    }
                    //else its a valid number and correct value must be shown...
                    else {
                        //replace resets caret position in IE, so we try to get the position before replace and set it back
                        var setCaretPosition = false;
                        if (document.activeElement && document.activeElement == field) setCaretPosition = true;
                        if (setCaretPosition) {
                            var pos = ClimaController.Utils.GetCaretPosition(field);
                            field.value = field.value.replace(".", ","); //so replace '.' to ',' for danish
                            ClimaController.Utils.SetCaretPosition(field, pos);
                        }
                        else {
                            field.value = field.value.replace(".", ","); //so replace '.' to ',' for danish
                        }
                    }
                }

                return oNonNumericFields;
            },

            ValidateWithPattern: function(fields, pattern) {
                var oWrongValueFields = new Array();
                for (var i = 0; i < fields.length; i++) {
                    var field = fields[i];
                    if (!field) return;

                    if (field.value.match(pattern) != field.value) {
                        oWrongValueFields.push(field);
                    }
                }

                return oWrongValueFields;
            },



            HighlightTitles: function(fields, errorFields) {
                if (!fields || fields.length == null) return;

                for (var i = 0; i < fields.length; i++) {
                    var field = fields[i];
                    if (!field) return;
                    var fieldTitle = document.getElementById(field.id + "Title");
                    if (!fieldTitle) break;

                    ClimaController.Utils.AddCssClass(fieldTitle, "Error");
                    fieldTitle.style.display = "block";
                }

                if (!errorFields || errorFields.length == null) return;

                for (var i = 0; i < errorFields.length; i++) {
                    var errorField = errorFields[i];
                    if (!errorField || !errorField.style) return;
                    errorField.style.display = "block";
                }
            },

            Reset: function(fields, errorFields) {
                if (!fields || fields.length == null || !errorFields || errorFields.length == null) return;
                for (var i = 0; i < fields.length; i++) {
                    var field = fields[i];

                    if (!field || !field.id) return;
                    var fieldTitle = document.getElementById(field.id + "Title");

                    if (!fieldTitle) break;

                    ClimaController.Utils.RemoveCssClass(fieldTitle, "Error");
                }

                for (var i = 0; i < errorFields.length; i++) {
                    var errorField = errorFields[i];
                    if (!errorField || !errorField.style) return;
                    errorField.style.display = "none";
                }
            },

            UsernameExists: function(exists) {

                var oDiv = document.getElementById("NewUserUsernameError");
                var oUsername = document.getElementById("NewUserUsername");

                if (!oDiv || !oUsername) return;

                if (exists) ClimaController.Validation.HighlightTitles(new Array(oUsername), new Array(oDiv));
                else ClimaController.Validation.Reset(new Array(oUsername), new Array(oDiv));
            },

            CreateUpdateTransportChain: function() {

                //get fields
                var oTransportChainFrom = document.getElementById("TransportChainFrom");
                var oTransportChainTo = document.getElementById("TransportChainTo");
                var oTransportChainDescription = document.getElementById("TransportChainDescription");
                var oTransportChainName = document.getElementById("TransportChainName");

                //get error fields
                var oEmptyFieldsError = document.getElementById("TransportChainEmptyFieldsError");

                //check they exist
                if (!oTransportChainFrom || !oTransportChainTo || !oTransportChainDescription || !oTransportChainName) return;
                if (!oEmptyFieldsError) return;

                var oTextFieldsToValidate = new Array(oTransportChainFrom, oTransportChainTo, oTransportChainDescription, oTransportChainName);
                var oErrorFields = new Array(oEmptyFieldsError);

                //Reset previous validation
                ClimaController.Validation.Reset(oTextFieldsToValidate, oErrorFields);
                var oErrorFieldsToDisplay = new Array();
                var oFieldsToHighLightTitles = new Array();
                var isValid = true;

                //Validate oTextFieldsToValidate fields are not empty
                var oEmptyFields = ClimaController.Validation.ValidateNotEmpty(oTextFieldsToValidate);
                //Paint titles of empty fields red
                if (oEmptyFields.length > 0) {
                    oErrorFieldsToDisplay.push(oEmptyFieldsError);
                    for (var i = 0; i < oEmptyFields.length; i++) {
                        oFieldsToHighLightTitles.push(oEmptyFields[i]);
                    }
                    isValid = false;
                }

                //HighlightTitles and show errors
                if (!isValid) {
                    ClimaController.Validation.HighlightTitles(oFieldsToHighLightTitles, oErrorFieldsToDisplay);
                    if (oErrorFieldsToDisplay.length > 0) oErrorFieldsToDisplay[0].scrollIntoView(true);
                }

                return isValid;
            },

            CreateUpdateTransportChainLink: function() {

                //get fields
                var oTransportChainLinkFrom = document.getElementById("TransportChainLinkFrom");
                var oTransportChainLinkTo = document.getElementById("TransportChainLinkTo");
                var oTransportChainLinkDistance = document.getElementById("TransportChainLinkDistance");
                //var oTransportChainLinkName = document.getElementById("TransportChainLinkName");

                //get error fields
                var oEmptyFieldsError = document.getElementById("TransportChainLinkEmptyFieldsError");
                var oNumericValueError = document.getElementById("TransportChainLinkNumericValueError");
                var oEmptyParentError = document.getElementById("TransportChainLinkNoParentError");

                //check they exist
                if (!oTransportChainLinkFrom || !oTransportChainLinkTo || !oTransportChainLinkDistance /*|| !oTransportChainLinkName*/) return;
                if (!oEmptyFieldsError || !oNumericValueError) return;

                var oTextFieldsToValidate = new Array(oTransportChainLinkFrom, oTransportChainLinkTo/*, oTransportChainLinkName*/, oTransportChainLinkDistance);
                var oNumericFieldsToValidate = new Array(oTransportChainLinkDistance);
                var oErrorFields = new Array(oNumericValueError, oEmptyFieldsError, oEmptyParentError);

                //Reset previous validation
                ClimaController.Validation.Reset(oTextFieldsToValidate, oErrorFields);
                var oErrorFieldsToDisplay = new Array();
                var oFieldsToHighLightTitles = new Array();
                var isValid = true;

                //Validate oTextFieldsToValidate fields are not empty
                var oEmptyFields = ClimaController.Validation.ValidateNotEmpty(oTextFieldsToValidate);
                //Paint titles of empty fields red
                if (oEmptyFields.length > 0) {
                    oErrorFieldsToDisplay.push(oEmptyFieldsError);
                    for (var i = 0; i < oEmptyFields.length; i++) {
                        oFieldsToHighLightTitles.push(oEmptyFields[i]);
                    }
                    isValid = false;
                }

                //Validate oNumericFieldsToValidate 
                var oNonNumericFields = ClimaController.Validation.ValidateNumeric(oNumericFieldsToValidate);
                if (oNonNumericFields.length > 0) {
                    oErrorFieldsToDisplay.push(oNumericValueError);
                    for (var i = 0; i < oNonNumericFields.length; i++) {
                        oFieldsToHighLightTitles.push(oNonNumericFields[i]);
                    }
                    isValid = false;
                }

                //empty transportchain parent?
                if (Page.TransportChainId == 0) {
                    oErrorFieldsToDisplay.push(oEmptyParentError);
                    isValid = false;
                }

                //HighlightTitles and show errors
                if (!isValid) {
                    ClimaController.Validation.HighlightTitles(oFieldsToHighLightTitles, oErrorFieldsToDisplay);
                    if (oErrorFieldsToDisplay.length > 0) oErrorFieldsToDisplay[0].scrollIntoView(true);
                }

                return isValid;
            }
        }, //Validation

        /**********************************************************/
        /* Utils 
        /**********************************************************/
        Utils: {

            ClearKeys: function() {
                var search = ClimaController.Utils.ClearKey("ReportId");
                search = ClimaController.Utils.ClearKey("Year", search);
                search = ClimaController.Utils.ClearKey("Section", search);
                search = ClimaController.Utils.ClearKey("Session", search);
                search = ClimaController.Utils.ClearKey("Ids", search);
                search = ClimaController.Utils.ClearKey("AdminLanguage", search);

                return search;
            },

            ClearKey: function(haystack, search) {

                if (!search) search = window.location.search;

                var startindex = search.indexOf(haystack + "=");

                if (startindex > -1) {
                    startindex2 = startindex + (haystack + "=").length;
                    search = search.replace(haystack + "][^&]*&", "");

                    var rest = search.substring(startindex2);
                    nextDelimiter = rest.indexOf("&");
                    var endindex = 0;
                    if (nextDelimiter > -1) endindex = startindex2 + nextDelimiter;
                    else endindex = search.length;

                    var SectionString = search.substring(startindex, endindex);

                    if (search.charAt(startindex - 1) == "&")
                        SectionString = "&" + SectionString;

                    search = search.replace(SectionString, "");
                }
                return search;
            },


            /*
            Method for replacing the 'Section' parameter in the current URI. 
            @param: newsection - Name of section to replace with. 
            @return: a new URI - with the section variable replaced
            */
            ReplaceKeyValue: function(newsection, searchparam, urlparam, hay) {
                var haystack = "Section";
                if (hay) haystack = hay;

                var url = "";
                if (urlparam) url = urlparam;
                else url = window.location.href.replace(window.location.search, "").replace("#", "");

                var search = window.location.search;
                if (searchparam) search = searchparam;


                search = ClimaController.Utils.ClearKey(haystack, search);


                if (search == "") search = "?" + haystack + "=" + newsection;
                else if (search == "?") search += haystack + "=" + newsection;
                else search += "&" + haystack + "=" + newsection;
                search = search.replace("?&", "?");

                return { url: url, search: search };
            },

            /*
            Cookie handling
            */
            GetCookieVal: function(offset) {
                var endstr = document.cookie.indexOf(";", offset);
                if (endstr == -1)
                    endstr = document.cookie.length;
                return unescape(document.cookie.substring(offset, endstr));
            },

            /*
            Cookie handling
            */
            GetCookie: function(name) {
                var arg = name + "=";
                var alen = arg.length;
                var clen = document.cookie.length;
                var i = 0;
                while (i < clen) {
                    var j = i + alen;
                    if (document.cookie.substring(i, j) == arg)
                        return ClimaController.Utils.GetCookieVal(j);
                    i = document.cookie.indexOf(" ", i) + 1;
                    if (i == 0) break;
                }
                return null;
            },

            /*
            Cookie handling
            */
            SetCookie: function(cname, cvalue) {
                var argv = ClimaController.Utils.SetCookie.arguments;
                var argc = ClimaController.Utils.SetCookie.arguments.length;
                var expires = (argc > 2) ? argv[2] : null;
                var path = (argc > 3) ? argv[3] : null;
                var domain = (argc > 4) ? argv[4] : null;
                var secure = (argc > 5) ? argv[5] : false;
                document.cookie = cname + "=" + escape(cvalue) +
            ((expires == null) ? "" : ("; expires=" + expires.toGMTString())) +
            ((path == null) ? "" : ("; path=" + path)) +
            ((domain == null) ? "" : ("; domain=" + domain)) +
            ((secure == true) ? "; secure" : "");

            },

            /*
            Method for adding a css class to an element
            */
            AddCssClass: function(element, className) {
                if (!element || !className) return;
                element.setAttribute("class", element.getAttribute("class") + " " + className);
            },

            /* 
            Method for removing a css class from an element
            */
            RemoveCssClass: function(element, className) {

                if (!element || !className) return;
                var classNameAttr = element.getAttribute("class");
                if (!classNameAttr) classNameAttr = element.getAttribute("className");
                if (!className) return;
                var classNames = classNameAttr.split(" ");
                classNames.remove(className);
                element.setAttribute("class", classNames.join(" "));
            },

            Trim: function(str) {
                return ClimaController.Utils.LTrim(ClimaController.Utils.RTrim(str, ' '), ' ');
            },

            LTrim: function(str, chars) {
                chars = chars || "\\s";
                return str.replace(new RegExp("^[" + chars + "]+", "g"), "");
            },

            RTrim: function(str, chars) {
                chars = chars || "\\s";
                return str.replace(new RegExp("[" + chars + "]+$", "g"), "");
            },


            JSRequest: function(request) {
                //if (!ClimaController.Settings.ScriptBlock) {
                var headID = document.getElementsByTagName("head")[0];
                ClimaController.Settings.ScriptBlock = document.createElement('script');
                ClimaController.Settings.ScriptBlock.type = 'text/javascript';

                headID.appendChild(ClimaController.Settings.ScriptBlock);
                // }

                var url = request.url;
                var search = "";
                search = search.concat("Action=" + request.action);
                search = search.concat("&Params=" + ClimaController.Utils.EncodeHTML(request.params));
                search = search.concat("&Failure=" + request.failure);
                search = search.concat("&Success=" + request.success);
                search = search.concat("&Ticket=" + ClimaController.Utils.CreateUniqueId());

                url = url.concat("?Payload=" + ClimaController.Utils.base64Encode(search));

                if (ClimaController.Settings.SessionID)
                    url = url.concat("&Session=" + ClimaController.Settings.SessionID);
                ClimaController.Settings.ScriptBlock.src = url;
            },

            EncodeHTML: function(searchstring) {
                var returnString = escape(searchstring); returnString = returnString.replace(/\+/g, "%2B");
                return returnString;
            },
            DecodeHTML: function(searchstring) { return unescape(searchstring); },


            CreateUniqueId: function() {
                var today = new Date();
                return today.getMilliseconds() + today.getSeconds() * 1000 + today.getMinutes() * 60 * 1000 + today.getHours() * 60 * 60 * 1000 + today.getDay() * 24 * 60 * 60 * 1000 + (today.getFullYear() - 1970) * 365 * 24 * 60 * 60 * 1000;
            },



            // Load the lookup arrays once
            initBase64: function() {
                var enc64List, dec64List;
                enc64List = new Array();
                dec64List = new Array();
                var i;
                for (i = 0; i < 26; i++) {
                    enc64List[enc64List.length] = String.fromCharCode(65 + i);
                }
                for (i = 0; i < 26; i++) {
                    enc64List[enc64List.length] = String.fromCharCode(97 + i);
                }
                for (i = 0; i < 10; i++) {
                    enc64List[enc64List.length] = String.fromCharCode(48 + i);
                }
                enc64List[enc64List.length] = "+";
                enc64List[enc64List.length] = "/";
                for (i = 0; i < 128; i++) {
                    dec64List[dec64List.length] = -1;
                }
                for (i = 0; i < 64; i++) {
                    dec64List[enc64List[i].charCodeAt(0)] = i;
                }

                return { enc64List: enc64List, dec64List: dec64List };
            },

            base64Encode: function(str) {
                var o = ClimaController.Utils.initBase64();
                var enc64List = o.enc64List;
                var dec64List = o.dec64List;
                var c, d, e, end = 0;
                var u, v, w, x;
                var ptr = -1;
                var input = str.split("");
                var output = "";
                while (end == 0) {
                    c = (typeof input[++ptr] != "undefined") ? input[ptr].charCodeAt(0) :
                    ((end = 1) ? 0 : 0);
                    d = (typeof input[++ptr] != "undefined") ? input[ptr].charCodeAt(0) :
                    ((end += 1) ? 0 : 0);
                    e = (typeof input[++ptr] != "undefined") ? input[ptr].charCodeAt(0) :
                    ((end += 1) ? 0 : 0);
                    u = enc64List[c >> 2];
                    v = enc64List[(0x00000003 & c) << 4 | d >> 4];
                    w = enc64List[(0x0000000F & d) << 2 | e >> 6];
                    x = enc64List[e & 0x0000003F];

                    // handle padding to even out unevenly divisible string lengths
                    if (end >= 1) { x = "="; }
                    if (end == 2) { w = "="; }

                    if (end < 3) { output += u + v + w + x; }
                }
                // format for 76-character line lengths per RFC
                var formattedOutput = "";
                var lineLength = 76;
                while (output.length > lineLength) {
                    formattedOutput += output.substring(0, lineLength) + "\n";
                    output = output.substring(lineLength);
                }
                formattedOutput += output;
                return formattedOutput;
            },

            base64Decode: function(str) {
                var o = ClimaController.Utils.initBase64();
                var enc64List = o.enc64List;
                var dec64List = o.dec64List;
                var c = 0, d = 0, e = 0, f = 0, i = 0, n = 0;
                var input = str.split("");
                var output = "";
                var ptr = 0;
                do {
                    f = input[ptr++].charCodeAt(0);
                    i = dec64List[f];
                    if (f >= 0 && f < 128 && i != -1) {
                        if (n % 4 == 0) {
                            c = i << 2;
                        } else if (n % 4 == 1) {
                            c = c | (i >> 4);
                            d = (i & 0x0000000F) << 4;
                        } else if (n % 4 == 2) {
                            d = d | (i >> 2);
                            e = (i & 0x00000003) << 6;
                        } else {
                            e = e | i;
                        }
                        n++;
                        if (n % 4 == 0) {
                            output += String.fromCharCode(c) +
                                String.fromCharCode(d) +
                                String.fromCharCode(e);
                        }
                    }
                }
                while (typeof input[ptr] != "undefined");
                output += (n % 4 == 3) ? String.fromCharCode(c) + String.fromCharCode(d) :
                    ((n % 4 == 2) ? String.fromCharCode(c) : "");
                return output;
            },

            //Find value of dictionary in the form of "DictionaryName" : [{"Key":"...","Value":"..."},...,{"Key":"...","Value":"..."}]
            GetValueOf: function(dictionary, keyName) {
                var index = -1;
                for (var i = 0; i < dictionary.length && index == -1; i++) {
                    if (dictionary[i].Key == keyName) index = i;
                }

                if (index == -1) return;
                return dictionary[index].Value;
            },

            /*
            **  Returns the caret (cursor) position of the specified text field.
            **  Return value range is 0-oField.length.
            */
            GetCaretPosition: function(oField) {

                // Initialize
                var iCaretPos = 0;

                // IE Support
                if (document.selection) {

                    // Set focus on the element
                    //oField.focus();

                    // To get cursor position, get empty selection range
                    var oSel = document.selection.createRange().duplicate();

                    // Move selection start to 0 position
                    oSel.moveStart('character', -oField.value.length);

                    // The caret position is selection length
                    iCaretPos = oSel.text.length;
                }

                // Firefox support
                else if (oField.selectionStart || oField.selectionStart == '0')
                    iCaretPos = oField.selectionStart;

                // Return results
                return (iCaretPos);
            },


            /*
            **  Sets the caret (cursor) position of the specified text field.
            **  Valid positions are 0-oField.length.
            */
            SetCaretPosition: function(oField, iCaretPos) {

                // IE Support
                if (document.selection) {

                    // Set focus on the element
                    oField.focus();

                    // Create empty selection range
                    var oSel = document.selection.createRange();

                    // Move selection start and end to 0 position
                    oSel.moveStart('character', -oField.value.length);
                    oSel.moveEnd('character', -oField.value.length);

                    // Move selection start and end to desired position
                    oSel.moveStart('character', iCaretPos);
                    //oSel.moveEnd('character', 0);
                    oSel.select();
                }

                // Firefox support
                else if (oField.selectionStart || oField.selectionStart == '0') {
                    oField.selectionStart = iCaretPos;
                    oField.selectionEnd = iCaretPos;
                    oField.focus();
                }
            }
        }, //Utils

        PageLogic: {},

        Exception: function(msg) {
            alert(msg);
        }

}//ClimaController