itkdb-gtk 0.10.8__py3-none-any.whl → 0.10.9__py3-none-any.whl

itkdb_gtk/CreateShipments.py

@@ -9,7 +9,7 @@ import re
 
 try:
     import itkdb_gtk
-    
+
 except ImportError:
     from pathlib import Path
     cwd = Path(__file__).parent.parent
@@ -28,7 +28,7 @@ gtk_runs, gtk_args = Gtk.init_check()
 class CreateShipments(dbGtkUtils.ITkDBWindow):
     """Create a shipment from input."""
 
-    def __init__(self, session, help=None):
+    def __init__(self, session, help_link=None):
         """Initialization.
 
         Args:
@@ -41,7 +41,8 @@ class CreateShipments(dbGtkUtils.ITkDBWindow):
         self.attachment = None
         global gtk_runs
         if gtk_runs:
-            super().__init__(session=session, title="Upload AVS Data", help=help, gtk_runs=gtk_runs)
+            super().__init__(session=session, title="Upload AVS Data",
+                             help_link=help_link, gtk_runs=gtk_runs)
             self.init_window()
 
     def init_window(self):
@@ -193,28 +194,28 @@ class CreateShipments(dbGtkUtils.ITkDBWindow):
                     dbGtkUtils.complain("Item {} is already in transit".format(SN),
                                         "This item is already in transit to {}".format(rc['shipmentDestination']['code']))
                     return
-                
+
                 nick = rc['alternativeIdentifier']
-                id = rc['id']
+                obj_id = rc['id']
                 obj = rc['componentType']['name']
                 loc = rc['currentLocation']['code']
                 serialN = rc['serialNumber']
                 if serialN is None:
-                    serialN = id
+                    serialN = obj_id
 
                 # Check tha tthe input is not already there
                 model = self.tree.get_model()
-                iter = model.get_iter_first()
-                while iter:
-                    if model.get_value(iter, 0) == SN:
+                lv_iter = model.get_iter_first()
+                while lv_iter:
+                    if model.get_value(lv_iter, 0) == SN:
                         dbGtkUtils.complain("Duplicated item.",
                                             "Object {} is already in the list".format(SN))
                         return
 
-                    iter = model.iter_next(iter)
+                    lv_iter = model.iter_next(lv_iter)
 
                 # Add the item in the liststore.
-                model.append([serialN, nick, obj, loc, id])
+                model.append([serialN, nick, obj, loc, obj_id])
 
             except Exception:
                 dbGtkUtils.complain("Error querying DB",
@@ -224,12 +225,12 @@ class CreateShipments(dbGtkUtils.ITkDBWindow):
     def remove_item(self, *args):
         """Remove selected item."""
         select = self.tree.get_selection()
-        model, iter = select.get_selected()
-        if iter:
-            values = model[iter]
+        model, lv_iter = select.get_selected()
+        if lv_iter:
+            values = model[lv_iter]
             rc = dbGtkUtils.ask_for_confirmation("Remove this items ?", values[0])
             if rc:
-                model.remove(iter)
+                model.remove(lv_iter)
 
     def add_attachment_dialog(self):
         """Create the add attachment dialog."""
@@ -282,7 +283,7 @@ class CreateShipments(dbGtkUtils.ITkDBWindow):
 
             T = T if len(T) else None
             D = D if len(D) else None
-            att = ITkDButils.Attachment(path, T, D)
+            att = ITkDButils.Attachment(path=path, title=T, desc=D)
             self.attachment = att
 
         dlg.hide()
@@ -309,16 +310,16 @@ class CreateShipments(dbGtkUtils.ITkDBWindow):
     def send_items(self, *args):
         """Send items in liststore."""
         model = self.tree.get_model()
-        iter = model.get_iter_first()
+        lv_iter = model.get_iter_first()
         items = []
         senders = {}
-        while iter:
-            values = model[iter]
+        while lv_iter:
+            values = model[lv_iter]
             items.append(values[0])
             senders[values[3]] = senders.setdefault(values[3], 0) + 1
-            iter = model.iter_next(iter)
+            lv_iter = model.iter_next(lv_iter)
 
-        if len(items):
+        if len(items)>0:
             if len(senders) != 1:
                 dbGtkUtils.complain("Too many senders.",
                                     "There are objects located in differen sites:{}".format('\n'.join(senders.keys())))

itkdb_gtk/GetShipments.py

@@ -1,19 +1,17 @@
 #!/usr/bin/env python3
 """GEt shipments to a particular site (default is IFIC)."""
-import pathlib
 import sys
+from pathlib import Path
 
 try:
     import itkdb_gtk
-    
+
 except ImportError:
-    from pathlib import Path
     cwd = Path(__file__).parent.parent
     sys.path.append(cwd.as_posix())
 
 from itkdb_gtk import dbGtkUtils, ITkDBlogin, ITkDButils
 import gi
-import serial
 
 gi.require_version("Gtk", "3.0")
 from gi.repository import Gtk, Gio, GLib
@@ -22,10 +20,31 @@ from gi.repository import Gtk, Gio, GLib
 gtk_runs, gtk_args = Gtk.init_check()
 
 
+def find_vtrx(client, SN):
+    """Searches VTRx."""
+    payload = {
+        "filterMap": {
+            "project": "CE",
+            "componentType": ["VTRX"],
+            "propertyFilter": [{"code": "PACKAGE_SN", "operator": "=", "value": SN}],
+        }
+    }
+    out = client.get("listComponentsByProperty", json=payload)
+    vtrx = None
+    nitem = 0
+    for item in out:
+        vtrx = item["serialNumber"]
+        nitem += 1
+
+    if nitem > 1:
+        raise ValueError("Too many VTRx with same device SN.")
+
+    return vtrx
+
 class ReceiveShipments(dbGtkUtils.ITkDBWindow):
     """Find shipments related to given recipient."""
 
-    def __init__(self, session, recipient="IFIC", help=None):
+    def __init__(self, session, recipient="IFIC", help_link=None):
         """Initialization.
 
         Args:
@@ -38,13 +57,14 @@ class ReceiveShipments(dbGtkUtils.ITkDBWindow):
         self.institute = None
         self.model = None
         self.store = None
+        self.tree = None
         self.shipments = {}
 
         global gtk_runs
         if gtk_runs:
             super().__init__(session=session, title="Upload AVS Data",
                              show_search="Click to search shipments",
-                             gtk_runs=gtk_runs, help=help)
+                             gtk_runs=gtk_runs, help_link=help_link)
 
             self.init_window()
 
@@ -159,15 +179,22 @@ class ReceiveShipments(dbGtkUtils.ITkDBWindow):
         txt = dbGtkUtils.scanner_get_line(reader)
         self.write_message("{}\n".format(txt))
 
+        if txt.find("J-SD") == 0:
+            try:
+                txt = find_vtrx(self.session, txt)
+            except ValueError as e:
+                self.write_message("Error: {}".format(e))
+                return
+
         # search code in the list
         if self.store:
-            iter = self.store.get_iter_first()
-            while iter:
-                if (self.store.get_value(iter, 0) == txt):
+            lv_iter = self.store.get_iter_first()
+            while lv_iter:
+                if (self.store.get_value(lv_iter, 0) == txt):
                     self.write_message("...found\n")
-                    self.store[iter][3] = False
+                    self.store[lv_iter][3] = False
 
-                iter = self.store.iter_next(iter)
+                lv_iter = self.store.iter_next(lv_iter)
 
         return True
 
@@ -206,9 +233,9 @@ class ReceiveShipments(dbGtkUtils.ITkDBWindow):
 
         # Store the model associated to this shipment.
         self.store = self.shipments[shpmnt]
-        filter = self.store.filter_new()
-        filter.set_visible_column(3)
-        self.tree.set_model(filter)
+        sfilter = self.store.filter_new()
+        sfilter.set_visible_column(3)
+        self.tree.set_model(sfilter)
 
     def on_status_changed(self, combo):
         """Status changed."""
@@ -301,25 +328,25 @@ class ReceiveShipments(dbGtkUtils.ITkDBWindow):
 
         # self.store is the model of the tree view
         if self.store:
-            iter = self.store.get_iter_first()
-            while iter:
-                shpmnt = self.store.get_value(iter, 2)
+            lv_iter = self.store.get_iter_first()
+            while lv_iter:
+                shpmnt = self.store.get_value(lv_iter, 2)
                 if shpmnt not in data:
                     data[shpmnt] = create_shipment_status(shpmnt)
-                    names[shpmnt] = self.store.get_value(iter, 4)
+                    names[shpmnt] = self.store.get_value(lv_iter, 4)
 
                 item = {
-                    "code": self.store[iter][5],
-                    "delivered": not self.store[iter][3]
+                    "code": self.store[lv_iter][5],
+                    "delivered": not self.store[lv_iter][3]
                 }
                 data[shpmnt]["shipmentItems"].append(item)
 
-                iter = self.store.iter_next(iter)
+                lv_iter = self.store.iter_next(lv_iter)
 
         else:
             self.write_message("Empty list of items.\n")
 
-        for id, S in data.items():
+        for oid, S in data.items():
             # Check that all items are there
             nlost = 0
             for item in S["shipmentItems"]:
@@ -338,7 +365,7 @@ class ReceiveShipments(dbGtkUtils.ITkDBWindow):
                     return
 
             # Open dialog to fill-in questions
-            create_check_list(S["checklist"]["questionList"], names[id])
+            create_check_list(S["checklist"]["questionList"], names[oid])
 
             # send the update to the DB
             S['status'] = "delivered"
@@ -354,10 +381,10 @@ class ReceiveShipments(dbGtkUtils.ITkDBWindow):
                 self.write_message("Could not update the shipment status.\n{}\n".foramt(rc))
 
             else:
-                self.write_message("Shipment {} received\n".format(names[id]))
+                self.write_message("Shipment {} received\n".format(names[oid]))
                 # Now remove the current shipment
-                iter = self.cmb_shipment.get_active_iter()
-                self.cmb_shipment.get_model().remove(iter)
+                lv_iter = self.cmb_shipment.get_active_iter()
+                self.cmb_shipment.get_model().remove(lv_iter)
                 self.cmb_shipment.set_active(0)
 
 

itkdb_gtk/GlueWeight.py

@@ -86,7 +86,7 @@ def remove_defaul_keys(data, default_value=-9999):
 class GlueWeight(Gtk.Window):
     """Upluead Glue Weight test."""
 
-    def __init__(self, session, ifile=None, help=None):
+    def __init__(self, session, ifile=None, help_link=None):
         """Initialization.
     
         Args:
@@ -113,7 +113,7 @@ class GlueWeight(Gtk.Window):
             session, "MODULE", "GLUE_WEIGHT", defaults)
 
         if gtk_runs:
-            super().__init__(title="Upload Glue Weight")
+            super().__init__(title="Upload Glue Weight", help_link=help_link)
             self.init_window()
 
     def init_window(self):

itkdb_gtk/ITkDBlogin.py

@@ -306,7 +306,7 @@ class ITkDBlogin(Gtk.Dialog):
             #     token_file.write(json.dumps(self.token))
             self.hide()
 
-    def get_client(self, use_eos=False):
+    def get_client(self, use_eos=True):
         """Return the client."""
         if not self.is_connected():
             return None

itkdb_gtk/ITkDButils.py

@@ -10,19 +10,31 @@ import itkdb
 
 # The response of the DB
 db_response = ""
+attachment_urls = {}
+uploaded_test_runs = []
 
 
 # define an Attachment object.
 class Attachment(object):
     """Encapsulates Attachment information."""
 
-    def __init__(self, path=None, title=None, desc=None):
+    def __init__(self, path=None, url=None, title=None, desc=None):
         """Initialization."""
         if path is not None:
             self.path = Path(path).expanduser().resolve()
+            self.type = "file"
         else:
             self.path = None
 
+        if url is not None:
+            self.url = url
+            self.type = "link"
+        else:
+            self.url = None
+
+        if self.path and self.url:
+            raise ValueError("Invalid Attachment. Has both file and link.")
+
         self.title = title
         self.desc = desc
 
@@ -161,13 +173,13 @@ def create_component_attachment(client, SN, file_path, title=None, description="
     return db_response
 
 
-def set_component_property(client, SN, property, value):
+def set_component_property(client, SN, the_property, value):
     """Set the value of an object property.
 
     Args:
         client: The DB client
         SN: The object SN
-        property: The property name
+        the_property: The property name
         value: The property value
 
     """
@@ -175,7 +187,7 @@ def set_component_property(client, SN, property, value):
     try:
         db_response = client.post('setComponentProperty',
                                   json={'component': SN,
-                                        'code': property,
+                                        'code': the_property,
                                         'value': value})
         return db_response
 
@@ -247,7 +259,7 @@ def get_DB_component(client, SN):
         db_response = str(e)
         return None
 
-def upload_test(client, data, attachments=None):
+def upload_test(client, data, attachments=None, check_runNumber=False):
     """Upload a test to the DB.
 
     Args:
@@ -260,39 +272,124 @@ def upload_test(client, data, attachments=None):
 
     """
     global db_response
+    global attachment_urls
+    global uploaded_test_runs
+
+    uploaded_test_runs = []
+    attachment_urls = {}
+    db_response = None
+
+    # Check the given run_number. If already existing, give another one which
+    # will try to be consecutive.
+    if check_runNumber:
+        def get_new_value(values):
+            run_no = max([x for x in values.keys()])+1
+            return run_no
+
+        test_list = client.get("listTestRunsByComponent",
+                               json={
+                                    "filterMap":{
+                                    "serialNumber": data["component"],
+                                    "state": "ready",
+                                    "testType":[data["testType"]]
+                                    }
+                                }
+                               )
+        values = {}
+        for T in test_list:
+            try:
+                run_no = int(T["runNumber"])
+            except ValueError:
+                run_no = get_new_value(values)
+
+            values[run_no] = 1
+
+        try:
+            if int(data["runNumber"]) in values.keys():
+                data["runNumber"] = "{}".format(get_new_value(values))
+        except ValueError:
+            data["runNumber"] = "{}".format(get_new_value(values))
+
+    # Try to upload the test
     try:
         db_response = client.post("uploadTestRunResults", json=data)
         testRun = db_response["testRun"]["id"]
+        uploaded_test_runs.append(testRun)
+
+        # Handle attachments.
+        attachment_urls = {}
         if attachments is not None:
             if not isinstance(attachments, Iterable):
                 attachments = (attachments)
 
             for att in attachments:
-                path = Path(att.path).expanduser().resolve()
-                if not path.exists():
-                    print("File {} does not exist".format(path))
-                    continue
-
                 data = {"testRun": testRun,
                         "title": att.title if att.title is not None else path.name,
                         "description": att.desc if att.desc is not None else path.name,
-                        "type": "file",
+                        "type": att.type,
                         }
-                filetype = mimetypes.guess_type(path.name)
-                attachment = {'data': (path.name, open(path.as_posix(), 'rb'), filetype[0])}
+                if att.type == "file":
+                    path = Path(att.path).expanduser().resolve()
+                    if not path.exists():
+                        print("File {} does not exist".format(path))
+                        continue
+
+                    data["url"] = path.name
+                    filetype = mimetypes.guess_type(path.name)
+                    attachment = {'data': (path.name, open(path.as_posix(), 'rb'), filetype[0])}
+                else:
+                    data["url"] = att.url
+                    filetype = mimetypes.guess_type(att.url)
+                    attachment = {'data':(att.url, None, "text/x-uri") }
+
                 db_response = client.post('createTestRunAttachment',
                                           data=data,
                                           files=attachment)
-                
+                try:
+                    attachment_urls[path.name] = db_response['url']
+
+                except KeyError:
+                    pass
+
 
         return None
 
     except Exception as e:
         return (str(e))
 
+def set_test_run_parameter(session, test_run, parameter, value):
+    """Modify testRun Parameter
+
+    Args:
+        session: The ITkDB session
+        test_run: ID of test run
+        parameter: parameter code
+        value: The new value
+    """
+    global db_response
+    try:
+        db_response = session.post("setTestRunParameter", 
+                                   json={"testRun": test_run, "code": parameter, "value": value})
+        return None
+    
+    except Exception as E:
+        return (str(E))
+
+def create_test_run_comment(session, test_run, comments):
+    """Adds a new comment in testRun."""
+    global db_response
+    if not isinstance(comments, Iterable):
+        comments = (comments)
+    
+    try:
+        db_response = session.post("createTestRunComment", json={"testRun": test_run, "comments": comments})
+        return None
+    
+    except Exception as E:
+        return (str(E))
 
 def create_shipment(session, sender, recipient, items, name=None, send=False,
-                    type="domestic", attachment=None, comments=None):
+                    shipment_type="domestic", attachment=None, comments=None):
     """Create a chipment.
 
     Args:
@@ -311,7 +408,7 @@ def create_shipment(session, sender, recipient, items, name=None, send=False,
     if name is None:
         name = "From {} to {}".format(sender, recipient)
 
-    if type not in ["domestic", "intraContinental", "continental"]:
+    if shipment_type not in ["domestic", "intraContinental", "continental"]:
         db_response = "Wrong shipment type."
         return None
 
@@ -330,7 +427,7 @@ def create_shipment(session, sender, recipient, items, name=None, send=False,
         "name": name,
         "sender": sender,
         "recipient": recipient,
-        "type": type,
+        "type": shipment_type,
         "shipmentItems": items,
     }