itkdb-gtk 0.10.9.dev3__py3-none-any.whl → 0.10.10.dev1__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
@@ -40,13 +38,13 @@ def find_vtrx(client, SN):
 
     if nitem > 1:
         raise ValueError("Too many VTRx with same device SN.")
-    
-    return vtrx        
+
+    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=None, help_link=None):
         """Initialization.
 
         Args:
@@ -54,20 +52,24 @@ class ReceiveShipments(dbGtkUtils.ITkDBWindow):
             recipient: default recipient
 
         """
-        self.recipient = recipient
         self.state = "inTransit"
         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",
+            super().__init__(session=session, title="Receive Shipments",
                              show_search="Click to search shipments",
-                             gtk_runs=gtk_runs, help=help)
+                             gtk_runs=gtk_runs, help_link=help_link)
 
+            self.recipient = self.pdb_user["institutions"][0]["code"]
             self.init_window()
+        else:
+            pdb_user = ITkDButils.get_db_user(session)
+            self.recipient = pdb_user["institutions"][0]["code"]
 
     def init_window(self):
         """Initialize window."""
@@ -189,31 +191,16 @@ class ReceiveShipments(dbGtkUtils.ITkDBWindow):
 
         # 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
 
-    def get_institute_list(self):
-        """Get the institute list."""
-        sites = self.session.get("listInstitutions", json={})
-        liststore = Gtk.ListStore(str, str)
-        for site in sites:
-            self.code2inst[site['code']] = site['name']
-            self.inst2code[site['name']] = site['code']
-            liststore.append([site["code"], site["code"]])
-            liststore.append([site["name"], site["code"]])
-
-        completion = Gtk.EntryCompletion()
-        completion.set_model(liststore)
-        completion.set_text_column(0)
-        return completion
-
     def on_cell_toggled(self, widget, path):
         """A cell has been toggled."""
         model = self.tree.get_model()
@@ -234,9 +221,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."""
@@ -250,30 +237,12 @@ class ReceiveShipments(dbGtkUtils.ITkDBWindow):
 
         self.state = name
 
-    def get_institute_from_combo(self, combo):
-        """Get Institute from combo."""
-        tree_iter = combo.get_active_iter()
-        if tree_iter is not None:
-            model = combo.get_model()
-            name = model[tree_iter][1]
-
-        else:
-            name = combo.get_child().get_text()
-            if name in self.inst2code:
-                name = self.inst2code[name]
-
-            elif name not in self.code2inst:
-                name = None
-
-        return name
-
     def on_receiver(self, combo):
         """Sets the recipient."""
         name = self.get_institute_from_combo(combo)
         if name:
             self.recipient = name
-            hb = self.get_titlebar()
-            hb.props.title = "{} shipments".format(self.recipient)
+            self.set_window_title("{} shipments".format(self.recipient))
 
     def on_institute(self, combo):
         """New institute chosen."""
@@ -291,8 +260,10 @@ class ReceiveShipments(dbGtkUtils.ITkDBWindow):
             return
 
         payload = {
-            "code": self.recipient,
-            "status": self.state
+            "filterMap": {
+                "code": self.recipient,
+                "status": self.state
+            }
         }
         shpmts = self.session.get("listShipmentsByInstitution", json=payload)
 
@@ -329,25 +300,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"]:
@@ -366,7 +337,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"
@@ -382,10 +353,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

@@ -239,10 +239,10 @@ class ITkDBlogin(Gtk.Dialog):
         self.ac1.set_visibility(False)
         self.ac2.set_visibility(False)
 
-        grid.attach(Gtk.Label(label="Acces Code 1"), 0, irow, 1, 1)
+        grid.attach(Gtk.Label(label="Access Code 1"), 0, irow, 1, 1)
         grid.attach(self.ac1, 1, irow, 1, 1)
         irow = irow + 1
-        grid.attach(Gtk.Label(label="Acces Code 1"), 0, irow, 1, 1)
+        grid.attach(Gtk.Label(label="Access Code 2"), 0, irow, 1, 1)
         grid.attach(self.ac2, 1, irow, 1, 1)
 
         btn = self.get_widget_for_response(Gtk.ResponseType.OK)
@@ -336,6 +336,10 @@ if __name__ == "__main__":
     #     print(l)
 
     print("Hello {}".format(dlg.name))
+
+    rc = client.get("getUser", json={"userIdentity": dlg.user.identity})
+    print(rc)
+
     if gtk_runs:
         try:
             while True:

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
 
@@ -44,7 +56,6 @@ def get_db_response():
     It is stores in a global variable. Trust the function if call
     right after your interaction with the DB.
     """
-    global db_response
     return db_response
 
 
@@ -72,7 +83,8 @@ def get_db_date(timestamp=None):
         try:
             this_date = dateutil.parser.parse(timestamp)
             out = date2string(this_date)
-        except Exception:
+            
+        except (OverflowError, dateutil.parser.ParserError):
             out = ""
 
     return out
@@ -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,
     }
 
@@ -569,3 +666,20 @@ def create_client():
     client.user.authenticate()
     print("Hello {} !".format(client.user.name))
     return client
+
+def get_db_user(client):
+    """REturn PDB information of current user.
+
+    Args:
+        client (itkdb.Client): The DB client.
+        
+    """
+    global db_response
+    if client is None:
+        return None
+    
+    try:
+        db_response = client.get("getUser", json={"userIdentity": client.user.identity})
+        return db_response
+    except Exception:
+        return None