@risecx/carespace-chat-ui/es/components/Auth/ForgotPassword/forgot-password.js

carespace-chat-ui React component

import _regeneratorRuntime from "@babel/runtime/regenerator";

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

import React, { Component } from 'react';
import { reactLocalStorage } from 'reactjs-localstorage';
import axios from 'axios';
import Button from '../../Button';
import './forgot-password.css';

var Register = /*#__PURE__*/function (_Component) {
  _inheritsLoose(Register, _Component);

  function Register(props) {
    var _this;

    _this = _Component.call(this, props) || this;

    _defineProperty(_assertThisInitialized(_this), "onInputChange", function (e) {
      var _this$setState;

      console.log(e.target.name);

      _this.setState((_this$setState = {
        error: false,
        errorFields: []
      }, _this$setState[e.target.name] = e.target.value, _this$setState));
    });

    _this.state = {
      error: false,
      errorFields: [],
      loginId: ''
    };
    return _this;
  }
  /*  async componentWillMount() {
    const { urlAPI } = this.props.clientConfig;
    let { data } = await axios.get(`${urlAPI}/auth/register/fields`);
    this.setState({ fields: data });
  } */


  var _proto = Register.prototype;

  _proto.submitFormHandler = /*#__PURE__*/function () {
    var _submitFormHandler = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
      var _this$state, loginId, errorFields, error, urlAPI, _yield$axios$post, data;

      return _regeneratorRuntime.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              _this$state = this.state, loginId = _this$state.loginId, errorFields = _this$state.errorFields;
              error = [];
              if (loginId === '') error.push('email.blank');

              if (!(error.length > 0)) {
                _context.next = 5;
                break;
              }

              return _context.abrupt("return", this.setState({
                error: true,
                errorFields: [].concat(errorFields, error)
              }));

            case 5:
              _context.prev = 5;
              urlAPI = this.props.clientConfig.urlAPI;
              _context.next = 9;
              return axios.post(urlAPI + "/auth/recovery-password/", {
                loginId: loginId
              });

            case 9:
              _yield$axios$post = _context.sent;
              data = _yield$axios$post.data;
              this.props.onCancel();
              console.log(this.props);
              _context.next = 19;
              break;

            case 15:
              _context.prev = 15;
              _context.t0 = _context["catch"](5);
              console.log(_context.t0);
              this.setState({
                error: true,
                errorFields: ['user.email.notfound']
              });

            case 19:
            case "end":
              return _context.stop();
          }
        }
      }, _callee, this, [[5, 15]]);
    }));

    function submitFormHandler() {
      return _submitFormHandler.apply(this, arguments);
    }

    return submitFormHandler;
  }();

  _proto.render = function render() {
    var _this2 = this;

    var _this$state2 = this.state,
        error = _this$state2.error,
        errorFields = _this$state2.errorFields,
        fields = _this$state2.fields;
    return /*#__PURE__*/React.createElement("div", {
      className: "card-container-out",
      style: {
        height: '100%'
      },
      ref: function ref(el) {
        return _this2.scrollList = el;
      }
    }, /*#__PURE__*/React.createElement("div", {
      className: "sc-auth--forgot-password"
    }, /*#__PURE__*/React.createElement("div", {
      className: "container"
    }, /*#__PURE__*/React.createElement("form", {
      className: error ? 'error' : ''
    }, /*#__PURE__*/React.createElement("div", {
      className: "form-group"
    }, /*#__PURE__*/React.createElement("p", null, "Email", /*#__PURE__*/React.createElement("span", null, "*")), /*#__PURE__*/React.createElement("input", {
      type: "email",
      name: "loginId",
      id: "loginId",
      onChange: this.onInputChange
    })), error && /*#__PURE__*/React.createElement("div", {
      className: "form-group error-message"
    }, /*#__PURE__*/React.createElement("ul", null, errorFields.includes('user.email.notfound') && /*#__PURE__*/React.createElement("li", null, "The E-mail does not exists."))))), /*#__PURE__*/React.createElement("div", {
      className: "buttons"
    }, /*#__PURE__*/React.createElement(Button, {
      classs: "outline",
      title: "Submit",
      onClick: this.submitFormHandler.bind(this)
    })), /*#__PURE__*/React.createElement("a", {
      className: "btn-cancel",
      onClick: this.props.onCancel.bind(this)
    }, "Cancel")));
  };

  return Register;
}(Component);

export default Register;