"use strict";

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

(function () {
  "use strict";

  var baseUrlApiDashboard = PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD;

  var HomeLoginServiceCtrl = /*#__PURE__*/function () {
    /**
     * constructor Home login service constructor.
     * Set up dependencies.
     * @param {Object} $http AngularJS http service
     * @param {Object} $q    AngularJS $q service
     * @param {Object} $location    AngularJS $location service
     */
    function HomeLoginServiceCtrl($http, $q, $location) {
      _classCallCheck(this, HomeLoginServiceCtrl);

      // set services/constant dependencies
      this.$http = $http;
      this.$q = $q;
      this.$location = $location;
    }
    /**
     * authorization Given a payload allows to login
     * to the application.
     * @param  {Object} payload Paylod sent
     * @return {Object}         A promise is returned
     */


    _createClass(HomeLoginServiceCtrl, [{
      key: "authorization",
      value: function authorization(payload) {
        var resp = null,
            defer = this.$q.defer();

        if (!validatePayload(payload)) {
          throw "Invalid payload provided";
        }

        this.$http.post(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "authentication", payload, {
          headers: {
            "Content-Type": "application/json"
          }
        }).then(function (response) {
          defer.resolve(response);
        })["catch"](function (error) {
          defer.reject(error);
        });
        return defer.promise;
      }
      /**
       * menuParser Parse menus data
       * @param  {Object} menus Database menus
       * @return {Array}  Array with parsed results
       */

    }, {
      key: "menuParser",
      value: function menuParser(menus) {
        var result = [];
        angular.forEach(menus, function (menu0, key0) {
          var menus1 = [];
          angular.forEach(menu0.MENU_ITEMS, function (menu1, key1) {
            var menus2 = [];
            angular.forEach(menu1.PAGES, function (menu2, key2) {
              var menus3 = [],
                  href = translateHref(menu2.TYPE, menu2.HREF);
              menus2.push({
                href: href,
                icon: menu2.ICON,
                type: menu2.TYPE,
                name: menu2.NAME,
                pages: menus3
              });
            });
            var href = translateHref(menu1.TYPE, menu1.HREF);
            menus1.push({
              href: href,
              icon: menu1.ICON,
              type: menu1.TYPE,
              name: menu1.NAME,
              pages: menus2
            });
          });
          result.push({
            groupLabel: menu0.GROUP_LABEL,
            items: menus1
          });
        });
        return result;
      }
      /**
       * getNextRoute Get the visited URL
       * @return {String} Visited URL
       */

    }, {
      key: "getNextRoute",
      value: function getNextRoute() {
        return sessionHandler.sessionStorage.get("nextRoute");
      }
      /**
       * deleteNextRoute Delete from local storage the last visited route
       */

    }, {
      key: "deleteNextRoute",
      value: function deleteNextRoute() {
        sessionHandler.sessionStorage.removeItem("nextRoute");
      }
      /**
       * isLoggedIn Check if the user is logged in based on session id saved
       * in sessionStorage
       * @return {Boolean} True if is logged in false otherwise
       */

    }, {
      key: "isLoggedIn",
      value: function isLoggedIn() {
        return sessionHandler.sessionStorage.get("SESSION_ID") != null && sessionHandler.sessionStorage.get("SESSION_ID") !== "";
      }
      /**
       * setSessionDataAndRedirect Set session data and perform a redirect,
       * to dashboard or to a specified URL
       * @param {Object}  resp              JSON object with the necesary data
       * to add to session storage
       * @param {String}  redirectUrl       A URL to redirect to
       * @param {Boolean} isAccountCreation Define if the log in is due to
       * an account creation (if true redirect the user to Family Creation workflow)
       */

    }, {
      key: "setSessionDataAndRedirect",
      value: function setSessionDataAndRedirect(resp, redirectUrl, isAccountCreation) {
        // Create session and cookies
        var session = resp.data.DATA.session,
            menus = resp.data.DATA.MENUS,
            userInfo = resp.data.DATA.session.USER_INFO,
            expire = new Date(session.expires.year, session.expires.mounth - 1, session.expires.day, session.expires.hour, session.expires.minute, session.expires.second, 0),
            redirectTo;
        /*if (isAccountCreation) {
          redirectTo = PCK_GLOBAL_VARIABLES.pck_wf_process_home_view + "#/new-process";
        } else {
          redirectTo = redirectUrl || PCK_GLOBAL_VARIABLES.dashboard_home_view;
        }*/
        // Using this for testing - check if it can be like this....
        // redirectTo = PCK_GLOBAL_VARIABLES.pck_home_home_view + "#/logged-in";

        redirectTo = "dashboard";
        document.cookie = "session_id=" + session.session_id + ";expires=" + expire
        /*  + ";path=/" */
        ;
        document.cookie = "ref_year=" + session.school_year + ";expires=" + expire
        /*  + ";path=/" */
        ;
        document.cookie = "portail_session_id=" + session.session_id + ";expires=" + expire
        /*  + ";path=/" */
        ; // put sessionObject in sessionStorage

        sessionHandler.sessionStorage.set("SESSION_ID", session.session_id);
        sessionHandler.sessionStorage.set("REF_YEAR", session.school_year);
        this.$http.defaults.headers.common.session_id = sessionHandler.sessionStorage.get("SESSION_ID");
        this.$http.defaults.headers.common.ref_year = sessionHandler.sessionStorage.get("REF_YEAR"); // put show bride into sessionStorage
        // Do not show the sidenav

        sessionHandler.sessionStorage.set("showBridge", false);
        sessionHandler.sessionStorage.set("sessionObj", {
          "urlDad": session.url_dad,
          "webServicePath": session.web_service_path,
          "schoolYear": session.school_year
        }); // put menus into webStore

        sessionHandler.sessionStorage.set("menu", this.menuParser(menus)); // put user info into webstrore

        sessionHandler.sessionStorage.set("userInfo", userInfo);
        /* Temporary fix */

        var localStoragePersistObj = {
          "timestamp": Math.floor(Date.now() / 1000),
          "initialConfig": sessionHandler.sessionStorage.get("initialConfig"),
          "loginData": sessionHandler.sessionStorage.get("loginData"),
          "sessionObj": JSON.stringify({
            "urlDad": session.url_dad,
            "webServicePath": session.web_service_path,
            "schoolYear": session.school_year
          }),
          "menu": JSON.stringify(this.menuParser(menus)),
          "userInfo": JSON.stringify(userInfo)
        };
        sessionHandler.localStorage.set("sessionDataPersisted", localStoragePersistObj);
        /* Temporary fix */
        // Redirect to last visited URL if it exists or to dashboard otherwise

        var lastVisitedUrl = this.getNextRoute();
        this.deleteNextRoute();

        if (lastVisitedUrl !== null) {
          window.location = lastVisitedUrl;
        } else {
          // window.location = redirectTo;
          // Testing!!
          this.$location.search({});
          this.$location.path(redirectTo);
        }
      }
      /**
        * confirmGDU This sends to the backoffice the confirmation that the user has accepted the general conditions
        * login
        * @param  {Object} params Params needed to perform the WS call
        * (email)
        * @return {Object}        A promise is returned
        */
      // sendEmailReset: function(email, lang) {
      //   var promise = $http.post(
      //     PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "sendEmail/changePassword?email=" + email  + "&lang=" + lang,
      //     {headers: {"Content-Type": "application/json"}}
      //   ).then(function (response) {
      //     return response;
      //   }).catch(function(error) {
      //     console.error("Error email send: " + error);
      //   });
      //   return promise;
      // },

      /**
       * confirmGDU Confirm general conditions
       * @param  {String} email email of the user logged in
       * @param  {Integer} cgu  if 1 general conditions were accepted, 0 otherwise
       * @return {Object}       A promise is returned
       */

    }, {
      key: "confirmGDU",
      value: function confirmGDU(email, cgu) {
        var dataJson = {},
            defer = this.$q.defer();
        dataJson = {
          "cgu": cgu
        };
        this.$http.post(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "account/" + email, dataJson, {
          headers: {
            "Content-Type": "application/json"
          }
        }).then(function (response) {
          defer.resolve(response);
        })["catch"](function (error) {
          console.error("CGU error" + error);
          defer.reject("CGU error" + error);
        });
        return defer.promise;
      }
      /**
       * franceConnectAuth Connect to Agora Plus application using France Connect
       * login
       * @param  {Object} params Params needed to perform the WS call
       * (action, code and state)
       * @return {Object}        A promise is returned
       */

    }, {
      key: "franceConnectAuth",
      value: function franceConnectAuth(params) {
        var defer = this.$q.defer();

        if (!validateFranceConnectPayload(params)) {
          defer.reject("France Connect - Invalid parameters provided");
          return defer.promise;
        }

        this.$http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "franceConnectAuthentication", {
          "params": params
        }).then(function (response) {
          defer.resolve(response);
        })["catch"](function (error) {
          defer.reject("France Connect - An error occured");
        });
        return defer.promise;
      }
      /**
       * franceConnectCreate Create a temporary account using France connect login
       * Possible response types:
       *
       * 1/2/3 -> manage these by showing the correct message (check email validation
       * component)
       *
       * 4 - A temp account was created and the user should be redirected to dashboard
       *
       * 5 - The account already exists in the database
       *
       * @param  {Object} Params needed to perform the WS call
       * (action, code and state)
       * @return {Object}        A promise is returned
       */

    }, {
      key: "franceConnectCreate",
      value: function franceConnectCreate(params) {
        var defer = this.$q.defer();

        if (!validateFranceConnectPayload(params)) {
          defer.reject("France Connect - Invalid parameters provided");
          return defer.promise;
        }

        this.$http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "franceConnectAccountTemp", {
          "params": params
        }).then(function (response) {
          defer.resolve(response);
        })["catch"](function (error) {
          defer.reject("France Connect - An error occured");
        });
        return defer.promise;
      }
      /**
       * franceConnectAccounts Connect France Connect account
       * with the account that exists in Agora Plus
       * @param  {Object} params Params needed to perform the WS call
       * (action, code and state)
       * @return {Object}        A promise is returned
       */

    }, {
      key: "franceConnectAccounts",
      value: function franceConnectAccounts(params) {
        var defer = this.$q.defer();

        if (!validateFranceConnectPayload(params)) {
          defer.reject("France Connect - Invalid parameters provided");
          return defer.promise;
        }

        this.$http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "franceConnectAccount", {
          "params": params
        }).then(function (response) {
          defer.resolve(response);
        })["catch"](function (error) {
          defer.reject("France Connect - An error occured");
        });
        return defer.promise;
      }
      /**
       * googleConnectAuth Connect to Agora Plus application using google login
       * @param  {Object} payload Payload needed to correctly invoke the authentication
       * web service
       * @return {Object}         A promise is returned
       */

    }, {
      key: "googleConnectAuth",
      value: function googleConnectAuth(payload) {
        var defer = this.$q.defer();

        if (!validateGoogleConnectPayload(payload)) {
          defer.reject("Google connect - Invalid parameters provided");
          return defer.promise;
        }

        this.$http.post(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "googleConnectAuthentication", payload, {
          headers: {
            "Content-Type": "application/json"
          }
        }).then(function (response) {
          defer.resolve(response);
        })["catch"](function (error) {
          defer.reject(error);
        });
        return defer.promise;
      }
      /**
       * googleConnectCreate Connect google account with Agora Plus account
       * @param  {Object} payload Payload needed to correctly invoke the connect
       * account temp
       * @return {Object}         A promise is returned
       */

    }, {
      key: "googleConnectCreate",
      value: function googleConnectCreate(payload) {
        var defer = this.$q.defer();

        if (!validateGoogleConnectPayload(payload)) {
          defer.reject("Google connect - Invalid parameters provided");
          return defer.promise;
        }

        this.$http.post(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "googleConnectAccountTemp", payload, {
          headers: {
            "Content-Type": "application/json"
          }
        }).then(function (response) {
          defer.resolve(response);
        })["catch"](function (error) {
          defer.reject(error);
        });
        return defer.promise;
      }
      /**
       * googleConnectConnect Connect google account with Agora Plus account
       * @param  {Object} payload Payload needed to correctly invoke the connect
       * account temp
       * @return {Object}         A promise is returned
       */

    }, {
      key: "googleConnectConnect",
      value: function googleConnectConnect(payload) {
        var defer = this.$q.defer();

        if (!validateGoogleConnectPayload(payload)) {
          defer.reject("Google connect - Invalid parameters provided");
          return defer.promise;
        }

        this.$http.post(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "googleConnectAccount", payload, {
          headers: {
            "Content-Type": "application/json"
          }
        }).then(function (response) {
          defer.resolve(response);
        })["catch"](function (error) {
          defer.reject(error);
        });
        return defer.promise;
      }
      /**
       * ssoConnectAuth Loggin Using SSO
       * @param  {Object} payload Payload needed to correctly invoke the web service
       * @return {Object}         A promise is returned
       */

    }, {
      key: "ssoConnectAuth",
      value: function ssoConnectAuth(payload) {
        var defer = this.$q.defer();

        if (!validateSSOConnectPayload(payload)) {
          defer.reject("SSO connect - Invalid parameters provided");
          return defer.promise;
        }

        this.$http.post(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "ssoAuthentication?token=" + payload.code, {}, {
          headers: {
            "Content-Type": "application/json"
          }
        }).then(function (response) {
          defer.resolve(response);
        })["catch"](function (error) {
          defer.reject(error);
        });
        return defer.promise;
      }
      /**
       * redirectToHome Redirect the user to home page
       * @param  {String} redirectTo A string that indicates where to redirect
       * Check the valid identifiers to use
       */

    }, {
      key: "redirectToHome",
      value: function redirectToHome(redirectTo) {
        switch (redirectTo) {
          case 'home':
            this.$location.search({});
            this.$location.path("/");
            break;

          case 'client_home':
            window.location = PCK_GLOBAL_VARIABLES.pck_home_home_view;
            break;

          default:
            window.location = PCK_GLOBAL_VARIABLES.pck_home_home_view;
        }
      }
      /**
       * logout Logout the user from the application
       * @param  {String} redirectTo A string that indicates where
       * * @param  {boolean} flag to redirect or not
       * to redirect (check the redirectToHome function)
       */

    }, {
      key: "logout",
      value: function logout(redirectTo) {
        var redirect = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

        //alert("logout");
        //return false;
        // let sessionObj = JSON.parse(sessionStorage.getItem("sessionObj")),
        var _self = this;

        logOut(this).then(function (data) {})["finally"](function () {
          /**
           *
           * @type {string}
          // if (sessionObj !== null ) {
          // path=/
          document.cookie = "session_id=" + sessionStorage.SESSION_ID + ";expires=" + "Thu, 01 Jan 1970 00:00:00 UTC;";
          // sessionObj.schoolYear
          //path=/
          document.cookie = "ref_year=" + sessionStorage.REF_YEAR + ";expires=" + "Thu, 01 Jan 1970 00:00:00 UTC;";
          //path=/
          document.cookie = "portail_session_id=" + sessionStorage.SESSION_ID + ";expires=" + "Thu, 01 Jan 1970 00:00:00 UTC;";
          */
          // }
          if (redirect) {
            // Clear sessionStorage
            sessionHandler.localStorage.clear();
            sessionHandler.sessionStorage.clear();
            sessionHandler.sessionStorage.set("SESSION_ID", "");

            _self.deleteCookies(["portail_session_id", "ref_year", "session_id"]);

            _self.redirectToHome(redirectTo);
          }
        })["catch"](function (error) {
          console.error(error);
        });
      }
      /**
       * Delete a cookie
       * @param {String} cname, cookie name
       */

    }, {
      key: "deleteCookies",
      value: function deleteCookies(cname) {
        var d = new Date(); //Create an date object

        d.setTime(d.getTime() - 1000 * 60 * 60 * 24); //Set the time to the past. 1000 milliseonds = 1 second

        var expires = "expires=" + d.toGMTString(); //Compose the expirartion date

        for (var i = 0; i < cname.length; i++) {
          window.document.cookie = cname[i] + "=" + "; " + expires; //Set the cookie with name and the expiration date
        }
      }
      /**
       * getMandatoryProcesses
       * @returns {*}
       */

    }, {
      key: "getMandatoryProcesses",
      value: function getMandatoryProcesses() {
        var defer = this.$q.defer();
        this.$http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_WORKFLOW + "GetMandatoryWfByPosition").then(function (response) {
          var respType = +response.data.TYPE_RESULT;
          /* parseInt(response.data.TYPE_RESULT, 10) */

          if (respType > 0) {
            defer.resolve(response.data.DATA);
          } else {
            var message = response.data.ERROR.hasOwnProperty("MESSAGE") && response.data.ERROR.MESSAGE ? response.data.ERROR.MESSAGE : "Unable to fetch data";
            defer.reject("Error occured: " + message);
          }
        })["catch"](function (error) {
          defer.reject("An error occured: Unable to fetch tags");
        });
        return defer.promise;
      }
    }]);

    return HomeLoginServiceCtrl;
  }();
  /**** Private methods ****/

  /**
   * logOut Logout the user from the application
   * @param  {Object} self This controller instance
   * @return {Object}      A promise is returned
   */


  function logOut(self) {
    var defer = self.$q.defer(),
        responseResult = 0;
    self.$http.post(baseUrlApiDashboard + "logout", {
      SESSION_ID: sessionHandler.sessionStorage.get("SESSION_ID")
    }, {
      headers: {
        "Content-Type": "application/json"
      }
    }).then(function (response) {
      //responseResult = parseInt(response.data.TYPE_RESULT, 10);
      responseResult = +response.data.TYPE_RESULT;

      if (responseResult >= 0) {
        defer.resolve(response.data);
      } else {
        defer.reject(response.data.ERROR.MESSAGE);
      }
    })["catch"](function (error) {
      defer.reject(error);
    });
    return defer.promise;
  }
  /**
   * validatePayload Validate if the payload provided has the
   * necessary properties
   * @param  {Object} payload Payload for the login request
   * @return {Boolean}        If payload is valid return true,
   * otherwise return false
   */


  function validatePayload(payload) {
    return payload.hasOwnProperty("LOGIN") && payload.hasOwnProperty("PASSWORD");
  }
  /**
   * validateFranceConnectPayload Check if the query parameters necessary
   * for the GET requests exist.
   * @param  {Object} payload JSON object with data received from the URL
   * query string
   * @return {Boolean}         If true the parameters are valid. False otherwise.
   */


  function validateFranceConnectPayload(payload) {
    return payload.hasOwnProperty("action") && payload.action && payload.hasOwnProperty("state") && payload.state && payload.hasOwnProperty("code") && payload.code;
  }
  /**
   * validateGoogleConnectPayload Check if the payload needed for the web service
   * googleConnectAuthentication is correct.
   * @param  {Object} payload Payload to check
   * @return {Boolean}         true if the payload is ok, false otherwise.
   */


  function validateGoogleConnectPayload(payload) {
    return payload.hasOwnProperty("googleId") && payload.googleId && payload.hasOwnProperty("fullName") && payload.fullName && payload.hasOwnProperty("firstName") && payload.firstName && payload.hasOwnProperty("lastName") && payload.lastName && payload.hasOwnProperty("imageUrl") && payload.imageUrl && payload.hasOwnProperty("email") && payload.email && payload.hasOwnProperty("sessionToken") && payload.sessionToken;
  }
  /**
   * validateSSOConnectPayload Check if the payload needed for the web service
   * ssoConnectAuth is correct.
   * @param {Object} payload Payload to check
   * * @return {Boolean}         true if the payload is ok, false otherwise.
   */


  function validateSSOConnectPayload(payload) {
    return payload.hasOwnProperty("code") && payload.code;
  }
  /**
   * translateHref Translate links
   * @param  {String} type Link type
   * @param  {String} link Menu link
   * @return {String} Translated link
   */


  function translateHref(type, link) {
    var href = "";

    if (type === "link") {
      var auxHref = link.split("$#/");

      if (auxHref.length > 1) {
        // href = eval("PCK_GLOBAL_VARIABLES." + auxHref[0]) + "#/" + auxHref[1];
        href = PCK_GLOBAL_VARIABLES[auxHref[0]] + "#/" + auxHref[1];
      } else {
        href = link;
      }
    }

    return href;
  }

  angular.module("agp.homeModule.login.services").service("HomeLoginService", HomeLoginServiceCtrl);
}).call();