Exemple #1
0
class Printers(hooky.Dict):
    def __init__(self):

        from win32com.client import GetObject
        self._Printer = GetObject('winmgmts:/root/cimv2').Get('Win32_Printer')

        super().__init__()
        for _ in self._Printer.instances_():
            p = Printer(_)
            self.data[_.DeviceID] = p

    def save(self):
        for name, printer in self.data.items():
            printer.save(name)

    def make_new(self, name):
        if name in [_.lower() for _ in self.keys()]:
            raise KeyError

        win32obj = self._Printer.SpawnInstance_()

        new_printer = Printer(win32obj)

        self.data[name] = new_printer
        return new_printer

    def __delitem__(self, key):
        self.data[key].win32obj.Delete_()
        del self.data[key]
Exemple #2
0
class Ports(hooky.Dict):
    def __init__(self, computer=None, account=None):
        super(Ports, self).__init__()

        self._tcpipobj = GetObject('winmgmts:/root/cimv2').Get(
            'Win32_TCPIPPrinterPort')
        self._localregtips = reg.Tips(_LOCAL_PORT_REG_KEY)
        self._old_localregtips = copy.deepcopy(self._localregtips)

        self._tcpipobjs_to_del = []

        self._tcpipobjs = {}
        for _ in self._tcpipobj.instances_():
            self.data[_.Name] = TCPIPPort(_)
            self._tcpipobjs[_.Name] = _

        for _, v in self._localregtips.items():
            self.data[_] = LocalPort(v)

    def make_a_tcpipport(self, name):
        if name in [_.lower() for _ in self.keys()]:
            raise KeyError

        win32obj = self._tcpipobj.SpawnInstance_()
        p = TCPIPPort(win32obj)
        self._tcpipobjs[name] = win32obj
        self[name] = p
        return p

    def make_a_localport(self, name):
        p = LocalPort()
        self[name] = p
        return p

    def save(self):
        for k, v in self.data.items():
            for one in self._tcpipobjs_to_del:
                one.Delete_()

            if isinstance(v, TCPIPPort):
                win32obj = self._tcpipobjs[k]
                win32obj.Name = k
                v.save_to(win32obj)
                win32obj.Put_()

            elif isinstance(v, LocalPort):
                self._localregtips[k] = v.value or ''

        if self._localregtips != self._old_localregtips:
            self._localregtips.save_to(_LOCAL_PORT_REG_KEY)
            self._old_localregtips = copy.deepcopy(self._localregtips)

            logging.info('restart print spooler')
            _ = 'Print Spooler'
            win32serviceutil.RestartService('Print Spooler')
            sec = 0
            while win32serviceutil.QueryServiceStatus(_)[1] != 4 and sec < 10:
                time.sleep(0.2)
                sec += 0.2

            print(sec)

    def __getitem__(self, key):
        for name, obj in self.data.items():
            if name.lower() == key.lower():
                return obj

    def __setitem__(self, key, value):
        if not isinstance(value, (TCPIPPort, LocalPort)):
            raise TypeError
        try:
            del self[key]
        except KeyError:
            pass

        try:
            del self._tcpipobjs[key]
        except KeyError:
            pass

        self.data[key] = value
        if isinstance(value, TCPIPPort):
            self._tcpipobjs[key] = self._tcpipobj.SpawnInstance_()

    def __delitem__(self, key):
        k_to_del = None
        for k, v in self.data.items():
            if k.lower() == key:
                k_to_del = key
                break

        if k_to_del is None:
            raise KeyError

        else:
            v = self.data[k_to_del]

            if isinstance(v, TCPIPPort):
                try:
                    self._tcpipobjs_to_del.append(self._tcpipobjs[key])
                    del self._tcpipobjs[key]
                except KeyError:
                    pass

            elif isinstance(v, LocalPort):
                del self._localregtips[key]

            del self.data[k_to_del]