def validate(self):
tainted_items = {}
skills = self.__fit.skills
# Go through restricted items
for item in self.__restricted_items:
# Container for skill requirement errors for current item
skillrq_errors = []
# Check each skill requirement
for skillrq_type_id, skillrq_level in (
item._type.required_skills.items()):
# Get skill level with None as fallback value for case when we
# don't have such skill or it's not loaded
try:
skill = skills[skillrq_type_id]
except KeyError:
skill_level = None
else:
if skill._is_loaded:
skill_level = skill.level
else:
skill_level = None
# Last check - if skill level is lower than expected, current
# item is tainted; mark it so and move to the next one
if skill_level is None or skill_level < skillrq_level:
skill_requirement_error = SkillRequirementErrorData(
skill_type_id=skillrq_type_id,
level=skill_level,
required_level=skillrq_level)
skillrq_errors.append(skill_requirement_error)
if skillrq_errors:
tainted_items[item] = tuple(skillrq_errors)
if tainted_items:
raise RestrictionValidationError(tainted_items)
def validate(self):
# Get type ID and group ID of ship, if no ship available, assume they're
# None; it's safe to set them to None because our primary data container
# with restricted items can't contain None in its values anyway
try:
ship_type_id = self.__fit.ship._type_id
ship_group_id = self.__fit.ship._type.group_id
except AttributeError:
ship_type_id = None
ship_group_id = None
# Container for tainted items
tainted_items = {}
# Go through all known restricted items
for item in self.__restricted_items:
allowed_data = self.__restricted_items[item]
# If ship's type isn't in allowed types and ship's group isn't in
# allowed groups, item is tainted
if (ship_type_id not in allowed_data.type_ids
and ship_group_id not in allowed_data.group_ids):
tainted_items[item] = ShipTypeGroupErrorData(
ship_type_id=ship_type_id,
ship_group_id=ship_group_id,
allowed_type_ids=allowed_data.type_ids,
allowed_group_ids=allowed_data.group_ids)
# Raise error if there're any tainted items
if tainted_items:
raise RestrictionValidationError(tainted_items)
def validate(self):
used, total = self._slot_stats
if used > total:
tainted_items = {}
for item in self._container:
tainted_items[item] = SlotQuantityErrorData(used=used,
total=total)
raise RestrictionValidationError(tainted_items)
def validate(self):
stats = self._slot_stats
if stats.used > stats.total:
tainted_items = {}
for item in stats._users:
tainted_items[item] = SlotQuantityErrorData(used=stats.used,
total=stats.total)
raise RestrictionValidationError(tainted_items)
def validate(self):
tainted_items = {}
# User has no direct control over autoitems, so skip them
for item in self.__fit._item_iter(skip_autoitems=True):
if not item._is_loaded:
tainted_items[item] = LoadedItemErrorData()
if tainted_items:
raise RestrictionValidationError(tainted_items)
def validate(self):
tainted_items = {}
for item in self.__restricted_items:
if item.state > item._type.max_state:
allowed_states = tuple(s for s in State
if s <= item._type.max_state)
tainted_items[item] = StateErrorData(
state=item.state, allowed_states=allowed_states)
if tainted_items:
raise RestrictionValidationError(tainted_items)
def validate(self):
tainted_items = {}
for slot_index, slot_index_items in self.__index_item_map.items():
# If more than one item occupies the same slot, all items in this
# slot are tainted
if len(slot_index_items) > 1:
for item in slot_index_items:
tainted_items[item] = SlotIndexErrorData(
slot_index=slot_index)
if tainted_items:
raise RestrictionValidationError(tainted_items)
def validate(self):
tainted_items = {}
# User has no direct control over autoitems, so skip them
for item in self.__fit._loaded_item_iter(skip_autoitems=True):
# Get validator function for class of passed item. If it is not
# found or fails, seek for 'right' item class for the item type
try:
validator_func = CLASS_VALIDATORS[type(item)]
except KeyError:
tainted_items[item] = self.__get_error_data(item)
else:
if validator_func(item._type) is not True:
tainted_items[item] = self.__get_error_data(item)
if tainted_items:
raise RestrictionValidationError(tainted_items)
def validate(self):
tainted_items = {}
# Go through containers with charges, and if their sizes mismatch, taint
# charge items
for container in self.__restricted_containers:
charge = container.charge
if charge is None or not charge._is_loaded:
continue
container_size = container._type_attrs[AttrId.charge_size]
charge_size = charge._type_attrs.get(AttrId.charge_size)
if container_size != charge_size:
tainted_items[charge] = ChargeSizeErrorData(
size=charge_size, allowed_size=container_size)
if tainted_items:
raise RestrictionValidationError(tainted_items)
def validate(self):
tainted_items = {}
for container in self.__containers:
charge = container.charge
if charge is None:
continue
# Get volume and capacity with 0 as fallback, and compare them,
# raising error when charge can't fit
charge_volume = charge._type_attrs.get(AttrId.volume, 0)
container_capacity = container._type_attrs.get(AttrId.capacity, 0)
if charge_volume > container_capacity:
tainted_items[charge] = ChargeVolumeErrorData(
volume=charge_volume,
max_allowed_volume=container_capacity)
if tainted_items:
raise RestrictionValidationError(tainted_items)
def validate(self):
# Skip validation only if ship has special special attribute set value
# which is evaluated as True
ship = self.__fit.ship
if ship is not None and ship._type_attrs.get(AttrId.is_capital_size):
return
# If we got here, then we're dealing with non-capital ship, and all
# registered items are tainted
if self.__capital_items:
tainted_items = {}
for item in self.__capital_items:
item_type_volume = item._type_attrs[AttrId.volume]
tainted_items[item] = CapitalItemErrorData(
item_volume=item_type_volume,
max_subcap_volume=MAX_SUBCAP_VOLUME)
raise RestrictionValidationError(tainted_items)
def validate(self):
# Do not apply restriction when fit doesn't have ship and when ship
# doesn't have restriction attribute
try:
allowed_rig_size = self.__fit.ship._type_attrs[AttrId.rig_size]
except (AttributeError, KeyError):
return
tainted_items = {}
for item in self.__restricted_items:
rig_size = item._type_attrs[AttrId.rig_size]
# If rig size specification on item and ship differs, then item is
# tainted
if rig_size != allowed_rig_size:
tainted_items[item] = RigSizeErrorData(
size=rig_size, allowed_size=allowed_rig_size)
if tainted_items:
raise RestrictionValidationError(tainted_items)
def validate(self):
tainted_items = {}
# If item has charge and its group is not allowed, taint charge item
# (not container)
for container, allowed_group_ids in (
self.__restricted_containers.items()
):
charge = container.charge
if charge is None or not charge._is_loaded:
continue
group_id = charge._type.group_id
if group_id not in allowed_group_ids:
tainted_items[charge] = ChargeGroupErrorData(
group_id=group_id,
allowed_group_ids=allowed_group_ids)
if tainted_items:
raise RestrictionValidationError(tainted_items)
def validate(self):
# Container for tainted items
tainted_items = {}
# Go through all restricted items
for item in self.__restricted_items:
# Get quantity of registered items, assigned to group of current
# restricted item, and item's restriction value
group_id = item._type.group_id
quantity = len(self.__group_item_map.get(group_id, ()))
max_allowed_quantity = item._type_attrs[self._max_group_attr_id]
if quantity > max_allowed_quantity:
tainted_items[item] = MaxGroupErrorData(
group_id=group_id,
quantity=quantity,
max_allowed_quantity=max_allowed_quantity)
# Raise error if we detected any tainted items
if tainted_items:
raise RestrictionValidationError(tainted_items)