Ejemplo n.º 1
0
 def lock_file(self, path, ttl=None):
     """
     Блокирование ресурса.
     @param path: Идентификатор.
     """
     p, tail = os.path.split(path)
     nm, ext = tail.split('.')
     ic_res.lockRes(None, nm, ext)
Ejemplo n.º 2
0
    def edit(self):
        """
        Редактирование модуля.
        """
        # Определяем имя модуля
        py_name = self.getModuleName()
        py_dir = self.getModulePath()
        py_file = os.path.join(py_dir, py_name + self.ext)

        # Определяем IDE
        ide = self.getRoot().getParent().ide
        if ide is None:
            io_prnt.outWarning(
                u'Не определен IDE для редактрования модуля <%s>' % py_file)
            io_prnt.outLog(u'Используется внешний редактор модулей Python')
            ide = ext_python_editor.icExtPythonEditor()

        if ide:
            # Сначала разблокировать все модули
            self.getRoot().unlockAllPyFilesInIDE()
            if ide.IsOpenedFile(py_file):
                ide.CloseFile(py_file)
            else:
                parent_pack = os.path.basename(py_dir)
                # Если модуль заблокирован,
                # тогда открыть его только для просмотра
                if ic_res.isLockRes(self.name, parent_pack, 'py',
                                    self.getRoot().lock_dir):
                    lock_rec = ic_res.getLockResRecord(self.name, parent_pack,
                                                       'py',
                                                       self.getRoot().lock_dir)
                    ic_dlg.icMsgBox(
                        u'ВНИМАНИЕ!',
                        u'Ресурс <%s> заблокирован пользователем <%s>. Компьютер: <%s>.'
                        % (self.name, lock_rec['user'], lock_rec['computer']))
                    self.readonly = True
                else:
                    # Заблокировать файл
                    ic_res.lockRes(self.name, parent_pack, 'py',
                                   self.getRoot().lock_dir)

            # Условие открытия в редакторе ресурса
            if self.isResClass(py_file):
                self.getRoot().getParent().res_editor.SetResource(self.name,
                                                                  py_dir,
                                                                  self.name,
                                                                  'py',
                                                                  bEnable=True)

            return ide.OpenFile(py_file, True, readonly=self.readonly)

        return False
Ejemplo n.º 3
0
 def edit(self):
     """
     Запуск ресурса на редактирование.
     """
     tree_prj = self.getRoot().getParent()
     res_editor = tree_prj.res_editor
     if res_editor:
         res_name = self.getResName()
         res_path = self.getResPath()
         ic_file.MakeDirs(res_path)
         res_file = self.getResFileName()
         res_ext = self.getResFileExt()
         self.getRoot().unlockResInResEditor(res_editor)
         if not self.readonly:
             is_lock = ic_res.isLockRes(res_name, res_file, res_ext,
                                        self.getRoot().lock_dir)
             if not is_lock:
                 # Если ресурс не заблокирован, то заблокировать его
                 # и отдать на редактирование
                 ic_res.lockRes(res_name, res_file, res_ext,
                                self.getRoot().lock_dir)
                 return res_editor.SetResource(res_name,
                                               res_path,
                                               res_file,
                                               res_ext,
                                               bEnable=True)
             else:
                 lock_rec = ic_res.getLockResRecord(res_name, res_file,
                                                    res_ext,
                                                    self.getRoot().lock_dir)
                 ic_dlg.icMsgBox(
                     u'ВНИМАНИЕ!',
                     u'Resource <%s> is locked by user <%s>. Computer: <%s>.'
                     % (res_name, lock_rec['user'], lock_rec['computer']))
                 # Открыть только для чтения
                 self.readonly = True
                 return res_editor.SetResource(res_name,
                                               res_path,
                                               res_file,
                                               res_ext,
                                               bEnable=False)
         else:
             return res_editor.SetResource(res_name,
                                           res_path,
                                           res_file,
                                           res_ext,
                                           bEnable=False)
     return None
Ejemplo n.º 4
0
 def edit(self):
     """
     Редактирование пакета(редактирование __init__.py файла).
     """
     ide = self.getRoot().getParent().ide
     if ide:
         pack_dir = self.getPath()
         py_file = pack_dir + '/__init__.py'
         # Сначала разблокировать все модули
         self.getRoot().unlockAllPyFilesInIDE()
         if not ide.SelectFile(py_file):
             # Заблокировать файл
             parent_pack = os.path.basename(os.path.dirname(pack_dir))
             ic_res.lockRes(self.name, parent_pack, 'py',
                            self.getRoot().lock_dir)
             return ide.OpenFile(py_file, True, readonly=self.readonly)
         return True
Ejemplo n.º 5
0
 def lockUserRes(self):
     """
     Блокировка ресурса пользователей.
     """
     return ic_res.lockRes(None, 'users', 'acc')