Merge pull request #447 from medulla-tech/csv

Csv

agent/mmc/plugins/base/computers.py

@@ -396,3 +396,9 @@ def getComputerByHostnameAndMacs(self, ctx, hostname, macs):
         klass = self.components[self.main]
         instance = klass()
         return instance.getComputerByHostnameAndMacs(ctx, hostname, macs)
+
+    def getComputerFilteredByCriterion(self, ctx, criterion, values, other=None):
+        logging.getLogger().warning(222)
+        klass = self.components[self.main]
+        instance = klass()
+        return instance.getComputerFilteredByCriterion(ctx, criterion, values)

services/mmc/plugins/dyngroup/__init__.py

@@ -270,6 +270,25 @@ def reload_group(self, id):
 #            ComputerProfileManager().addComputersToProfile(ctx, [1, 2], id) # fake!
         return xmlrpcCleanup(ret)
 
+    def importCsvColumn(self, id, criterion, values):
+        id = int(id)
+        ctx = self.currentContext
+        # get machines uuids from values
+        uuids = {}
+        uuids = ComputerManager().getComputerFilteredByCriterion(ctx, criterion, values)
+
+        registered_machines = DyngroupDatabase().getRegisteredMachines(list(uuids.keys()))
+        unregistered_uuids = list(set(uuids)- set(registered_machines))
+
+        unregistered_machines = {}
+
+        for uuid in uuids:
+            unregistered_machines[uuid] = uuids[uuid]
+
+        DyngroupDatabase().addMissingMachines(unregistered_machines)
+        DyngroupDatabase().associateMachinesToGroup(id, list(uuids.keys()))
+
+
     def addmembers_to_group(self, id, uuids):
         ctx = self.currentContext
         # remove all the computers that cant be added to a profile from the list

services/mmc/plugins/dyngroup/database.py

@@ -463,6 +463,55 @@ def create_group(self, ctx, name, visibility, type = 0, parent_id = None):
         self.__createShare(group.id, root_id, visibility, 1)
         return group.id
 
+    @DatabaseHelper._sessionm
+    def getRegisteredMachines(self, session, uuids):
+        query = session.query(Machines).filter(Machines.uuid.in_(uuids)).all()
+
+        result = {}
+        for machine in query:
+            result[machine.uuid] = {
+                "id":machine.id,
+                "uuid":machine.uuid,
+                "hostname":machine.name
+            }
+
+        return result
+
+    @DatabaseHelper._sessionm
+    def addMissingMachines(self, session, machines):
+        tmp = []
+        for uuid in machines:
+            machine = Machines()
+            machine.uuid = uuid
+            machine.name = machines[uuid]["hostname"]
+            tmp.append(machine)
+        try:
+            session.add_all(tmp)
+            session.flush()
+            session.commit()
+            return True
+        except:
+            return False
+
+    @DatabaseHelper._sessionm
+    def associateMachinesToGroup(self, session, id, machines):
+        query = session.query(Machines.id).filter(Machines.uuid.in_(machines)).all()
+
+
+        results = []
+        for element in query:
+            tmp = Results()
+            tmp.FK_groups = id
+            tmp.FK_machines = element.id
+            results.append(tmp)
+        try:
+            session.add_all(results)
+            session.flush()
+            session.commit()
+            return True
+        except:
+            return False
+
     def setname_group(self, ctx, id, name):
         """
         set a new name to the group defined by it's id

services/mmc/plugins/glpi/computers.py

@@ -301,3 +301,6 @@ def getComputerByHostnameAndMacs(self, ctx, hostname, macs):
         @rtype: str or None
         """
         return self.glpi.getMachineByHostnameAndMacs(ctx, hostname, macs)
+
+    def getComputerFilteredByCriterion(self, ctx, criterion, values):
+        return self.glpi.getComputerFilteredByCriterion(ctx, criterion, values)

services/mmc/plugins/glpi/database_084.py

@@ -5346,7 +5346,6 @@ def get_machine_with_update(self, session, kb):
 
     @DatabaseHelper._sessionm
     def get_machine_for_id(self, session, strlistuuid, filter, start, limit):
-        # knokno
         criterion = filter['criterion']
         filter = filter['filter']
 
@@ -5445,6 +5444,145 @@ def get_computer_count_for_dashboard(self, session, count=True):
         else:
             return {"registered" : inventory_filtered_machines, "online": registered_online_machine, 'offline': registered_offline_machine,'unregistered': unregistred_online_machine}
 
+    @DatabaseHelper._sessionm
+    def getComputerFilteredByCriterion(self, session, ctx, criterion, values):
+        query = session.query(Machine.id, Machine.name)
+
+        if criterion == "Computer name" :
+            query = query.filter(and_(Machine.name.in_(values)))
+
+        elif criterion == "Register key":
+            query = query.filter(and_(RegContents.value.in_(values)))
+            query = query.join(RegContents, RegContents.computers_id, Machine.id)
+
+        elif criterion == "Peripheral serial":
+            # for unknown reason the mapping of Peripherals object is not reachable
+            # query = query.filter(and_(self.peripherals.serial.in_(values)))
+            # query = query.join(Computersitems, Machine.id == Computersitems.computers_id)
+            # query = query.join(Peripherals, and_(Computersitems.items_id == Peripherals.id,
+            #                       Computersitems.itemtype == "Peripheral"))
+            pass
+
+        elif criterion == "State":
+            query = query.filter(and_(State.name.in_(values)))
+            query = query.join(State, State.id == Machine.states_id)
+
+        elif criterion == "Location":
+            query = query.filter(and_(Locations.name.in_(values)))
+            query = query.join(Locations, Locations.id == Machine.locations_id)
+
+        elif criterion == "Printer serial":
+            # for unknown reason the mapping of Peripherals object is not reachable
+            # query = query.filter(and_(self.printers.c.serial.in_(values)))
+            # query = query.join(Computersitems, Machine.id == Computersitems.computers_id)
+            # query = query.join(self.printers, and_(Computersitems.items_id==self.printers.c.id,
+            #    Computersitems.itemtype == 'Printer'))
+            pass
+
+        elif criterion == "Printer name":
+            # for unknown reason the mapping of Peripherals object is not reachable
+            # query = query.filter(and_(self.printers.c.name.in_(values)))
+            # query = query.join(Computersitems, Machine.id == Computersitems.computers_id)
+            # query = query.join(self.printers, and_(Computersitems.items_id==self.printers.c.id,
+            #    Computersitems.itemtype == 'Printer'))
+            pass
+
+        elif criterion == "OS Version":
+            query = query.filter(and_(OsVersion.name.in_(values)))
+            query = query.join(OsVersion, OsVersion.id == Machine.operatingsystemversions_id)
+
+        elif criterion == "Installed version":
+            pass
+
+        elif criterion == "Description":
+            query = query.filter(and_(Machine.comment.in_(values)))
+
+        elif criterion == "System model":
+            query = query.filter(and_(Model.name.in_(values)))
+            query = query.join(Model, Model.id == Machine.computermodels_id)
+
+        elif criterion == "Inventory number":
+            query = query.filter(and_(Machine.otherserial.in_(values)))
+
+        elif criterion == "Register key value":
+            pass
+
+        elif criterion == "System type":
+            query = query.filter(self.glpi_computertypes.c.name.in_(values))
+            query = query.join(self.glpi_computertypes, Machine.computertypes_id == self.glpi_computertypes.c.id)
+
+        elif criterion == "Online computer":
+            # for csv import that doesn't make any sense
+            pass
+
+        elif criterion == "Operating system":
+            query = query.filter(and_(OS.name.in_(values)))
+            query = query.join(OS, OS.id == Machine.operatingsystems_id)
+
+        elif criterion == "Contact number":
+            query = query.filter(and_(Machine.contact_num.in_(values)))
+
+        elif criterion == "Service Pack":
+            query = query.filter(and_(OsSp.name.in_(values)))
+            query = query.join(OsSp, OsSp.id == Machine.operatingsystemservicepacks_id)
+
+        elif criterion == "Contact":
+            query = query.filter(and_(Machine.contact.in_(values)))
+
+        elif criterion == "Architecture":
+            # added for compatibility
+            pass
+
+        elif criterion == "Installed software (specific version)":
+            pass
+
+        elif criterion == "Last Logged User":
+            query = query.filter(and_(Machine.contact.in_(values)))
+
+        elif criterion == "User location":
+            query = query.filter(and_(Locations.name.in_(values)))
+            query = query.join(User, User.id == Machine.users_id)
+            query = query.join(Locations, Locations.id == User.locations_id)
+
+        elif criterion == "Vendors":
+            pass
+
+        elif criterion == "Peripheral name":
+            query = query.filter(and_(Peripherals.name.in_(values)))
+            query = query.join(Computersitems, Machine.id == Computersitems.computers_id)
+            query = query.join(Peripherals, and_(Computersitems.items_id == Peripherals.id,
+                                   Computersitems.itemtype == "Peripheral"))
+
+        elif criterion == "Entity":
+            query = query.filter(and_(Entities.name.in_(values)))
+            query = query.join(Entities, Entities.id == Machine.entities_id)
+
+
+        elif criterion == "Owner of the machine":
+            query = query.filter(and_(User.name.in_(values)))
+            query = query.join(User, User.id == Machine.users_id)
+
+        elif criterion == "Software versions":
+            query = query.filter(and_(SoftwareVersion.name.in_(values)))
+
+            query = query.join(InstSoftware, InstSoftware.computers_id == Machine.id)
+            query = query.join(SoftwareVersion, InstSoftware.softwareversions_id == SoftwareVersion.id)
+            query = query.group_by(Machine.id)
+
+        elif criterion == "System manufacturer":
+            query = query.filter(and_(Manufacturers.name.in_(values)))
+            query = query.join(Manufacturers, Manufacturers.id == Machine.manufacturers_id)
+
+        query = query.filter(and_(Machine.is_deleted==0, Machine.is_template==0))
+        response = query.all()
+
+        result = {}
+        for element in response:
+            uuid = "UUID%i"%element.id
+            name = element.name
+            result["UUID%i"%element.id] = {"uuid": uuid, "hostname": name}
+        return result
+
 # Class for SQLalchemy mapping
 class Machine(object):
     __tablename__ = 'glpi_computers'