def project(self, fitID, thing):
pyfalog.debug("Projecting fit ({0}) onto: {1}", fitID, thing)
if fitID is None:
return
fit = eos.db.getFit(fitID)
if isinstance(thing, int):
thing = eos.db.getItem(thing,
eager=("attributes", "group.category"))
if isinstance(thing, es_Module):
thing = copy.deepcopy(thing)
fit.projectedModules.append(thing)
elif isinstance(thing, FitType):
if thing in fit.projectedFits:
return
fit.projectedFitDict[thing.ID] = thing
# this bit is required -- see GH issue # 83
eos.db.saveddata_session.flush()
eos.db.saveddata_session.refresh(thing)
elif thing.category.name == "Drone":
drone = None
for d in fit.projectedDrones.find(thing):
if d is None or d.amountActive == d.amount or d.amount >= 5:
drone = d
break
if drone is None:
drone = es_Drone(thing)
fit.projectedDrones.append(drone)
drone.amount += 1
elif thing.category.name == "Fighter":
fighter = es_Fighter(thing)
fit.projectedFighters.append(fighter)
elif thing.group.name in es_Module.SYSTEM_GROUPS:
module = es_Module(thing)
module.state = FittingModuleState.ONLINE
fit.projectedModules.append(module)
else:
try:
module = es_Module(thing)
except ValueError:
return False
module.state = FittingModuleState.ACTIVE
if not module.canHaveState(module.state, fit):
module.state = FittingModuleState.OFFLINE
fit.projectedModules.append(module)
eos.db.commit()
self.recalc(fit)
return True
def project(self, fitID, thing):
pyfalog.debug("Projecting fit ({0}) onto: {1}", fitID, thing)
if fitID is None:
return
fit = eos.db.getFit(fitID)
if isinstance(thing, int):
thing = eos.db.getItem(thing,
eager=("attributes", "group.category"))
if isinstance(thing, es_Module):
thing = copy.deepcopy(thing)
fit.projectedModules.append(thing)
elif isinstance(thing, FitType):
if thing in fit.projectedFits:
return
fit.__projectedFits[thing.ID] = thing
# this bit is required -- see GH issue # 83
eos.db.saveddata_session.flush()
eos.db.saveddata_session.refresh(thing)
elif thing.category.name == "Drone":
drone = None
for d in fit.projectedDrones.find(thing):
if d is None or d.amountActive == d.amount or d.amount >= 5:
drone = d
break
if drone is None:
drone = es_Drone(thing)
fit.projectedDrones.append(drone)
drone.amount += 1
elif thing.category.name == "Fighter":
fighter = es_Fighter(thing)
fit.projectedFighters.append(fighter)
elif thing.group.name in es_Module.SYSTEM_GROUPS:
module = es_Module(thing)
module.state = State.ONLINE
fit.projectedModules.append(module)
else:
try:
module = es_Module(thing)
except ValueError:
return False
module.state = State.ACTIVE
if not module.canHaveState(module.state, fit):
module.state = State.OFFLINE
fit.projectedModules.append(module)
eos.db.commit()
self.recalc(fit)
return True
def project(self, fitID, thing):
if fitID is None:
return
fit = eos.db.getFit(fitID)
if isinstance(thing, int):
thing = eos.db.getItem(thing,
eager=("attributes", "group.category"))
if isinstance(thing, FitType):
if thing in fit.projectedFits:
return
fit.__projectedFits[thing.ID] = thing
# this bit is required -- see GH issue # 83
eos.db.saveddata_session.flush()
eos.db.saveddata_session.refresh(thing)
elif thing.category.name == "Drone":
drone = None
for d in fit.projectedDrones.find(thing):
if d is None or d.amountActive == d.amount or d.amount >= 5:
drone = d
break
if drone is None:
drone = es_Drone(thing)
fit.projectedDrones.append(drone)
drone.amount += 1
elif thing.category.name == "Fighter":
fighter = es_Fighter(thing)
fit.projectedFighters.append(fighter)
elif thing.group.name == "Effect Beacon":
module = es_Module(thing)
module.state = State.ONLINE
fit.projectedModules.append(module)
else:
module = es_Module(thing)
module.state = State.ACTIVE
if not module.canHaveState(module.state, fit):
module.state = State.OFFLINE
fit.projectedModules.append(module)
eos.db.commit()
self.recalc(fit)
return True
def changeModule(self, fitID, position, newItemID):
pyfalog.debug(
"Changing position of module from position ({0}) for fit ID: {1}",
position, fitID)
fit = eos.db.getFit(fitID)
# Dummy it out in case the next bit fails
fit.modules.toDummy(position)
item = eos.db.getItem(newItemID,
eager=("attributes", "group.category"))
try:
m = es_Module(item)
except ValueError:
pyfalog.warning("Invalid item: {0}", newItemID)
return False
if m.fits(fit):
m.owner = fit
fit.modules.toModule(position, m)
if m.isValidState(State.ACTIVE):
m.state = State.ACTIVE
# As some items may affect state-limiting attributes of the ship, calculate new attributes first
self.recalc(fit)
# Then, check states of all modules and change where needed. This will recalc if needed
self.checkStates(fit, m)
fit.fill()
eos.db.commit()
return True
else:
return None
def changeModule(self, fitID, position, newItemID):
fit = getFit(fitID)
# Dummy it out in case the next bit fails
fit.modules.toDummy(position)
item = getItem(newItemID, eager=("attributes", "group.category"))
try:
m = es_Module(item)
except ValueError:
return False
if m.fits(fit):
m.owner = fit
fit.modules.toModule(position, m)
if m.isValidState(State.ACTIVE):
m.state = State.ACTIVE
# As some items may affect state-limiting attributes of the ship, calculate new attributes first
self.recalc(fit)
# Then, check states of all modules and change where needed. This will recalc if needed
self.checkStates(fit, m)
fit.fill()
eds_queries.commit()
return True
else:
return None
def changeModule(self, fitID, position, newItemID):
fit = eos.db.getFit(fitID)
# Dummy it out in case the next bit fails
fit.modules.toDummy(position)
item = eos.db.getItem(newItemID, eager=("attributes", "group.category"))
try:
m = es_Module(item)
except ValueError:
return False
if m.fits(fit):
m.owner = fit
fit.modules.toModule(position, m)
if m.isValidState(State.ACTIVE):
m.state = State.ACTIVE
# As some items may affect state-limiting attributes of the ship, calculate new attributes first
self.recalc(fit)
# Then, check states of all modules and change where needed. This will recalc if needed
self.checkStates(fit, m)
fit.fill()
eos.db.commit()
return True
else:
return None
def appendModule(self, fitID, itemID):
fit = getFit(fitID)
item = getItem(itemID, eager=("attributes", "group.category"))
try:
m = es_Module(item)
except ValueError:
return False
if m.item.category.name == "Subsystem":
fit.modules.freeSlot(m.getModifiedItemAttr("subSystemSlot"))
if m.fits(fit):
m.owner = fit
numSlots = len(fit.modules)
fit.modules.append(m)
if m.isValidState(State.ACTIVE):
m.state = State.ACTIVE
# As some items may affect state-limiting attributes of the ship, calculate new attributes first
self.recalc(fit)
# Then, check states of all modules and change where needed. This will recalc if needed
self.checkStates(fit, m)
fit.fill()
eds_queries.commit()
return numSlots != len(fit.modules)
else:
return None
def convertMutaplasmid(self, fitID, position, mutaplasmid):
# this is mostly the same thing as the self.changeModule method, however it initializes an abyssal module with
# the old module as it's base, and then replaces it
fit = eos.db.getFit(fitID)
base = fit.modules[position]
fit.modules.toDummy(position)
try:
m = es_Module(mutaplasmid.resultingItem, base.item, mutaplasmid)
except ValueError:
pyfalog.warning("Invalid item: {0} AHHHH")
return False
if m.fits(fit):
m.owner = fit
fit.modules.toModule(position, m)
if m.isValidState(State.ACTIVE):
m.state = State.ACTIVE
# As some items may affect state-limiting attributes of the ship, calculate new attributes first
self.recalc(fit)
# Then, check states of all modules and change where needed. This will recalc if needed
self.checkStates(fit, m)
fit.fill()
eos.db.commit()
return True
else:
return None
def convertMutaplasmid(self, fitID, position, mutaplasmid):
# this is mostly the same thing as the self.changeModule method, however it initializes an abyssal module with
# the old module as it's base, and then replaces it
fit = eos.db.getFit(fitID)
base = fit.modules[position]
fit.modules.toDummy(position)
try:
m = es_Module(mutaplasmid.resultingItem, base.item, mutaplasmid)
except ValueError:
pyfalog.warning("Invalid item: {0} AHHHH")
return False
if m.fits(fit):
m.owner = fit
fit.modules.toModule(position, m)
if m.isValidState(State.ACTIVE):
m.state = State.ACTIVE
# As some items may affect state-limiting attributes of the ship, calculate new attributes first
self.recalc(fit)
# Then, check states of all modules and change where needed. This will recalc if needed
self.checkStates(fit, m)
fit.fill()
eos.db.commit()
return True
else:
return None
def appendModule(self, fitID, itemID):
pyfalog.debug("Appending module for fit ({0}) using item: {1}", fitID,
itemID)
fit = eos.db.getFit(fitID)
item = eos.db.getItem(itemID, eager=("attributes", "group.category"))
try:
m = es_Module(item)
except ValueError:
pyfalog.warning("Invalid item: {0}", itemID)
return False
if m.item.category.name == "Subsystem":
fit.modules.freeSlot(m.getModifiedItemAttr("subSystemSlot"))
if m.fits(fit):
m.owner = fit
numSlots = len(fit.modules)
fit.modules.append(m)
if m.isValidState(FittingModuleState.ACTIVE):
m.state = FittingModuleState.ACTIVE
# As some items may affect state-limiting attributes of the ship, calculate new attributes first
self.recalc(fit)
# Then, check states of all modules and change where needed. This will recalc if needed
self.checkStates(fit, m)
fit.fill()
eos.db.commit()
return numSlots != len(fit.modules), m.modPosition
else:
return None, None
def appendModule(self, fitID, itemID):
pyfalog.debug("Appending module for fit ({0}) using item: {1}", fitID, itemID)
fit = eos.db.getFit(fitID)
item = eos.db.getItem(itemID, eager=("attributes", "group.category"))
try:
m = es_Module(item)
except ValueError:
pyfalog.warning("Invalid item: {0}", itemID)
return False
if m.item.category.name == "Subsystem":
fit.modules.freeSlot(m.getModifiedItemAttr("subSystemSlot"))
if m.fits(fit):
m.owner = fit
numSlots = len(fit.modules)
fit.modules.append(m)
if m.isValidState(State.ACTIVE):
m.state = State.ACTIVE
# As some items may affect state-limiting attributes of the ship, calculate new attributes first
self.recalc(fit)
# Then, check states of all modules and change where needed. This will recalc if needed
self.checkStates(fit, m)
fit.fill()
eos.db.commit()
return numSlots != len(fit.modules)
else:
return None
def moveCargoToModule(self, fitID, moduleIdx, cargoIdx, copyMod=False):
"""
Moves cargo to fitting window. Can either do a copy, move, or swap with current module
If we try to copy/move into a spot with a non-empty module, we swap instead.
To avoid redundancy in converting Cargo item, this function does the
sanity checks as opposed to the GUI View. This is different than how the
normal .swapModules() does things, which is mostly a blind swap.
"""
pyfalog.debug("Moving cargo item to module for fit ID: {1}", fitID)
fit = eos.db.getFit(fitID)
module = fit.modules[moduleIdx]
cargo = fit.cargo[cargoIdx]
# Gather modules and convert Cargo item to Module, silently return if not a module
try:
cargoP = es_Module(cargo.item)
cargoP.owner = fit
if cargoP.isValidState(State.ACTIVE):
cargoP.state = State.ACTIVE
except:
pyfalog.warning("Invalid item: {0}", cargo.item)
return
if cargoP.slot != module.slot: # can't swap modules to different racks
return
# remove module that we are trying to move cargo to
fit.modules.remove(module)
if not cargoP.fits(fit): # if cargo doesn't fit, rollback and return
fit.modules.insert(moduleIdx, module)
return
fit.modules.insert(moduleIdx, cargoP)
if not copyMod: # remove existing cargo if not cloning
if cargo.amount == 1:
fit.cargo.remove(cargo)
else:
cargo.amount -= 1
if not module.isEmpty: # if module is placeholder, we don't want to convert/add it
for x in fit.cargo.find(module.item):
x.amount += 1
break
else:
moduleP = es_Cargo(module.item)
moduleP.amount = 1
fit.cargo.insert(cargoIdx, moduleP)
eos.db.commit()
self.recalc(fit)
def moveCargoToModule(self, fitID, moduleIdx, cargoIdx, copyMod=False):
"""
Moves cargo to fitting window. Can either do a copy, move, or swap with current module
If we try to copy/move into a spot with a non-empty module, we swap instead.
To avoid redundancy in converting Cargo item, this function does the
sanity checks as opposed to the GUI View. This is different than how the
normal .swapModules() does things, which is mostly a blind swap.
"""
fit = eos.db.getFit(fitID)
module = fit.modules[moduleIdx]
cargo = fit.cargo[cargoIdx]
# Gather modules and convert Cargo item to Module, silently return if not a module
try:
cargoP = es_Module(cargo.item)
cargoP.owner = fit
if cargoP.isValidState(State.ACTIVE):
cargoP.state = State.ACTIVE
except:
return
if cargoP.slot != module.slot: # can't swap modules to different racks
return
# remove module that we are trying to move cargo to
fit.modules.remove(module)
if not cargoP.fits(fit): # if cargo doesn't fit, rollback and return
fit.modules.insert(moduleIdx, module)
return
fit.modules.insert(moduleIdx, cargoP)
if not copyMod: # remove existing cargo if not cloning
if cargo.amount == 1:
fit.cargo.remove(cargo)
else:
cargo.amount -= 1
if not module.isEmpty: # if module is placeholder, we don't want to convert/add it
for x in fit.cargo.find(module.item):
x.amount += 1
break
else:
moduleP = es_Cargo(module.item)
moduleP.amount = 1
fit.cargo.insert(cargoIdx, moduleP)
eos.db.commit()
self.recalc(fit)
def changeModule(self, fitID, position, newItemID, recalc=True):
fit = eos.db.getFit(fitID)
# We're trying to add a charge to a slot, which won't work. Instead, try to add the charge to the module in that slot.
if self.isAmmo(newItemID):
module = fit.modules[position]
if not module.isEmpty:
self.setAmmo(fitID, newItemID, [module])
return True
pyfalog.debug(
"Changing position of module from position ({0}) for fit ID: {1}",
position, fitID)
item = eos.db.getItem(newItemID,
eager=("attributes", "group.category"))
# Dummy it out in case the next bit fails
fit.modules.toDummy(position)
try:
m = es_Module(item)
except ValueError:
pyfalog.warning("Invalid item: {0}", newItemID)
return False
if m.fits(fit):
m.owner = fit
fit.modules.toModule(position, m)
if m.isValidState(FittingModuleState.ACTIVE):
m.state = FittingModuleState.ACTIVE
if recalc:
# As some items may affect state-limiting attributes of the ship, calculate new attributes first
self.recalc(fit)
# Then, check states of all modules and change where needed. This will recalc if needed
self.checkStates(fit, m)
fit.fill()
eos.db.commit()
return m
else:
return None
def changeModule(self, fitID, position, newItemID):
fit = eos.db.getFit(fitID)
module = fit.modules[position]
# We're trying to add a charge to a slot, which won't work. Instead, try to add the charge to the module in that slot.
if self.isAmmo(newItemID) and not module.isEmpty:
self.setAmmo(fitID, newItemID, [module])
return True
pyfalog.debug("Changing position of module from position ({0}) for fit ID: {1}", position, fitID)
item = eos.db.getItem(newItemID, eager=("attributes", "group.category"))
# Dummy it out in case the next bit fails
fit.modules.toDummy(position)
ret = None
try:
m = es_Module(item)
except ValueError:
pyfalog.warning("Invalid item: {0}", newItemID)
return False
if m.slot != module.slot:
fit.modules.toModule(position, module)
# Fits, but we selected wrong slot type, so don't want to overwrite because we will append on failure (none)
ret = None
elif m.fits(fit):
m.owner = fit
fit.modules.toModule(position, m)
if m.isValidState(State.ACTIVE):
m.state = State.ACTIVE
# As some items may affect state-limiting attributes of the ship, calculate new attributes first
self.recalc(fit)
# Then, check states of all modules and change where needed. This will recalc if needed
self.checkStates(fit, m)
fit.fill()
eos.db.commit()
ret = True
return ret
def changeModule(self, fitID, position, newItemID, recalc=True):
fit = eos.db.getFit(fitID)
# We're trying to add a charge to a slot, which won't work. Instead, try to add the charge to the module in that slot.
if self.isAmmo(newItemID):
module = fit.modules[position]
if not module.isEmpty:
self.setAmmo(fitID, newItemID, [module])
return True
pyfalog.debug("Changing position of module from position ({0}) for fit ID: {1}", position, fitID)
item = eos.db.getItem(newItemID, eager=("attributes", "group.category"))
# Dummy it out in case the next bit fails
fit.modules.toDummy(position)
try:
m = es_Module(item)
except ValueError:
pyfalog.warning("Invalid item: {0}", newItemID)
return False
if m.fits(fit):
m.owner = fit
fit.modules.toModule(position, m)
if m.isValidState(FittingModuleState.ACTIVE):
m.state = FittingModuleState.ACTIVE
if recalc:
# As some items may affect state-limiting attributes of the ship, calculate new attributes first
self.recalc(fit)
# Then, check states of all modules and change where needed. This will recalc if needed
self.checkStates(fit, m)
fit.fill()
eos.db.commit()
return m
else:
return None
def moveCargoToModule(self, fitID, moduleIdx, cargoIdx, copyMod=False):
"""
Moves cargo to fitting window. Can either do a copy, move, or swap with current module
If we try to copy/move into a spot with a non-empty module, we swap instead.
To avoid redundancy in converting Cargo item, this function does the
sanity checks as opposed to the GUI View. This is different than how the
normal .swapModules() does things, which is mostly a blind swap.
"""
fit = eos.db.getFit(fitID)
module = fit.modules[moduleIdx]
cargo = fit.cargo[cargoIdx]
# We're trying to move a charge from cargo to a slot - try to add charge to dst module. Don't do anything with
# the charge in the cargo (don't respect move vs copy)
if self.isAmmo(cargo.item.ID):
if not module.isEmpty:
self.setAmmo(fitID, cargo.item.ID, [module])
return
pyfalog.debug("Moving cargo item to module for fit ID: {0}", fitID)
# Gather modules and convert Cargo item to Module, silently return if not a module
try:
cargoP = es_Module(cargo.item)
cargoP.owner = fit
if cargoP.isValidState(FittingModuleState.ACTIVE):
cargoP.state = FittingModuleState.ACTIVE
except:
pyfalog.warning("Invalid item: {0}", cargo.item)
return
if cargoP.slot != module.slot: # can't swap modules to different racks
return
# remove module that we are trying to move cargo to
fit.modules.remove(module)
if not cargoP.fits(fit): # if cargo doesn't fit, rollback and return
fit.modules.insert(moduleIdx, module)
return
fit.modules.insert(moduleIdx, cargoP)
if not copyMod: # remove existing cargo if not cloning
if cargo.amount == 1:
fit.cargo.remove(cargo)
else:
cargo.amount -= 1
if not module.isEmpty: # if module is placeholder, we don't want to convert/add it
moduleItem = module.item if not module.item.isAbyssal else module.baseItem
for x in fit.cargo.find(moduleItem):
x.amount += 1
break
else:
moduleP = es_Cargo(moduleItem)
moduleP.amount = 1
fit.cargo.insert(cargoIdx, moduleP)
eos.db.commit()
self.recalc(fit)
