instantjob-recruiter-client/dist/selectors/missions.es6.js

a set of tools for creating an instantjob recruiter react client

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.get_proposals = exports.get_user_deals = exports.get_mission_proposals = exports.get_default_deal = exports.get_displayed_deals = exports.get_deals = exports.get_initially_selected_recruiters = exports.get_mission_users = exports.get_user_missions_events = exports.get_user_missions = exports.get_missions = undefined;

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

var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

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

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

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

var _extends4 = _interopRequireDefault(_extends3);

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

var _keys2 = _interopRequireDefault(_keys);

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

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

exports.deal_status = deal_status;

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

var _calendar = require('selectors/calendar');

var _users = require('selectors/users');

var _recruiters = require('selectors/recruiters');

var _fields = require('selectors/fields');

var _moment = require('common/moment');

var _moment2 = _interopRequireDefault(_moment);

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

var _missions = require('common/missions');

var _workplaces = require('common/workplaces');

var _calendar2 = require('common/calendar');

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

var get_raw_deals = function get_raw_deals(state) {
  return state.missions.deals;
};
var get_raw_missions = function get_raw_missions(state) {
  return state.missions.missions;
};
var get_raw_events = function get_raw_events(state) {
  return state.missions.events;
};
var get_raw_mission_users = function get_raw_mission_users(state) {
  return state.missions.users;
};
var get_raw_workplaces = function get_raw_workplaces(state) {
  return state.missions.workplaces;
};
var get_raw_users = function get_raw_users(state) {
  return state.users.users;
};
var get_profile_id = function get_profile_id(state) {
  return state.profile.id;
};
var get_raw_agency = function get_raw_agency(state) {
  return state.profile.agency;
};
var get_raw_values = function get_raw_values(state) {
  return state.fields.values;
};
var get_raw_fields = function get_raw_fields(state) {
  return state.fields.fields;
};

var get_missions = exports.get_missions = (0, _base.tolerant_selector)([get_raw_missions, get_raw_mission_users, get_raw_events, get_raw_workplaces, _users.get_users, _fields.get_fields, _fields.get_fields_by_mission, get_raw_agency], function (missions, mission_users, events, workplaces, users, fields, fields_by_mission, _ref) {
  var workplace_shared_with_user = _ref.workplace_shared_with_user;

  var day_events_by_mission = {};
  var hour_events_by_mission = {};
  var not_full_days = {};
  var start = {};
  var end = {};
  (0, _utilities.array_from_hash)(events).forEach(function (e) {
    if (!e.deleted_at) {
      var events_by_mission = void 0;
      if (e.full_days) {
        events_by_mission = day_events_by_mission;
      } else {
        not_full_days[e.calenderable_id] = true;
        events_by_mission = hour_events_by_mission;
      }
      events_by_mission[e.calenderable_id] = [].concat((0, _toConsumableArray3.default)(events_by_mission[e.calenderable_id] || []), [e]);
      if (!start[e.calenderable_id] || (0, _moment2.default)(e.start).isBefore(start[e.calenderable_id])) {
        start[e.calenderable_id] = e.start;
      }
      if (!end[e.calenderable_id] || (0, _moment2.default)(e.end).isAfter(end[e.calenderable_id])) {
        end[e.calenderable_id] = e.end;
      }
    }
  });
  var allowed_users_statuses = (0, _utilities.set_from_array)(["active", "mail", "pending"]);
  return (0, _utilities.map_hash)(missions, function (mission) {
    var _mission = mission,
        id = _mission.id,
        users_count = _mission.users_count,
        workplace_id = _mission.workplace_id,
        recruiter_id = _mission.recruiter_id;

    var users_status = mission_users[id] || {};
    var grouped_users_status = (0, _utilities.group_hash_by_value)(users_status, ['new', 'accepted', 'rejected', 'assigned', 'impossible']);
    grouped_users_status.available = (0, _keys2.default)(users).filter(function (user_id) {
      return !users_status[user_id];
    }).filter(function (user_id) {
      return users[user_id] && allowed_users_statuses[users[user_id].status.status];
    });
    var status = mission_status((0, _extends4.default)({}, mission, { grouped_users_status: grouped_users_status }));
    var assigned_count = grouped_users_status.assigned.length;
    var accepted_count = grouped_users_status.accepted.length;
    var day_events = day_events_by_mission[id] || [];
    var hour_events = hour_events_by_mission[id] || [];
    var fields = (0, _utilities.array_from_hash)(fields_by_mission[id] || {}).map(function (field) {
      var shared_with_user = field.shared_with_user;

      if (shared_with_user) {
        return (0, _extends4.default)({}, field, (0, _utilities.create_hash)(["on_select_value", "on_deselect_value", "on_clear", "on_submit_comment"], function (action) {
          return function () {
            (0, _missions.action_notify_updated_mission)(mission.id);
            return field[action].apply(field, arguments);
          };
        }));
      }
      return field;
    });
    mission = (0, _extends4.default)({}, mission, {
      status: status,
      sent: status != 'draft',
      day_events: day_events,
      hour_events: hour_events,
      events: [].concat((0, _toConsumableArray3.default)(day_events), (0, _toConsumableArray3.default)(hour_events)),
      grouped_users_status: grouped_users_status,
      users_status: users_status,
      workplace: workplaces[workplace_id] || {},
      full_days: !not_full_days[id],
      start: start[id],
      end: end[id],
      assigned_count: assigned_count,
      accepted_count: accepted_count,
      empty_count: mission.users_count - assigned_count,
      waiting_count: grouped_users_status.new.length,
      fields: fields
    });
    return (0, _extends4.default)({}, mission, {
      update: function update(new_mission) {
        (0, _missions.action_update_mission)(mission, (0, _extends4.default)({ id: id }, new_mission));
      },
      cancel: function cancel() {
        (0, _missions.action_cancel_mission)(mission);
      },
      create_workplace: function create_workplace(workplace_name) {
        return (0, _workplaces.action_create_workplace)(workplace_name);
      },
      set_workplace: function set_workplace(workplace_id) {
        (0, _missions.action_notify_updated_mission)(mission.id);
        (0, _missions.action_update_mission)(mission, { id: id, workplace_id: workplace_id });
      },
      update_events: function update_events(events) {
        (0, _missions.action_notify_updated_mission)(mission.id);
        return (0, _missions.action_update_mission_events)(mission.id, events);
      },
      send: function send(user_ids) {
        return (0, _missions.action_send_mission)(mission, user_ids);
      },
      assign: function assign(user_ids) {
        return (0, _missions.action_assign_mission)(mission, user_ids);
      },
      unassign: function unassign(user_ids) {
        return (0, _missions.action_unassign_mission)(mission, user_ids);
      },
      toggle_publish: function toggle_publish() {
        return (0, _missions.action_toggle_publish_mission)(mission);
      },
      cancel_update_notification: function cancel_update_notification() {
        return (0, _missions.action_cancel_notify_updated_mission)(mission);
      }
    });
  });
});

function mission_status(_ref2) {
  var grouped_users_status = _ref2.grouped_users_status,
      users_count = _ref2.users_count,
      published = _ref2.published;

  if (grouped_users_status.assigned.length >= users_count) {
    return "assigned";
  } else if ((0, _utilities.for_all)(["new", "rejected", "assigned", "accepted"], function (status) {
    return grouped_users_status[status].length == 0;
  }) && !published) {
    return "draft";
  } else if (grouped_users_status.new.length + grouped_users_status.accepted.length + grouped_users_status.assigned.length < users_count && !published) {
    return "pending_selection";
  } else if (grouped_users_status.accepted.length > 0) {
    return "pending_assignement";
  } else {
    return "sent";
  }
}

var make_mission_periods = function make_mission_periods(mission) {
  return (0, _calendar2.make_periods)(mission.events).map(function (period) {
    return (0, _extends4.default)({}, period, {
      mission_start: mission.start,
      mission_end: mission.end,
      mission_status: mission.status,
      mission_workplace: mission.workplace,
      mission_id: mission.id
    });
  });
};

var get_user_missions = exports.get_user_missions = (0, _utilities.make_memoized)(function (user_id) {
  return (0, _base.tolerant_selector)([get_mission_proposals], function (missions) {
    var user_missions = (0, _utilities.filter_hash)(missions, function (mission) {
      return mission.users_status[user_id];
    });
    return (0, _utilities.array_from_hash)(user_missions).map(function (mission) {
      return (0, _extends4.default)({}, mission, {
        user_status: mission.users_status[user_id],
        periods: make_mission_periods(mission) // deprecated, do not use
      });
    }).filter(function (_ref3) {
      var user_status = _ref3.user_status;
      return (0, _utilities.set_from_array)(["new", "accepted", "rejected", "assigned"])[user_status];
    });
  });
});

var get_user_missions_events = exports.get_user_missions_events = (0, _utilities.make_memoized)(function (user_id) {
  return (0, _base.tolerant_selector)([get_user_missions(user_id)], function (missions) {
    return (0, _utilities.flatten_array)(missions.map((0, _utilities.property_getter)('events')));
  });
});

var get_mission_users = exports.get_mission_users = (0, _utilities.make_memoized)(function (mission_id, status) {
  return (0, _base.tolerant_selector)([get_missions, _users.get_users, _fields.get_mission_values_by_mission, _fields.get_values_by_field, get_raw_values, get_raw_fields], function (missions, users, mission_values_by_mission, values_by_field, values, fields) {
    var _ref4 = missions[mission_id] || {},
        grouped_users_status = _ref4.grouped_users_status;

    if (grouped_users_status) {
      var user_ids_set = (0, _utilities.set_from_array)(grouped_users_status[status]);
      if (status == "available") {
        var accepted_values = {};
        mission_values_by_mission[mission_id].forEach(function (value_id) {
          var field_id = values[value_id].field_id;
          var _fields$field_id = fields[field_id],
              for_entity = _fields$field_id.for_entity,
              category = _fields$field_id.category,
              recycled = _fields$field_id.recycled;

          if (for_entity == 'User' && recycled) {
            if (category == 'non_exclusive') {
              user_ids_set = (0, _utilities.set_intersection)(user_ids_set, values[value_id].entity_ids);
            } else if (category == 'exclusive') {
              accepted_values[field_id] = (0, _extends4.default)({}, accepted_values[field_id] || {}, (0, _defineProperty3.default)({}, value_id, true));
            }
          }
        });
        (0, _utilities.array_from_hash)(fields).forEach(function (_ref5) {
          var id = _ref5.id,
              category = _ref5.category,
              for_entity = _ref5.for_entity,
              recycled = _ref5.recycled,
              value_id_for = _ref5.value_id_for;

          if (for_entity == 'User' && recycled && category == 'exclusive') {
            var _values = accepted_values[id];
            if (_values) {
              user_ids_set = (0, _utilities.filter_set)(user_ids_set, function (user_id) {
                return _values[value_id_for[user_id]];
              });
            }
          }
        });
      }
      return (0, _utilities.filter_hash)(users, function (_ref6) {
        var id = _ref6.id,
            status = _ref6.status.status;
        return user_ids_set[id] && status != 'applied';
      });
    } else {
      return {};
    }
  });
});

var get_initially_selected_recruiters = exports.get_initially_selected_recruiters = (0, _base.tolerant_selector)([_recruiters.get_recruiters, get_profile_id], function (recruiters, profile_id) {
  if (profile_id) {
    var _ref7 = recruiters[profile_id] || {},
        team_id = _ref7.team_id,
        administrator = _ref7.administrator;

    if (administrator) {
      return [];
    } else if (team_id) {
      return (0, _utilities.array_from_hash)(recruiters).filter(function (_ref8) {
        var id = _ref8.team_id;
        return id == team_id;
      }).map((0, _utilities.property_getter)('id'));
    } else {
      return [profile_id];
    }
  } else {
    return [];
  }
});

var get_deals = (0, _base.tolerant_selector)([get_raw_deals, get_missions, get_raw_workplaces, _recruiters.get_recruiters, _fields.get_mission_fields_by_deal, _fields.get_fields_by_deal], function (deals, all_missions, workplaces, recruiters, mission_fields_by_deal, fields_by_deal) {
  var template_mission_ids = (0, _utilities.set_from_hash)((0, _utilities.map_hash)(deals, (0, _utilities.property_getter)('template_mission_id')));
  var missions_by_deal = (0, _utilities.split_array)((0, _utilities.array_from_hash)((0, _utilities.filter_hash)(all_missions, function (_ref9) {
    var id = _ref9.id,
        deleted_at = _ref9.deleted_at;
    return !deleted_at && !template_mission_ids[id];
  })), (0, _utilities.property_getter)('deal_id'), (0, _keys2.default)(deals));
  return (0, _utilities.map_hash)(deals, function (deal) {
    var _deal = deal,
        id = _deal.id,
        template_mission_id = _deal.template_mission_id,
        custom_field_ids = _deal.custom_field_ids,
        has_custom_events = _deal.has_custom_events,
        has_custom_workplace = _deal.has_custom_workplace,
        recruiter_id = _deal.recruiter_id;

    function filter_fields(_ref10) {
      var keep_custom = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
      var fields = _ref10.fields,
          mission = (0, _objectWithoutProperties3.default)(_ref10, ['fields']);

      return (0, _extends4.default)({}, mission, {
        fields: (fields || []).filter(function (_ref11) {
          var id = _ref11.id,
              category = _ref11.category;
          return Boolean(keep_custom) == Boolean(custom_field_ids[id] || category == 'computed');
        })
      });
    }
    function add_deals_fields(_ref12) {
      var fields = _ref12.fields,
          mission = (0, _objectWithoutProperties3.default)(_ref12, ['fields']);

      return (0, _extends4.default)({}, mission, {
        fields: [].concat((0, _toConsumableArray3.default)(fields), (0, _toConsumableArray3.default)((0, _utilities.array_from_hash)(fields_by_deal[id] || {})))
      });
    }
    var template_mission = add_deals_fields(filter_fields(all_missions[template_mission_id] || {}, false));
    var missions = missions_by_deal[id].map(function (mission) {
      return filter_fields(mission, true);
    }).filter(function (_ref13) {
      var deleted_at = _ref13.deleted_at;
      return !deleted_at;
    });
    var counts = {};
    new Array('users_count', 'accepted_count', 'assigned_count', 'empty_count', 'waiting_count').forEach(function (count) {
      counts[count] = (0, _utilities.array_sum)(missions.map((0, _utilities.property_getter)(count, 0)));
    });
    var start = has_custom_events ? (0, _utilities.array_minimum)(missions.map((0, _utilities.property_getter)('start')), function (a, b) {
      return (0, _moment2.default)(a).isBefore(b);
    }) : template_mission.start;
    var end = has_custom_events ? (0, _utilities.array_maximum)(missions.map((0, _utilities.property_getter)('end')), function (a, b) {
      return (0, _moment2.default)(b).isBefore(b);
    }) : template_mission.end;
    var events = has_custom_events ? (0, _utilities.flatten_array)(missions.map((0, _utilities.property_getter)('events'))) : template_mission.events;
    var workplace_ids = has_custom_workplace ? missions.map((0, _utilities.property_getter)('workplace_id')) : [template_mission.workplace_id];
    var own_workplaces = workplace_ids.map(function (workplace_id) {
      return workplaces[workplace_id] || {};
    });
    deal = (0, _extends4.default)({}, deal, counts, {
      missions: missions,
      sent: (0, _utilities.exist)(missions, (0, _utilities.property_getter)('sent')),
      template_mission: template_mission,
      status: deal_status(missions),
      workplace_ids: workplace_ids,
      workplaces: own_workplaces,
      workplace: own_workplaces[0],
      recruiter: recruiters[recruiter_id] || {},
      start: start,
      end: end,
      events: events,
      fields: mission_fields_by_deal[id],
      has_custom_fields: (0, _missions.deal_has_custom_fields)(deal)
    });
    return (0, _extends4.default)({}, deal, {
      cancel: function cancel() {
        (0, _missions.action_cancel_deal)(deal);
      },
      duplicate: function duplicate() {
        (0, _missions.action_duplicate_deal)(deal);
      },
      add_mission: function add_mission() {
        (0, _missions.action_add_mission)(deal);
      },
      customize_fields: function customize_fields() {
        (0, _missions.action_customize_deal_fields)(deal);
      },
      export_users: function export_users() {
        return (0, _missions.action_export_users)(deal);
      }
    });
  });
});

exports.get_deals = get_deals;
function deal_status(missions) {
  var statuses = (0, _utilities.split_array)(missions, (0, _utilities.property_getter)('status'), ['pending_selection', 'pending_assignement', 'assigned', 'sent', 'draft']);
  if (statuses['assigned'].length == missions.length) {
    return 'assigned';
  } else if (statuses['pending_selection'].length) {
    return 'pending_selection';
  } else if (statuses['pending_assignement'].length) {
    return 'pending_assignement';
  } else if (statuses['draft'].length) {
    return 'draft';
  } else {
    return 'sent';
  }
}

var get_displayed_deals = exports.get_displayed_deals = (0, _base.tolerant_selector)([get_deals, _recruiters.get_recruiters], function (deals, recruiters) {
  var default_deal_ids = (0, _utilities.set_from_array)((0, _utilities.array_from_hash)(recruiters).map((0, _utilities.property_getter)('default_deal_id')));
  return (0, _utilities.array_from_hash)(deals).filter(function (_ref14) {
    var id = _ref14.id,
        deleted_at = _ref14.deleted_at;
    return !deleted_at && !default_deal_ids[id];
  });
});

var get_default_deal = exports.get_default_deal = (0, _base.tolerant_selector)([get_profile_id, _recruiters.get_recruiters, get_deals], function (id, recruiters, deals) {
  var _ref15 = recruiters[id] || {},
      default_deal_id = _ref15.default_deal_id;

  return deals[default_deal_id];
});

var get_mission_proposals = exports.get_mission_proposals = (0, _base.tolerant_selector)([get_missions, get_deals, get_raw_agency, _recruiters.get_recruiters], function (missions, deals, agency, recruiters) {
  return (0, _utilities.map_hash)(missions, function (mission) {
    var deal = deals[mission.deal_id];

    var _ref16 = deal || { custom_field_ids: {} },
        has_custom_events = _ref16.has_custom_events,
        has_custom_workplace = _ref16.has_custom_workplace,
        template_mission_id = _ref16.template_mission_id,
        custom_field_ids = _ref16.custom_field_ids,
        recruiter_id = _ref16.recruiter_id;

    var template_mission = missions[template_mission_id] || {};
    var status = mission.status;
    var sent = mission.sent;
    if (template_mission_id == mission.id) {
      status = deal.status;
      sent = deal.sent;
    }
    var fields = template_mission.fields,
        workplace = template_mission.workplace;
    var workplace_shared_with_user = agency.workplace_shared_with_user;

    function get_event_properties(_ref17) {
      var start = _ref17.start,
          end = _ref17.end,
          events = _ref17.events;

      return { start: start, end: end, events: events };
    }
    var real_workplace = has_custom_workplace ? mission.workplace : workplace;
    return (0, _extends4.default)({}, mission, {
      deal: deal,
      status: status,
      sent: sent,
      real_workplace: real_workplace,
      workplace: workplace_shared_with_user ? real_workplace : null,
      agency: agency,
      recruiter: recruiters[recruiter_id] || {}
    }, get_event_properties(has_custom_events ? mission : template_mission), {
      fields: (fields || []).filter((0, _utilities.property_getter)('shared_with_user')).map(function (field, index) {
        if (custom_field_ids[field.id]) {
          return mission.fields[index];
        } else {
          return field;
        }
      })
    });
  });
});

var get_user_deals = exports.get_user_deals = (0, _utilities.make_memoized)(function (user_id) {
  return (0, _base.tolerant_selector)([get_user_missions(user_id), get_deals], function (missions, deals) {
    var deal_ids = {};
    missions.forEach(function (_ref18) {
      var deal_id = _ref18.deal_id;
      return deal_ids[deal_id] = true;
    });
    return (0, _utilities.array_from_hash)(deals).filter(function (_ref19) {
      var id = _ref19.id;
      return deal_ids[id];
    });
  });
});

var get_proposals = (0, _utilities.make_memoized)(function (mission_id) {
  return (0, _base.tolerant_selector)([get_missions, _users.get_users, _fields.get_fields_by_proposal], function (missions, users, fields_by_proposal) {
    var _ref20 = missions[mission_id] || { assigned_proposals: [] },
        assigned_proposals = _ref20.assigned_proposals;

    return assigned_proposals.map(function (_ref21) {
      var user_id = _ref21.user_id,
          proposal = (0, _objectWithoutProperties3.default)(_ref21, ['user_id']);
      return (0, _extends4.default)({}, proposal, {
        mission_id: mission_id,
        user: users[user_id] || {},
        fields: (0, _utilities.array_from_hash)(fields_by_proposal[proposal.id]) || []
      });
    });
  });
});
exports.get_proposals = get_proposals;