'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _defineProperty2 = require('babel-runtime/helpers/defineProperty');

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

var _keys = require('babel-runtime/core-js/object/keys');

var _keys2 = _interopRequireDefault(_keys);

var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

var _extends4 = require('babel-runtime/helpers/extends');

var _extends5 = _interopRequireDefault(_extends4);

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _reactRedux = require('react-redux');

var _bind = require('classnames/bind');

var _bind2 = _interopRequireDefault(_bind);

var _md = require('react-icons/lib/md');

var _menu = require('./menu');

var _menu2 = _interopRequireDefault(_menu);

var _button = require('components/utils/button');

var _button2 = _interopRequireDefault(_button);

var _user_table = require('./user_table');

var _user_table2 = _interopRequireDefault(_user_table);

var _field_categories_selector = require('./field_categories_selector');

var _field_categories_selector2 = _interopRequireDefault(_field_categories_selector);

var _utilities = require('../common/utilities');

var _request = require('../common/request');

var _request2 = _interopRequireDefault(_request);

var _store = require('../common/store');

var _store2 = _interopRequireDefault(_store);

var _constants = require('../common/constants');

var _fields = require('../common/fields');

var _users = require('../common/users');

var _display = require('../actions/display');

var _users2 = require('../actions/users');

var _fields2 = require('../actions/fields');

var _base = require('actions/base');

var _users3 = require('../selectors/users');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var cx = _bind2.default.bind(require('../styles/upload_results.scss'));

var get_uploaded_users = function get_uploaded_users(upload_users, props_users) {
  return (0, _utilities.map_hash)(upload_users, function (user) {
    return (0, _extends5.default)({}, user, {
      status: user.existing ? (0, _users.get_user_status)(props_users[user.existing]) : (0, _users.make_user_status)('new')
    });
  });
};

var UploadResultsStatic = function (_Component) {
  (0, _inherits3.default)(UploadResultsStatic, _Component);

  function UploadResultsStatic(props) {
    (0, _classCallCheck3.default)(this, UploadResultsStatic);

    var _this = (0, _possibleConstructorReturn3.default)(this, (UploadResultsStatic.__proto__ || (0, _getPrototypeOf2.default)(UploadResultsStatic)).call(this, props));

    _this.state = {
      active_field_type: 'summary',
      active_field: null,
      messages: {
        summary: [],
        invitations: [],
        instant_job_field: {},
        agency_field: {}
      },
      invitations: true,
      importing: {
        instant_job_field: {},
        agency_field: {}
      },
      imported: {
        instant_job_field: {},
        agency_field: {}
      },
      statistics: 'old'
    };
    _this.render_page = _this.render_page.bind(_this);
    _this.send_invitations = _this.send_invitations.bind(_this);
    _this.import_users = _this.import_users.bind(_this);
    _this.import_field = _this.import_field.bind(_this);
    _this.render_navigation = _this.render_navigation.bind(_this);
    return _this;
  }

  (0, _createClass3.default)(UploadResultsStatic, [{
    key: 'componentWillUnmount',
    value: function componentWillUnmount() {
      this.mounted = false;
    }
  }, {
    key: 'componentDidMount',
    value: function componentDidMount() {
      var _this2 = this;

      this.mounted = true;
      var summary = [],
          invitations = [],
          instant_job_field = {},
          agency_field = {};
      var _props$upload_results = this.props.upload_results,
          users = _props$upload_results.users,
          fields = _props$upload_results.fields,
          values = _props$upload_results.values,
          instant_job_fields_present = _props$upload_results.instant_job_fields_present,
          new_users_count = _props$upload_results.new_users_count,
          old_users_count = _props$upload_results.old_users_count,
          duplicate_users_count = _props$upload_results.duplicate_users_count,
          invalid_emails = _props$upload_results.invalid_emails;

      if (new_users_count > 0) {
        this.setState({ statistics: 'new' });
      }
      var new_field_names = (0, _keys2.default)(fields).map(function (id) {
        return fields[id];
      }).filter(function (field) {
        return !field.existing;
      }).map(function (field) {
        return field.name;
      });
      var total_fields_count = (0, _keys2.default)(fields).length + (0, _utilities.array_from_set)(instant_job_fields_present).length;
      summary.new_fields = {
        new_field_names: new_field_names,
        total_fields_count: total_fields_count,
        component: MessageFieldsCount
      };
      if (duplicate_users_count > 0) {
        summary.duplicate_users = {
          duplicate_users_count: duplicate_users_count,
          component: MessageDuplicateUsers
        };
      }
      if (invalid_emails.length > 0) {
        summary.duplicate_users = {
          invalid_emails: invalid_emails,
          component: MessageInvalidEmails
        };
      }
      if (new_users_count == 0 && old_users_count == 0) {
        summary.empty_file = {
          component: MessageEmptyFile
        };
      }
      if (new_users_count > 0) {
        invitations.new_users = {
          validated: false,
          all_users: (0, _keys2.default)(users).length,
          new_users: new_users_count,
          component: MessageInviteUsers,
          onClick: function onClick() {
            return _this2.setState((0, _utilities.deep_merge)(_this2.state, {
              messages: { invitations: { new_users: { validated: !_this2.state.messages.invitations.new_users.validated } } }
            }));
          }
        };
      }
      var absent_fields = (0, _utilities.array_from_hash)((0, _utilities.filter_hash)((0, _utilities.group_hash_by_value)(this.props.instant_job_fields), function (labels) {
        return (0, _utilities.for_all)(labels, function (label) {
          return !instant_job_fields_present[label];
        });
      })).map(function (labels) {
        return labels[0];
      });
      if (absent_fields.length > 0) {
        invitations.absent_fields = {
          validated: false,
          absent_fields: absent_fields,
          component: MessageAbsentFields,
          onClick: function onClick() {
            return _this2.setState((0, _utilities.deep_merge)(_this2.state, {
              messages: { invitations: { absent_fields: { validated: !_this2.state.messages.invitations.absent_fields.validated } } }
            }));
          }
        };
      }
      (0, _utilities.array_from_set)(instant_job_fields_present).forEach(function (field_label) {
        var field_name = _this2.props.instant_job_fields[field_label];
        if (new_users_count > 0) {
          instant_job_field[field_name] = (0, _utilities.deep_merge)(instant_job_field[field_name], { new: { valid: {
                component: MessageInstantJobFieldNew,
                informational: true
              } } });
        }
        if (old_users_count > 0) {
          var conflicting_users = (0, _utilities.array_from_hash)(users).filter(function (user) {
            if (user.existing) {
              return (user[field_name] || "") != (_this2.props.users[user.existing][field_name] || "");
            } else {
              return false;
            }
          });
          var conflicting_users_with_app_count = conflicting_users.filter(function (user) {
            return _this2.props.users[user.existing].app_name;
          }).length;
          var conflicting_users_without_app_count = conflicting_users.length - conflicting_users_with_app_count;
          if (conflicting_users.length > 0) {
            if (conflicting_users_without_app_count > 0) {
              instant_job_field[field_name] = (0, _utilities.deep_merge)(instant_job_field[field_name], { old: { conflict: {
                    component: MessageFieldConflict,
                    conflicting_users_count: conflicting_users_without_app_count,
                    selected: null,
                    exists_new_user: false,
                    on_select: function on_select(selected) {
                      return _this2.setState((0, _utilities.deep_merge)(_this2.state, {
                        messages: { instant_job_field: (0, _defineProperty3.default)({}, field_name, { old: { conflict: { selected: selected } } }) }
                      }));
                    }
                  } } });
            }
            if (conflicting_users_with_app_count > 0) {
              instant_job_field[field_name] = (0, _utilities.deep_merge)(instant_job_field[field_name], { old: { conflict_with_app: {
                    component: MessageInstantJobAppUserConflict,
                    conflicting_users_count: conflicting_users_with_app_count,
                    informational: true
                  } } });
            }
          } else {
            instant_job_field[field_name] = (0, _utilities.deep_merge)(instant_job_field[field_name], { old: { identical: {
                  component: MessageFieldIdentical,
                  informational: true
                } } });
          }
        }
      });
      (0, _utilities.array_from_hash)(fields).forEach(function (field) {
        if (field.existing) {
          var conflicting_users_count = void 0,
              new_values_old_users = void 0;
          var field_values = (0, _utilities.array_from_set)(field.values).map(function (id) {
            return values[id];
          });
          switch (field.category) {
            case 'non_exclusive':
              if (new_users_count > 0) {
                var new_values_new_users = field_values.filter(function (value) {
                  return !value.existing && value.created_by_new_users;
                }).map(function (value) {
                  return value.name;
                });
                if (new_values_new_users.length > 0) {
                  agency_field[field.id] = (0, _utilities.deep_merge)(agency_field[field.id], { new: { new_values_new_users: {
                        component: MessageNewValuesNewUsers,
                        new_field_values: new_values_new_users,
                        new_users_count: new_users_count,
                        validated: false,
                        onClick: function onClick() {
                          return _this2.setState((0, _utilities.deep_merge)(_this2.state, {
                            messages: { agency_field: (0, _defineProperty3.default)({}, field.id, { new: { new_values_new_users: { validated: !_this2.state.messages.agency_field[field.id].new.new_values_new_users.validated } } }) }
                          }));
                        }
                      } } });
                } else {
                  agency_field[field.id] = (0, _utilities.deep_merge)(agency_field[field.id], { new: { ready: {
                        component: MessageAgencyFieldReady,
                        validated: true
                      } } });
                }
              }
              conflicting_users_count = (0, _utilities.array_from_hash)(users).filter(function (user) {
                return user.existing && !(0, _utilities.for_all)(field_values, function (value) {
                  return !(!value.existing && value.entity_ids[user.id] || value.mismatching_users[user.id]);
                });
              }).length;
              new_values_old_users = field_values.filter(function (value) {
                return value.created_by_old_users;
              }).map(function (value) {
                return value.name;
              });
              break;
            case 'exclusive':
              if (new_users_count > 0) {
                var _new_values_new_users = field_values.filter(function (value) {
                  return !value.existing && value.created_by_new_users;
                }).map(function (value) {
                  return value.name;
                });
                if (_new_values_new_users.length > 0) {
                  agency_field[field.id] = (0, _utilities.deep_merge)(agency_field[field.id], { new: { new_values_new_users: {
                        component: MessageNewValuesNewUsers,
                        new_field_values: _new_values_new_users,
                        new_users_count: new_users_count,
                        validated: false,
                        onClick: function onClick() {
                          return _this2.setState((0, _utilities.deep_merge)(_this2.state, {
                            messages: { agency_field: (0, _defineProperty3.default)({}, field.id, { new: { new_values_new_users: { validated: !_this2.state.messages.agency_field[field.id].new.new_values_new_users.validated } } }) }
                          }));
                        }
                      } } });
                } else {
                  agency_field[field.id] = (0, _utilities.deep_merge)(agency_field[field.id], { new: { ready: {
                        component: MessageAgencyFieldReady,
                        validated: true
                      } } });
                }
              }
              conflicting_users_count = (0, _utilities.array_from_hash)(users).filter(function (user) {
                return user.existing && field.mismatching_user_ids[user.id];
              }).length;
              new_values_old_users = field_values.filter(function (value) {
                return value.created_by_old_users;
              }).map(function (value) {
                return value.name;
              });
              break;
            case "comment":
              if (new_users_count > 0) {
                agency_field[field.id] = (0, _utilities.deep_merge)(agency_field[field.id], { new: { ready: {
                      component: MessageAgencyFieldReady,
                      validated: true
                    } } });
              }
              conflicting_users_count = (0, _utilities.array_from_hash)(users).filter(function (user) {
                return field.conflicting_comments[user.id];
              }).length;
              new_values_old_users = [];
              break;
            default:
          }
          if (old_users_count > 0) {
            if (conflicting_users_count > 0) {
              agency_field[field.id] = (0, _utilities.deep_merge)(agency_field[field.id], { old: { conflict: {
                    component: MessageFieldConflict,
                    conflicting_users_count: conflicting_users_count,
                    new_field_values: new_values_old_users,
                    selected: null,
                    exists_new_user: new_users_count > 0,
                    on_select: function on_select(selected) {
                      return _this2.setState((0, _utilities.deep_merge)(_this2.state, {
                        messages: { agency_field: (0, _defineProperty3.default)({}, field.id, { old: { conflict: { selected: selected } } }) }
                      }));
                    }
                  } } });
            } else {
              agency_field[field.id] = (0, _utilities.deep_merge)(agency_field[field.id], { old: { identical: {
                    component: MessageFieldIdentical,
                    informational: true
                  } } });
            }
          }
        } else {
          agency_field[field.id] = (0, _utilities.deep_merge)(agency_field[field.id], { common: { new_field: {
                component: MessageNewField,
                selected: null,
                on_select: function on_select(category) {
                  _this2.props.upload_results.fields = (0, _extends5.default)({}, _this2.props.upload_results.fields, (0, _defineProperty3.default)({}, field.id, (0, _extends5.default)({}, field, {
                    category: category
                  })));
                  _this2.setState((0, _utilities.deep_merge)(_this2.state, {
                    messages: { agency_field: (0, _defineProperty3.default)({}, field.id, { common: { new_field: { selected: category } } }) }
                  }));
                }
              } } });
        }
      });
      this.setState({ messages: { summary: summary, invitations: invitations, instant_job_field: instant_job_field, agency_field: agency_field } });
    }
  }, {
    key: 'send_invitations',
    value: function send_invitations() {
      var _this3 = this;

      this.setState((0, _utilities.deep_merge)(this.state, { importing: { invitations: true } }));
      var users = (0, _utilities.array_from_hash)(this.props.upload_results.users).filter(function (user) {
        return !user.existing;
      });
      (0, _users.action_invite_users)(users).then(function () {
        return _this3.setState((0, _utilities.deep_merge)(_this3.state, { imported: { invitations: true } }));
      });
    }
  }, {
    key: 'import_users',
    value: function import_users(field_name) {
      var _this4 = this;

      var users = (0, _utilities.array_from_hash)(this.props.upload_results.users).filter(function (user) {
        return user.existing && !_this4.props.users[user.existing].app_name;
      }).filter(function (user) {
        return _this4.props.users[user.existing][field_name] != user[field_name];
      }).map(function (user) {
        return (0, _extends5.default)({}, _this4.props.users[user.existing], (0, _defineProperty3.default)({}, field_name, user[field_name]));
      });
      _store2.default.dispatch((0, _users2.update_users)(users.filter(function (user) {
        return user.user_id;
      }).map(function (user) {
        return (0, _extends5.default)({}, user, { id: user.user_id });
      })));
      return _request2.default.asynchronous('users/agency_update', { users: users.map(function (_ref) {
          var first_name = _ref.first_name,
              last_name = _ref.last_name,
              email = _ref.email,
              postal_code = _ref.postal_code,
              phone_number = _ref.phone_number;
          return { first_name: first_name, last_name: last_name, email: email, postal_code: postal_code, phone_number: phone_number };
        }) }).then(function (users) {
        return _store2.default.dispatch((0, _users2.update_users)(users));
      });
    }
  }, {
    key: 'import_field',
    value: function import_field(imported_field_id, old_users_import_mode) {
      var _this5 = this;

      var _props$upload_results2 = this.props.upload_results,
          users = _props$upload_results2.users,
          fields = _props$upload_results2.fields,
          values = _props$upload_results2.values;

      var field = fields[imported_field_id];
      var users_to_import = (0, _utilities.array_from_hash)(users);
      if (old_users_import_mode == 'ignore') {
        users_to_import = users_to_import.filter(function (user) {
          return !user.existing;
        });
      }
      var existing_users = (0, _utilities.hash_with_key)((0, _utilities.array_from_hash)(this.props.users), 'email');
      users = (0, _utilities.map_hash)(users, function (user) {
        return (0, _extends5.default)({}, user, { existing: existing_users[user.email] });
      });
      var should_import_user = (0, _utilities.set_from_array)(users_to_import.map(function (user) {
        return users[user.id].existing.id;
      }));
      var imported_users = (0, _utilities.hash_with_key)((0, _utilities.array_from_hash)(users), 'email');
      return new _promise2.default(function (resolve, reject) {
        if (field.existing) {
          resolve(field.existing);
        } else {
          (0, _fields.action_create_field)(field).then(function (id) {
            return resolve(id);
          });
        }
      }).then(function (field_id) {
        var actions = [];
        switch (field.category) {
          case "non_exclusive":
            return _promise2.default.all((0, _utilities.array_from_set)(field.values).map(function (id) {
              var imported_value = values[id];
              return new _promise2.default(function (resolve, reject) {
                if (imported_value.existing) {
                  resolve(imported_value);
                } else {
                  (0, _fields.action_create_value)(field_id, imported_value.name).then(function (id) {
                    return resolve((0, _extends5.default)({}, imported_value, { existing: id }));
                  });
                }
              });
            })).then(function (imported_values) {
              return _request2.default.asynchronous("users/update_values", { values: imported_values.map(function (imported_value) {
                  var value = _this5.props.values[imported_value.existing];
                  var result = {
                    id: value.id,
                    added: (0, _utilities.array_from_set)(imported_value.entity_ids).map(function (id) {
                      return users[id].existing.id;
                    }).filter(function (user_id) {
                      return !value.entity_ids[user_id] && should_import_user[user_id];
                    }),
                    removed: (0, _utilities.array_from_set)(value.entity_ids).filter(function (user_id) {
                      var imported_user = imported_users[_this5.props.users[user_id].email];
                      return imported_user && !imported_value.entity_ids[imported_user.id] && should_import_user[user_id];
                    })
                  };
                  actions.push((0, _fields2.add_users_value)(result.added, result.id));
                  actions.push((0, _fields2.remove_users_value)(result.removed, result.id));
                  return result;
                }) });
            }).then(function (result) {
              _store2.default.dispatch((0, _base.combined_actions)(actions));
              return result;
            });
          case "exclusive":
            return _promise2.default.all((0, _utilities.array_from_set)(field.values).map(function (id) {
              var imported_value = values[id];
              return new _promise2.default(function (resolve, reject) {
                if (imported_value.existing) {
                  resolve(imported_value);
                } else {
                  (0, _fields.action_create_value)(field_id, imported_value.name).then(function (id) {
                    return resolve((0, _extends5.default)({}, imported_value, { existing: id }));
                  });
                }
              });
            })).then(function (imported_values) {
              return _request2.default.asynchronous("users/update_values", { values: imported_values.map(function (imported_value) {
                  var value = _this5.props.values[imported_value.existing];

                  var _ref2 = _this5.props.fields[value.field_id] || {},
                      value_id_for = _ref2.value_id_for;

                  var result = {
                    id: value.id,
                    added: (0, _keys2.default)(field.value_id_for).filter(function (user_id) {
                      return field.value_id_for[user_id] == imported_value.id && value_id_for[users[user_id].existing.id] != field.value_id_for[user_id];
                    }).map(function (id) {
                      return users[id].existing.id;
                    }).filter(function (user_id) {
                      return should_import_user[user_id];
                    }),
                    removed: (0, _keys2.default)(value_id_for).filter(function (user_id) {
                      if (value_id_for[user_id] != value.id) {
                        return false;
                      }
                      var imported_user = imported_users[_this5.props.users[user_id].email];
                      return imported_user && !field.value_id_for[imported_user.id] && should_import_user[user_id];
                    })
                  };
                  result.added.forEach(function (user_id) {
                    actions.push((0, _fields2.update_exclusive_entity_value)(user_id, value.id));
                  });
                  result.removed.forEach(function (user_id) {
                    actions.push((0, _fields2.clear_exclusive_entity_value)(user_id, value.id));
                  });
                  return result;
                }) });
            }).then(function (result) {
              _store2.default.dispatch((0, _base.combined_actions)(actions));
              return result;
            });
          case "comment":
            var query = (0, _utilities.array_from_hash)(users).filter(function (user) {
              return should_import_user[user.existing.id] && (field.conflicting_comments[user.id] || !field.existing && field.comments[user.id] != "");
            }).map(function (user) {
              return { id: user.existing.id, comment: field.comments[user.id] };
            });
            _store2.default.dispatch((0, _fields2.update_user_comments)(field_id, (0, _utilities.map_hash)((0, _utilities.hash_with_key)(query), function (user) {
              return user.comment;
            })));
            return _request2.default.asynchronous("users/update_comments", { users: query, field: { id: field_id } });
          default:
        }
      });
    }
  }, {
    key: 'render_page',
    value: function render_page() {
      var _this6 = this;

      var exists_new_user = this.props.upload_results.new_users_count > 0;
      var exists_old_user = this.props.upload_results.old_users_count > 0;
      switch (this.state.active_field_type) {
        case 'summary':
        case 'invitations':
          var messages = (0, _utilities.array_from_hash)(this.state.messages[this.state.active_field_type]);
          var message_wrappers = (messages || []).map(function (_ref3, index) {
            var MessageWrapper = _ref3.component,
                props = (0, _objectWithoutProperties3.default)(_ref3, ['component']);
            return _react2.default.createElement(MessageWrapper, (0, _extends5.default)({ key: index }, props, { imported: _this6.state.imported.invitations }));
          });
          if (this.state.active_field_type == 'summary') {
            return _react2.default.createElement(
              'div',
              { className: cx('upload-results__content-container') },
              _react2.default.createElement(
                'div',
                { className: cx('upload-results__content-title') },
                'Aper\xE7u'
              ),
              message_wrappers,
              exists_old_user || exists_new_user ? _react2.default.createElement(_user_table2.default, (0, _extends5.default)({}, this.props.upload_results, { editable: false, place_filterable: false, users: get_uploaded_users(this.props.upload_results.users, this.props.users) })) : null
            );
          } else {
            return _react2.default.createElement(
              'div',
              { className: cx('upload-results__content-container') },
              _react2.default.createElement(
                'div',
                { className: cx('upload-results__content-title') },
                'Invitations'
              ),
              _react2.default.createElement(
                'div',
                { className: cx('upload-results__messages') },
                message_wrappers
              ),
              _react2.default.createElement(
                'div',
                { className: cx('upload-results__upload-button') },
                this.state.imported.invitations ? _react2.default.createElement(
                  _button2.default,
                  { done: true },
                  (0, _utilities.human_plural)(this.props.upload_results.new_users_count, 'L\'invitation a \xE9t\xE9 envoy\xE9e', 'Les invitations ont \xE9t\xE9 envoy\xE9es')
                ) : this.state.importing.invitations ? _react2.default.createElement(
                  _button2.default,
                  { loading: true },
                  'Importation en cours ...'
                ) : _react2.default.createElement(
                  _button2.default,
                  {
                    disabled: !(0, _utilities.for_all)(messages, function (message) {
                      return message.informational || message.validated || message.selected;
                    }),
                    onClick: this.send_invitations
                  },
                  (0, _utilities.human_plural)(this.props.upload_results.new_users_count, 'Envoyer l\'invitation', 'Envoyer les invitations')
                )
              )
            );
          }
        case 'instant_job_field':
        case 'agency_field':
          var imported = this.state.imported[this.state.active_field_type][this.state.active_field];
          var new_field = this.state.active_field_type == 'agency_field' && !this.props.upload_results.fields[this.state.active_field].existing;
          var common_messages = (0, _utilities.array_from_hash)((this.state.messages[this.state.active_field_type][this.state.active_field] || {}).common);
          var common_message_wrappers = common_messages.map(function (_ref4, index) {
            var MessageWrapper = _ref4.component,
                props = (0, _objectWithoutProperties3.default)(_ref4, ['component']);
            return _react2.default.createElement(MessageWrapper, (0, _extends5.default)({ key: index }, props, { imported: imported }));
          });
          var new_users_messages = (0, _utilities.array_from_hash)((this.state.messages[this.state.active_field_type][this.state.active_field] || {}).new);
          var new_users_message_wrappers = new_users_messages.map(function (_ref5, index) {
            var MessageWrapper = _ref5.component,
                props = (0, _objectWithoutProperties3.default)(_ref5, ['component']);
            return _react2.default.createElement(MessageWrapper, (0, _extends5.default)({ key: index }, props, { imported: imported }));
          });
          var old_users_messages = (0, _utilities.array_from_hash)((this.state.messages[this.state.active_field_type][this.state.active_field] || {}).old);
          var old_users_message_wrappers = old_users_messages.map(function (_ref6, index) {
            var MessageWrapper = _ref6.component,
                props = (0, _objectWithoutProperties3.default)(_ref6, ['component']);
            return _react2.default.createElement(MessageWrapper, (0, _extends5.default)({ key: index }, props, { imported: imported }));
          });
          var statistics = void 0;
          var switcher = exists_new_user && exists_old_user ? _react2.default.createElement(
            'div',
            { className: cx('upload-results__statistics-switcher') },
            ["new", "old"].map(function (option) {
              return _react2.default.createElement(
                'div',
                {
                  key: option,
                  className: cx('upload-results__statistics-switcher-option', { 'upload-results__statistics-switcher-option_selected': _this6.state.statistics == option }),
                  onClick: function onClick() {
                    return _this6.setState({ statistics: option });
                  }
                },
                { "new": "Nouveaux candidats", "old": "Anciens candidats" }[option]
              );
            })
          ) : null;
          var filter_user = function filter_user(user) {
            return _this6.state.statistics == (user.existing ? "old" : "new");
          };
          var field = void 0;
          if (this.state.active_field_type == 'instant_job_field') {
            field = { name: (0, _utilities.hash_key_with_value)(this.props.instant_job_fields, this.state.active_field) };
            var all_users = (0, _utilities.array_from_hash)(this.props.upload_results.users).filter(filter_user);
            var filled_users_count = all_users.filter(function (user) {
              return user[_this6.state.active_field];
            }).length;
            statistics = _react2.default.createElement(
              'div',
              { className: cx('upload-results__statistics') },
              switcher,
              _react2.default.createElement(
                'div',
                { className: cx('upload-results__content-title') },
                'Statistiques'
              ),
              _react2.default.createElement(
                Statistics,
                null,
                {
                  "Renseigné": filled_users_count,
                  "Vide": all_users.length - filled_users_count
                }
              )
            );
          } else {
            field = this.props.upload_results.fields[this.state.active_field];
            switch (field.category) {
              case 'exclusive':
              case 'non_exclusive':
                var field_values = (0, _utilities.array_from_set)(field.values).map(function (id) {
                  return _this6.props.upload_results.values[id];
                });
                var user_values_statistics = {};
                field_values.forEach(function (value) {
                  (0, _utilities.array_from_set)(value.entity_ids).forEach(function (user_id) {
                    if (filter_user(_this6.props.upload_results.users[user_id])) {
                      user_values_statistics[user_id] = (user_values_statistics[user_id] || 0) + 1;
                    }
                  });
                });
                statistics = _react2.default.createElement(
                  'div',
                  { className: cx('upload-results__statistics') },
                  switcher,
                  _react2.default.createElement(
                    'div',
                    { className: cx('upload-results__content-title') },
                    'Statistiques'
                  ),
                  _react2.default.createElement(
                    Statistics,
                    null,
                    field_values.reduce(function (statistics, value) {
                      statistics[value.name] = (0, _utilities.array_from_set)(value.entity_ids).map(function (id) {
                        return _this6.props.upload_results.users[id];
                      }).filter(filter_user).length;
                      return statistics;
                    }, {})
                  ),
                  field.category == 'non_exclusive' ? _react2.default.createElement(
                    'div',
                    null,
                    _react2.default.createElement(
                      'div',
                      { className: cx('upload-results__content-title') },
                      'Nombre de valeurs'
                    ),
                    _react2.default.createElement(
                      Statistics,
                      null,
                      (0, _utilities.array_from_hash)(user_values_statistics).reduce(function (statistics, value_count) {
                        statistics[value_count] = (statistics[value_count] || 0) + 1;
                        return statistics;
                      }, {})
                    )
                  ) : null
                );
                break;
              case 'comment':
                var _all_users = (0, _utilities.array_from_hash)(this.props.upload_results.users).filter(filter_user);
                var comments = this.props.upload_results.fields[this.state.active_field].comments;

                var _filled_users_count = _all_users.filter(function (_ref7) {
                  var id = _ref7.id;
                  return comments[id];
                }).length;
                statistics = _react2.default.createElement(
                  'div',
                  { className: cx('upload-results__statistics') },
                  switcher,
                  _react2.default.createElement(
                    'div',
                    { className: cx('upload-results__content-title') },
                    'Statistiques'
                  ),
                  _react2.default.createElement(
                    Statistics,
                    null,
                    {
                      "Renseigné": _filled_users_count,
                      "Vide": _all_users.length - _filled_users_count
                    }
                  )
                );
                break;
              default:
            }
          }
          return _react2.default.createElement(
            'div',
            { className: cx('upload-results__content-container') },
            _react2.default.createElement(
              'div',
              { className: cx('upload-results__content-title') },
              field.name
            ),
            _react2.default.createElement(
              'div',
              { className: cx('upload-results__main-content') },
              _react2.default.createElement(
                'div',
                { className: cx('upload-results__messages') },
                common_message_wrappers,
                exists_new_user && new_users_messages.length > 0 ? _react2.default.createElement(
                  'div',
                  { className: cx('upload-results__content-title') },
                  'Candidats nouvellement import\xE9s'
                ) : null,
                exists_new_user ? new_users_message_wrappers : null,
                exists_old_user && old_users_messages.length > 0 ? _react2.default.createElement(
                  'div',
                  { className: cx('upload-results__content-title') },
                  'Candidats d\xE9j\xE0 pr\xE9sents dans la base'
                ) : null,
                exists_old_user ? old_users_message_wrappers : null
              ),
              statistics
            ),
            _react2.default.createElement(
              'div',
              { className: cx('upload-results__upload-button') },
              (0, _utilities.for_all)([].concat((0, _toConsumableArray3.default)(new_users_messages), (0, _toConsumableArray3.default)(old_users_messages), (0, _toConsumableArray3.default)(common_messages)), function (message) {
                return message.informational;
              }) ? _react2.default.createElement(
                _button2.default,
                { done: true },
                "Vous n'avez rien à faire"
              ) : imported ? _react2.default.createElement(
                _button2.default,
                { done: true },
                new_field ? "Le champ a été créé et les données importées" : "Les données de ce champ ont été importées"
              ) : this.state.importing[this.state.active_field_type][this.state.active_field] ? _react2.default.createElement(
                _button2.default,
                { loading: true },
                'Importation en cours ...'
              ) : _react2.default.createElement(
                _button2.default,
                {
                  disabled: !(0, _utilities.for_all)([].concat((0, _toConsumableArray3.default)(new_users_messages), (0, _toConsumableArray3.default)(old_users_messages), (0, _toConsumableArray3.default)(common_messages)), function (message) {
                    return message.informational || message.validated || message.selected;
                  }),
                  onClick: function onClick() {
                    var active_field = _this6.state.active_field,
                        active_field_type = _this6.state.active_field_type;
                    _this6.setState((0, _utilities.deep_merge)(_this6.state, { importing: (0, _defineProperty3.default)({}, active_field_type, (0, _defineProperty3.default)({}, active_field, true)) }));
                    _this6.forceUpdate();
                    var set_imported_state = function set_imported_state() {
                      if (_this6.mounted) {
                        _this6.setState((0, _utilities.deep_merge)(_this6.state, { imported: (0, _defineProperty3.default)({}, active_field_type, (0, _defineProperty3.default)({}, active_field, true)) }));
                      }
                    };
                    var messages = _this6.state.messages[active_field_type][active_field];
                    switch (active_field_type) {
                      case "instant_job_field":
                        _this6.import_users(active_field).then(set_imported_state);
                        break;
                      case "agency_field":
                        _this6.import_field(active_field, new_field ? 'overwrite' : exists_old_user && messages.old.conflict ? messages.old.conflict.selected : 'ignore').then(set_imported_state);
                        break;
                      default:
                    }
                  }
                },
                new_field ? "Créer le champ" : !exists_old_user || exists_old_user && exists_new_user && (0, _utilities.for_all)(old_users_messages, function (message) {
                  return message.selected != "overwrite";
                }) ? "Importer les données pour les nouveaux candidats" : "Importer les données de ce champ"
              )
            )
          );
        default:
          return _react2.default.createElement('div', null);
      }
    }
  }, {
    key: 'render_navigation',
    value: function render_navigation(field_array) {
      var current_index = field_array.findIndex(function (field) {
        return field.active;
      });

      var decrement = function decrement() {
        field_array[current_index - 1].onClick();
      };

      var increment = function increment() {
        field_array[current_index + 1].onClick();
      };

      return _react2.default.createElement(
        'div',
        { className: cx('upload-results__actions') },
        _react2.default.createElement(
          'div',
          { className: cx('upload-results__actions__button-container', 'upload-results__actions__button-container__reverse') },
          current_index > 0 ? _react2.default.createElement(
            _button2.default,
            { secondary: true, left_icon: _react2.default.createElement(_md.MdKeyboardArrowLeft, null), onClick: decrement, disabled: current_index == 0 },
            'Pr\xE9c\xE9dent'
          ) : null
        ),
        _react2.default.createElement(
          'div',
          { className: cx('upload-results__actions__button-container') },
          current_index + 1 < field_array.length ? _react2.default.createElement(
            _button2.default,
            { secondary: true, right_icon: _react2.default.createElement(_md.MdKeyboardArrowRight, null), disabled: field_array[current_index + 1] && field_array[current_index + 1].disabled, onClick: increment },
            'Suivant'
          ) : _react2.default.createElement(
            _button2.default,
            { secondary: true, right_icon: _react2.default.createElement(_md.MdCheck, null), disabled: field_array[current_index + 1] && field_array[current_index + 1].disabled, onClick: this.props.close },
            'Terminer'
          )
        )
      );
    }
  }, {
    key: 'render',
    value: function render() {
      var _this7 = this;

      var status = {
        invitations: (0, _utilities.for_all)((0, _utilities.array_from_hash)(this.state.messages.invitations), function (message) {
          return message.informational || message.validated || message.selected;
        }) ? 'ready' : 'warning',
        instant_job_field: (0, _utilities.create_hash)((0, _utilities.array_from_hash)(this.props.instant_job_fields), function (field_name) {
          var all_messages = _this7.state.messages.instant_job_field[field_name] || {};
          var messages = [].concat((0, _toConsumableArray3.default)((0, _utilities.array_from_hash)(all_messages.common)), (0, _toConsumableArray3.default)((0, _utilities.array_from_hash)(all_messages.new)), (0, _toConsumableArray3.default)((0, _utilities.array_from_hash)(all_messages.old)));
          if ((0, _utilities.for_all)(messages, function (message) {
            return message.informational;
          })) {
            return 'imported';
          } else if ((0, _utilities.for_all)(messages, function (message) {
            return message.informational || message.validated || message.selected;
          })) {
            return 'ready';
          } else {
            return 'warning';
          }
        }),
        agency_field: (0, _utilities.create_hash)((0, _keys2.default)(this.props.upload_results.fields), function (field_id) {
          var all_messages = _this7.state.messages.agency_field[field_id] || {};
          var messages = [].concat((0, _toConsumableArray3.default)((0, _utilities.array_from_hash)(all_messages.common)), (0, _toConsumableArray3.default)((0, _utilities.array_from_hash)(all_messages.new)), (0, _toConsumableArray3.default)((0, _utilities.array_from_hash)(all_messages.old)));
          if ((0, _utilities.for_all)(messages, function (message) {
            return message.informational;
          })) {
            return 'imported';
          } else if ((0, _utilities.for_all)(messages, function (message) {
            return message.informational || message.validated || message.selected;
          })) {
            return 'ready';
          } else {
            return 'warning';
          }
        })
      };
      var exists_user = this.props.upload_results.new_users_count > 0 || this.props.upload_results.old_users_count > 0;
      var field_array = [{
        label: "Aperçu",
        onClick: function onClick() {
          return _this7.setState({ active_field_type: 'summary' });
        },
        active: this.state.active_field_type == 'summary',
        disabled: false,
        icon: _react2.default.createElement(MenuIcon, null),
        display: true
      }, {
        label: "Invitations",
        onClick: function onClick() {
          return _this7.setState({ active_field_type: 'invitations' });
        },
        active: this.state.active_field_type == 'invitations',
        disabled: false,
        icon: _react2.default.createElement(MenuIcon, { status: this.state.imported['invitations'] ? 'imported' : status['invitations'] }),
        display: this.props.upload_results.new_users_count > 0
      }].concat((0, _toConsumableArray3.default)((0, _utilities.array_from_set)(this.props.upload_results.instant_job_fields_present).map(function (field_label) {
        var field_name = _this7.props.instant_job_fields[field_label];
        return {
          label: field_label,
          onClick: function onClick() {
            return _this7.setState({ active_field_type: 'instant_job_field', active_field: field_name });
          },
          active: _this7.state.active_field_type == 'instant_job_field' && _this7.state.active_field == field_name,
          disabled: _this7.props.upload_results.new_users_count > 0 && !_this7.state.imported['invitations'],
          icon: _react2.default.createElement(MenuIcon, { status: _this7.state.imported['instant_job_field'][field_name] ? 'imported' : status['instant_job_field'][field_name] }),
          display: exists_user
        };
      })), (0, _toConsumableArray3.default)((0, _utilities.array_from_hash)(this.props.upload_results.fields).map(function (field) {
        return {
          label: field.name,
          onClick: function onClick() {
            return _this7.setState({ active_field_type: 'agency_field', active_field: field.id });
          },
          active: _this7.state.active_field_type == 'agency_field' && _this7.state.active_field == field.id,
          disabled: _this7.props.upload_results.new_users_count > 0 && !_this7.state.imported['invitations'],
          icon: _react2.default.createElement(MenuIcon, { status: _this7.state.imported['agency_field'][field.id] ? 'imported' : status['agency_field'][field.id] }),
          display: exists_user
        };
      }))).filter(function (tab) {
        return tab.display;
      });
      return _react2.default.createElement(
        'div',
        { className: cx('upload-results') },
        _react2.default.createElement(
          'div',
          { className: cx('upload-results__import-button') },
          _react2.default.createElement(
            _button2.default,
            { icon: _md.MdFileUpload, secondary: true, onClick: this.props.upload_new_file },
            'Charger un autre fichier'
          )
        ),
        _react2.default.createElement(
          'div',
          { className: cx('upload-results__container') },
          _react2.default.createElement(
            'div',
            { className: cx('upload-results__menu-container') },
            _react2.default.createElement(
              _menu2.default,
              null,
              field_array
            )
          ),
          this.render_page()
        ),
        this.render_navigation(field_array)
      );
    }
  }]);
  return UploadResultsStatic;
}(_react.Component);

var Message = function Message(props) {
  var Icon = {
    'error': _md.MdError,
    'warning': _md.MdWarning,
    'ok': _md.MdCheck
  }[props.status || 'ok'];
  return _react2.default.createElement(
    'div',
    { className: cx('upload-results__message', 'upload-results__message_' + (props.status || 'ok')) },
    _react2.default.createElement(
      'div',
      { className: cx('upload-results__message-title') },
      _react2.default.createElement(
        'div',
        { className: cx('upload-results__message-title-icon') },
        _react2.default.createElement(Icon, null)
      ),
      _react2.default.createElement(
        'div',
        { className: cx('upload-results__message-title-label') },
        props.title
      )
    ),
    props.children ? _react2.default.createElement(
      'div',
      { className: cx('upload-results__message-information') },
      props.children
    ) : null
  );
};

var MessageFieldsCount = function MessageFieldsCount(props) {
  var new_field_names_count = props.new_field_names.length;
  if (new_field_names_count > 0) {
    return _react2.default.createElement(
      Message,
      {
        status: props.new_field_names.length > 0 ? 'warning' : 'ok',
        title: (0, _utilities.human_plural)(props.total_fields_count, 'Votre fichier contient %% champ (colonne)', 'Votre fichier contient %% champs (colonnes)')
      },
      _react2.default.createElement(
        'p',
        null,
        (0, _utilities.human_plural)(props.total_fields_count - props.new_field_names.length, '%% est déjà présent', '%% sont déjà présents'),
        ' sur InstantJob'
      ),
      _react2.default.createElement(
        'p',
        null,
        (0, _utilities.human_plural)(props.new_field_names.length, '%% correspond à un nouveau champ', '%% correspondent à des nouveaux champs'),
        ' : ',
        (0, _utilities.human_join)(props.new_field_names)
      )
    );
  } else {
    return _react2.default.createElement(Message, {
      status: props.new_field_names.length > 0 ? 'warning' : 'ok',
      title: (0, _utilities.human_plural)(props.total_fields_count, '%% champ a été importé et était déjà présent sur InstantJob', '%% champs ont été importés et étaient déjà présents sur InstantJob')
    });
  }
};

var MessageInviteUsers = function MessageInviteUsers(props) {
  var title = void 0;
  if (props.new_users == props.all_users) {
    title = 'Votre fichier contient des donn\xE9es au sujet de ' + (0, _utilities.human_plural)(props.all_users, '%% nouveau candidat', '%% nouveaux candidats') + '.';
  } else {
    title = 'Votre fichier contient des donn\xE9es au sujet de ' + (0, _utilities.human_plural)(props.all_users, '%% candidat', '%% candidats') + '.';
  }
  return _react2.default.createElement(
    Message,
    {
      status: props.validated ? 'ok' : 'warning',
      title: title
    },
    props.new_users == props.all_users ? null : _react2.default.createElement(
      'p',
      null,
      (0, _utilities.human_plural)(props.all_users - props.new_users, '%% était déjà présent', '%% étaient déjà présents'),
      ' sur InstantJob'
    ),
    props.new_users == props.all_users ? null : _react2.default.createElement(
      'p',
      null,
      (0, _utilities.human_plural)(props.new_users, '%% est un nouveau candidat', '%% sont des nouveaux candidats')
    ),
    _react2.default.createElement(
      Action,
      { imported: props.imported, status: props.validated ? 'checked' : 'unchecked', onClick: props.onClick },
      'Cr\xE9er ' + (0, _utilities.human_plural)(props.new_users, '%% nouveau candidat sur InstantJob et lui', '%% nouveaux candidats sur InstantJob et leur') + ' envoyer une invitation \xE0 t\xE9l\xE9charger l\'application.'
    )
  );
};

var MessageAbsentFields = function MessageAbsentFields(props) {
  return _react2.default.createElement(
    Message,
    {
      status: props.validated ? 'ok' : 'warning',
      title: (0, _utilities.human_plural)(props.absent_fields.length, 'Le champ "' + props.absent_fields[0] + '" n\'a pas \xE9t\xE9 trouv\xE9', 'Les champs ' + (0, _utilities.human_join)(props.absent_fields.map(function (field) {
        return '"' + field + '"';
      })) + ' n\'ont pas \xE9t\xE9 trouv\xE9s') + ' dans votre fichier.'
    },
    _react2.default.createElement(
      Action,
      { imported: props.imported, status: props.validated ? 'checked' : 'unchecked', onClick: props.onClick },
      'Laisser ' + (0, _utilities.human_plural)(props.absent_fields.length, 'ce champ vide', 'ces champs vides') + ' pour les nouveaux candidats import\xE9s.'
    )
  );
};

var MessageInstantJobFieldNew = function MessageInstantJobFieldNew(props) {
  return _react2.default.createElement(Message, { title: 'Les donn\xE9es ont d\xE9j\xE0 \xE9t\xE9 import\xE9es car il s\'agit d\'un champ impos\xE9 par InstantJob.' });
};

var MessageAgencyFieldReady = function MessageAgencyFieldReady(props) {
  return _react2.default.createElement(Message, { title: 'Donn\xE9es pr\xEAtes \xE0 \xEAtre import\xE9es.' });
};

var MessageFieldIdentical = function MessageFieldIdentical(props) {
  return _react2.default.createElement(Message, { title: 'Les donn\xE9es du fichier sont identiques aux donn\xE9es dans InstantJob.' });
};

var MessageFieldConflict = function MessageFieldConflict(props) {
  var new_field_values_count = (props.new_field_values || []).length;
  return _react2.default.createElement(
    Message,
    {
      status: props.selected ? 'ok' : 'warning',
      title: 'Pour ' + (0, _utilities.human_plural)(props.conflicting_users_count, '%% candidat', '%% candidats') + ', les donn\xE9es de votre fichier ne correspondent pas aux donn\xE9es pr\xE9sentes dans votre base InstantJob.'
    },
    new_field_values_count ? _react2.default.createElement(
      'p',
      null,
      'Nous avons \xE9galement trouv\xE9 ',
      (0, _utilities.human_plural)(new_field_values_count, "%% nouvelle valeur", "%% nouvelles valeurs"),
      ' chez les candidats d\xE9j\xE0 pr\xE9sents : ',
      (0, _utilities.human_join)(props.new_field_values, 10)
    ) : null,
    props.exists_new_user ? _react2.default.createElement(
      Action,
      { imported: props.imported, status: props.selected == 'ignore' ? 'checked' : props.selected ? 'discarded' : 'unchecked', onClick: function onClick() {
          return props.on_select('ignore');
        } },
      'Ne pas prendre en compte les donn\xE9es import\xE9es et laisser la base InstantJob inchang\xE9e'
    ) : null,
    _react2.default.createElement(
      Action,
      {
        imported: props.imported,
        status: props.selected == 'overwrite' ? 'checked' : props.selected && props.exists_new_user ? 'discarded' : 'unchecked',
        onClick: props.exists_new_user || !props.selected ? function () {
          return props.on_select('overwrite');
        } : function () {
          return props.on_select(false);
        }
      },
      'Ecraser les donn\xE9es sur InstantJob et les remplacer par les donn\xE9es de votre fichier ',
      new_field_values_count > 0 ? 'en cr\xE9ant ' + (0, _utilities.human_plural)(new_field_values_count, "%% nouvelle valeur", "%% nouvelles valeurs") : null
    )
  );
};

var MessageInstantJobAppUserConflict = function MessageInstantJobAppUserConflict(props) {
  return _react2.default.createElement(Message, {
    status: 'warning',
    title: 'Les donn\xE9es de ' + (0, _utilities.human_plural)(props.conflicting_users_count, "%% candidat ne pourront pas être modifiées car il indique", "%% candidats ne pourront pas être modifiées car ils indiquent") + ' ces informations via l\'application.'
  });
};

var MessageNewField = function MessageNewField(props) {
  return _react2.default.createElement(
    Message,
    { status: props.selected ? 'ok' : 'warning', title: "Ce champ n'existe pas dans la base InstantJob" },
    _react2.default.createElement(
      'p',
      null,
      'Ce champ correspond-il a un champ de tri (\xE0 choix multiple) ou \xE0 un champ de commentaire ?'
    ),
    _react2.default.createElement(_field_categories_selector2.default, {
      selected: props.selected,
      on_select: props.imported ? function () {} : props.on_select
    })
  );
};

var MessageDuplicateUsers = function MessageDuplicateUsers(props) {
  return _react2.default.createElement(
    Message,
    {
      status: 'warning',
      title: 'Votre fichier contient ' + (0, _utilities.human_plural)(props.duplicate_users_count, "%% addresse mail", "%% adresses mail") + ' en double'
    },
    _react2.default.createElement(
      'p',
      null,
      'Nous avons conserv\xE9 uniquement la derni\xE8re ligne correspondant \xE0 chaque adresse mail dupliqu\xE9e'
    )
  );
};

var MessageInvalidEmails = function MessageInvalidEmails(props) {
  return _react2.default.createElement(
    Message,
    {
      status: 'warning',
      title: 'Votre fichier contient ' + (0, _utilities.human_plural)(props.invalid_emails.length, "%% addresse mail invalide", "%% adresses mail invalides") + ' : ' + (0, _utilities.human_join)(props.invalid_emails, 10)
    },
    _react2.default.createElement(
      'p',
      null,
      'Il faut une adresse mail valide pour envoyer une invitation, ',
      (0, _utilities.human_plural)(props.invalid_emails.length, "ce candidat ne pourra donc pas être importé", "ces candidats ne pourront donc pas être importés"),
      '.'
    )
  );
};

var MessageEmptyFile = function MessageEmptyFile(props) {
  return _react2.default.createElement(Message, {
    status: 'error',
    title: 'Votre fichier ne contient aucune adresse mail valide'
  });
};

var MessageNewValuesNewUsers = function MessageNewValuesNewUsers(props) {
  return _react2.default.createElement(
    Message,
    {
      status: props.validated ? 'ok' : 'warning',
      title: 'Nous avons trouv\xE9 ' + (0, _utilities.human_plural)(props.new_field_values.length, "%% nouvelle valeur", "%% nouvelles valeurs") + ' chez ' + (0, _utilities.human_plural)(props.new_users_count, "le nouveau candidat", "les %% nouveaux candidats") + ' : ' + (0, _utilities.human_join)(props.new_field_values, 10)
    },
    _react2.default.createElement(
      Action,
      { imported: props.imported, status: props.validated ? 'checked' : 'unchecked', onClick: props.onClick },
      'Cr\xE9er ',
      (0, _utilities.human_plural)(props.new_field_values.length, "%% nouvelle valeur", "%% nouvelles valeurs")
    )
  );
};

var Action = function Action(props) {
  var _cx;

  var Icon = props.status == 'checked' ? _md.MdCheckBox : _md.MdCheckBoxOutlineBlank;
  return _react2.default.createElement(
    'div',
    { className: cx('upload-results__message-action', (_cx = {}, (0, _defineProperty3.default)(_cx, 'upload-results__message-action_' + props.status, props.status), (0, _defineProperty3.default)(_cx, 'upload-results__message-action_editable', !props.imported), _cx)), onClick: props.imported ? function () {} : props.onClick },
    _react2.default.createElement(
      'div',
      { className: cx('upload-results__message-action-checkbox') },
      _react2.default.createElement(Icon, null)
    ),
    _react2.default.createElement(
      'div',
      { className: cx('upload-results__message-action-label') },
      props.children
    )
  );
};

var MenuIcon = function MenuIcon(props) {
  switch (props.status) {
    case 'imported':
      return _react2.default.createElement(
        'div',
        { className: cx('upload-results__menu-icon', 'upload-results__menu-icon_imported') },
        _react2.default.createElement(_md.MdCheck, null)
      );
    case 'ready':
      return _react2.default.createElement('div', { className: cx('upload-results__menu-icon', 'upload-results__menu-icon_ready') });
    case 'warning':
      return _react2.default.createElement('div', { className: cx('upload-results__menu-icon', 'upload-results__menu-icon_warning') });
    case 'error':
      return _react2.default.createElement('div', { className: cx('upload-results__menu-icon', 'upload-results__menu-icon_error') });
    default:
      return _react2.default.createElement('div', null);
  }
};

var Statistics = function Statistics(props) {
  return _react2.default.createElement(
    'div',
    { style: { display: 'flex', flexDirection: 'column', alignItems: 'stretch' } },
    (0, _keys2.default)(props.children).map(function (label, index) {
      return _react2.default.createElement(
        'div',
        { key: index, style: { display: 'flex', justifyContent: 'space-between' } },
        _react2.default.createElement(
          'div',
          null,
          label
        ),
        _react2.default.createElement(
          'div',
          null,
          props.children[label]
        )
      );
    })
  );
};

var UploadResults = (0, _reactRedux.connect)(function (state) {
  return {
    fields: state.fields.fields,
    values: state.fields.values,
    users: (0, _users3.get_users)(state)
  };
})(UploadResultsStatic);

UploadResults.defaultProps = {
  upload_results: {
    fields: [],
    values: {},
    users: []
  },
  fields: {},
  values: {},
  users: {},
  update_upload_results: function update_upload_results() {},
  upload_new_file: function upload_new_file() {},
  close: function close() {}
};

exports.default = UploadResults;