def add_key(self, import_file):
"""Add a key to the keyring.
:param file-object import_file: File object containing the key data.
:return: True if the key is successfully added.
:rtype: bool
:Example:
>>> from pathlib import Path
>>> my_key_file = Path("pharmaship.pub").open()
>>> km = KeyManager()
>>> km.add_key(my_key_file)
True
"""
key_data = import_file.read()
r = self.gpg.import_keys(key_data)
for item in r.results:
if 'ok' not in item.keys():
log.error("Signature error: %s", item["text"])
self.status = _('Something went wrong! See detailed logs.')
return False
if r.imported == 0:
log.info("Key already added.")
self.status = _('Key already added')
else:
key = self.get_key(r.fingerprints[0])
item = {"name": key['uids'][0], "fingerprint": key['fingerprint']}
log.debug(item)
self.status = _('Key successfully added')
return True
def on_language(self, action, param):
log.info("Lang changed: %s", param)
action.set_state(param)
self.params.application.lang = param.get_string()
self.params.save()
set_langage(self.params.application.lang)
# Get window parameters
window_size = self.window.get_size()
# Position is not reliable on Wayland
window_position = self.window.get_position()
log.debug(window_position)
mode = self.window.mode
self.window.destroy()
self.window = AppWindow(application=self,
params=self.params,
actions=self)
self.window.set_size_request(800, 600)
self.set_mode(mode)
self.window.set_default_size(*window_size)
self.window.move(x=window_position[0], y=window_position[1])
self.window.show_all()
def create_main_layout(self):
box = self.builder.get_object("main-box")
# self.scrolled.add(box)
self.window.layout.pack_start(box, True, True, 0)
self.window.layout.show_all()
# Get setting
self.setting = self.params.setting
if self.setting.first_aid_kit == 0:
return
first_aid_kits = models.FirstAidKit.objects.order_by("id").prefetch_related("items").all()[:self.params.setting.first_aid_kit]
# Create the missing first aid kits
count = first_aid_kits.count()
missing = self.setting.first_aid_kit - count
if missing > 0:
log.info("Missing some first aid kit instances. Creating...")
for i in range(missing):
models.FirstAidKit.objects.create(
name="First Aid Kit {0}".format(count + i),
location_id=0
)
first_aid_kits = None
self.build_kits(first_aid_kits)
def on_dashboard(self, action, param):
log.info("Dashboard!")
self.window.mode = "dashboard"
self.window.mode_button.set_label(_("Dashboard"))
self.clear_layout()
view = views.dashboard.View(self.window)
view.create_main_layout()
def do_activate(self):
# We only allow a single window and raise any existing ones
if not self.window:
# Windows are associated with the application
# when the last one is closed the application shuts down
self.window = AppWindow(application=self,
params=self.params,
actions=self)
self.window.set_size_request(800, 600)
self.on_dashboard(None, None)
self.window.show_all()
query_count_all()
log.info("Initialization completed!")
def create_rescue_bags(total):
current = RescueBag.objects.count()
missing = total - current
if missing < 1:
# Nothing to do
log.debug("Number of RescueBag in database higher than needed")
return True
log.info("Missing some rescue bag instances. Creating...")
for i in range(missing):
location = Location.objects.create(name="Rescue Bag {0}".format(i),
parent_id=0,
is_rescue_bag=True)
RescueBag.objects.create(name="Rescue Bag {0}".format(i),
location_id=location.id)
return True
def deploy(self):
"""Propagate the import to concerned modules.
For each module listed in the configuration, the import class
``update()`` method is called.
:return: ``True`` if all updates are applied correctly, ``False``\
otherwise
:rtype: bool
"""
for module in self.modules:
import_class = load_module(module)
if not import_class:
self.status = _("Module import error. See detailed log.")
return False
data_import = import_class(tar=self.archive,
conf=self.conf,
key=self.km.key)
if not (hasattr(data_import, "update")
and callable(data_import.update)):
log.error("Module %s has no DataImport.update method.", module)
self.status = _(
"Target module has no update method. See detailed log.")
return False
step_result = data_import.update()
if not step_result:
msg = _("Import of module {0} failed. See detailed logs."
).format(module)
log.error(msg)
else:
msg = _("Import of module {0} succeeded.").format(module)
log.info(msg)
self.import_log.append({'name': module, 'value': msg})
self.status = _("Import success.")
return True
def create_main_layout(self):
box = self.builder.get_object("main-box")
# self.scrolled.add(box)
self.window.layout.pack_start(box, True, True, 0)
self.window.layout.show_all()
# Get setting
self.setting = self.params.setting
if self.setting.rescue_bag == 0:
return
rescue_bags = RescueBag.objects.all().order_by(
"name").prefetch_related("location")
# Create the missing first aid kits
count = rescue_bags.count()
missing = self.setting.rescue_bag - count
if missing > 0:
log.info("Missing some rescue bag instances. Creating...")
for i in range(missing):
location = Location.objects.create(
name="Rescue Bag {0}".format(count + i),
parent_id=0,
is_rescue_bag=True)
RescueBag.objects.create(name="Rescue Bag {0}".format(count +
i),
location_id=location.id)
rescue_bags = RescueBag.objects.all().order_by(
"name").prefetch_related("location")
data = parser(self.params)
# Create the all bags page
self.build_full_list(data)
self.build_bags(data, rescue_bags)
def list_allowance(self, args):
"""List `Allowance` objects in database."""
log.info("Allowances in database:")
log.info("[ID] NAME (VERSION)")
for item in models.Allowance.objects.all().order_by("id"):
log.info("[{0:02d}] {1} ({2})".format(item.id, item.name,
item.version))
def check_signature(self, signed_data):
"""Check signed data has a valid known signature.
:param str signed_data: GPG signed content to verify (armored).
:return: validated data if the signature is valide, False otherwise.
:rtype: bytes or False.
"""
# Verifying the signature
verified = self.gpg.verify(signed_data)
# Check first is the signature is valid
if not verified:
self.status = _("No signature found.")
return False
# Then check that it is in the keyring
self.key = None
for k in self.gpg.list_keys():
if k['keyid'] == verified.key_id:
self.key = k
break
# Also check in the subkeys
for sk in k['subkeys']:
if sk[0] == verified.key_id:
self.key = k
break
if not self.key:
self.status = _("Signature not in the keyring.")
return False
# Decrypt the file
log.info("Package signature correct and verified (%s, %s)",
verified.username, verified.key_id[-8:])
return self.gpg.decrypt(signed_data).data
def update_allowance(allowance, key):
"""Update or create an allowance instance from serialized allowance data.
:param models.Allowance allowance: Up-to-date Allowance instance.
:param str key: GPG key ID used for signing the package archive.
:return: the updated (or create) allowance instance
:rtype: models.Allowance
"""
log.debug("Allowance name: %s", allowance.name)
allowance_dict = allowance.__dict__
allowance_dict.pop('id', None)
allowance_dict.pop('_state', None)
allowance_dict['signature'] = key
# Unique: (name, )
obj, created = models.Allowance.objects.update_or_create(
name=allowance.name, defaults=allowance_dict)
if not created:
log.info("Allowance `%s` already exists, updated.", allowance.name)
else:
log.info("Allowance `%s` create.", allowance.name)
return obj
def update(self):
"""Launch the importation.
Import first the :class:`pharmaship.inventory.models.Allowance`.
Then, import all :class:`pharmaship.inventory.models.Molecule` and
:class:`pharmaship.inventory.models.Equipment` objects (update or
create them).
When this is done, parse each JSON file for required quantities:
* :class:`pharmaship.inventory.models.MoleculeReqQty`
* :class:`pharmaship.inventory.models.EquipmentReqQty`
* :class:`pharmaship.inventory.models.RescueBagReqQty`
* :class:`pharmaship.inventory.models.FirstAidKitReqQty`
* :class:`pharmaship.inventory.models.LaboratoryReqQty`
* :class:`pharmaship.inventory.models.TelemedicalReqQty`
:class:`pharmaship.inventory.models.Molecule` and
:class:`pharmaship.inventory.models.Equipment` objects without
required quantity after import are affected to the default
:class:`pharmaship.inventory.models.Allowance` (``id=0``) with a
required quantity of 0.
:return: ``True`` if import successful, ``False`` otherwise.
:rtype: bool
"""
log.info("Inventory import...")
# Detecting objects without allowance (orphan)
self.no_allowance = models.Allowance.objects.get(pk=0)
query_count_all()
allowance = self.import_allowance()
if not allowance:
return False
query_count_all()
if not self.import_molecule():
return False
query_count_all()
if not self.import_equipment():
return False
query_count_all()
# Required Quantities
required = [
{
"filename": "inventory/molecule_reqqty.json",
"model": models.MoleculeReqQty,
# "serializer": serializers.MoleculeReqQtySerializer
},
{
"filename": "inventory/equipment_reqqty.json",
"model": models.EquipmentReqQty,
# "serializer": serializers.EquipmentReqQtySerializer
},
{
"filename": "inventory/telemedical_reqqty.json",
"model": models.TelemedicalReqQty,
# "serializer": serializers.TelemedicalReqQtySerializer
},
{
"filename": "inventory/laboratory_reqqty.json",
"model": models.LaboratoryReqQty,
# "serializer": serializers.LaboratoryReqQtySerializer
},
{
"filename": "inventory/rescue_bag_reqqty.json",
"model": models.RescueBagReqQty,
# "serializer": serializers.RescueBagReqQtySerializer
},
{
"filename": "inventory/first_aid_kit_reqqty.json",
"model": models.FirstAidKitReqQty,
# "serializer": serializers.FirstAidKitReqQtySerializer
},
]
query_count_all()
for item in required:
res = required_quantity(item, self.tar, allowance)
if not res:
return False
# Listing molecules with no reqqty
molecule_orphan_after = models.Molecule.objects.filter(allowances=None)
equipment_orphan_after = models.Equipment.objects.filter(
allowances=None)
log.info("Orphan Molecules: %s", len(molecule_orphan_after))
log.info("Orphan Equipments: %s", len(equipment_orphan_after))
# Creating reqqty with special allowance (id=1)
for molecule in molecule_orphan_after:
models.MoleculeReqQty.objects.create(base=molecule,
allowance=self.no_allowance,
required_quantity=0)
for equipment in equipment_orphan_after:
models.EquipmentReqQty.objects.create(base=equipment,
allowance=self.no_allowance,
required_quantity=0)
# Copying pictures
self.tar.extractall(members=pictures_files(self.tar),
path=str(settings.PICTURES_FOLDER))
# Set allowance active as everything went well
allowance.active = True
allowance.save()
return True
def handle(self, *args, **options): # noqa: D102
try:
settings.PHARMASHIP_CONF.touch()
log.info("Copy default configuration")
default_config = settings.PHARMASHIP_DATA / "config_default.yaml"
data = default_config.read_text()
settings.PHARMASHIP_CONF.write_text(data)
except FileExistsError:
pass
log.info("Load Equipment Groups")
load_data("EquipmentGroup.yaml")
log.info("Load Molecule Groups")
load_data("MoleculeGroup.yaml")
log.info("Load default Locations")
load_data("Location.yaml")
log.info("Load default Allowance")
load_data("Allowance.yaml")
log.info("Load Pharmaship public key")
key_path = settings.PHARMASHIP_DATA / "pharmaship.pub"
log.debug(key_path)
call_command("key_management", "add", key_path)
def get(self, args):
log.info("Getting keys")
km = KeyManager()
res = km.get_key(args["fingerprint"])
log.info(res)
def delete(self, args):
log.info("Deleting keys")
km = KeyManager()
res = km.delete_key(args["fingerprint"])
log.info(res)
def add(self, args):
log.info("Adding key from file.")
km = KeyManager()
res = km.add_key(args["file"])
log.info(res)
def list(self, args):
log.info("Listing keys")
km = KeyManager()
res = km.key_list()
log.info(res)
def handle(self, *args, **options): # noqa: D102
log.info(args)
if "func" in options:
options['func'](options)