# -*- coding: utf-8 -*-
"""
Модуль cerebro.aclasses содержит описание типов (классов) данных,
используемых при работе с программным интерфейсом.
.. rubric:: Классы
* :py:class:`cerebro.aclasses.AbstractAttachment`
* :py:class:`cerebro.aclasses.AbstractMessage`
* :py:class:`cerebro.aclasses.AbstractTag`
* :py:class:`cerebro.aclasses.Activities`
* :py:class:`cerebro.aclasses.Attachment`
* :py:class:`cerebro.aclasses.Message`
* :py:class:`cerebro.aclasses.NewAttachment`
* :py:class:`cerebro.aclasses.Perm`
* :py:class:`cerebro.aclasses.Statuses`
* :py:class:`cerebro.aclasses.Tag`
* :py:class:`cerebro.aclasses.Task`
* :py:class:`cerebro.aclasses.Users`
"""
import cerebro
import py_cerebro_classes
def get_val_by_type(val_id):
pass
[документация]class AbstractAttachment:
"""
Базовый класс вложения.
Имеет основной функционал для доступа к свойствам вложения.
.. rubric:: Методы
* :py:meth:`comment() <cerebro.aclasses.AbstractAttachment.comment>`
* :py:meth:`file_path() <cerebro.aclasses.AbstractAttachment.file_path>`
* :py:meth:`file_size() <cerebro.aclasses.AbstractAttachment.file_size>`
* :py:meth:`has_review() <cerebro.aclasses.AbstractAttachment.has_review>`
* :py:meth:`hashtags() <cerebro.aclasses.AbstractAttachment.hashtags>`
* :py:meth:`is_link() <cerebro.aclasses.AbstractAttachment.is_link>`
* :py:meth:`name() <cerebro.aclasses.AbstractAttachment.name>`
* :py:meth:`review_path() <cerebro.aclasses.AbstractAttachment.review_path>`
"""
DATA_ = ''
"""
.. rubric:: Поля кортежа данных вложения
"""
DATA_MTM = 0
"""Время модификации данных. Тип datetime."""
DATA_EVENT_ID = 1
"""Идентификатор сообщения. Тип int."""
DATA_GROUP_ID = 2
"""Идентификатор вложения. Тип int."""
DATA_IS_LINK = 3
"""Тип вложения: 0 - файл, 1 - ссылка."""
DATA_HAS_REVIEW = 4
"""Наличие рецензии. 0 - нет, 1 - есть."""
DATA_FILE_SIZE = 5
"""Размер вложения в байтах. Тип int."""
DATA_NAME = 6
"""Имя вложения. Тип string."""
DATA_COMMENT = 7
"""Текстовый комментарий. Тип string."""
DATA_FILE_PATH = 8
"""Путь до файла. Тип string."""
DATA_REVIEW_PATH = 9
"""Путь до файла рецензии. Тип string."""
DATA_FILE_HASH = 10
"""Хеш файла. Тип string."""
DATA_REVIEW_HASH = 11
"""Хеш файла рецензии. Тип string."""
DATA_THUMB1_HASH = 12
"""Хеш первого эскиза. Тип string."""
DATA_THUMB2_HASH = 13
"""Хеш второго эскиза. Тип string."""
DATA_THUMB3_HASH = 14
"""Хеш третьего эскиза. Тип string."""
def __init__(self, event_id, message_id, attach_id):
self.__event_id = event_id
self.__message_id = message_id
self.__attach_id = attach_id
[документация] def name(self):
"""
:returns: имя вложения. В случаи ссылки возвращает полный путь до файла.
:rtype: string
"""
return py_cerebro_classes.attach_data(self.__event_id, self.__message_id, self.__attach_id)[AbstractAttachment.DATA_NAME]
[документация] def is_link(self):
"""
:returns: True, если вложение является ссылкой.
:rtype: bool
"""
return py_cerebro_classes.attach_data(self.__event_id, self.__message_id, self.__attach_id)[AbstractAttachment.DATA_IS_LINK] != 0
[документация] def has_review(self):
"""
:returns: True, если вложение имеет рецензию (аудио-визуальные комментарии).
:rtype: bool
"""
return py_cerebro_classes.attach_data(self.__event_id, self.__message_id, self.__attach_id)[AbstractAttachment.DATA_HAS_REVIEW] != 0
[документация] def file_size(self):
"""
:returns: размер файла в байтах. В случаи ссылки возвращает 0.
:rtype: int
"""
return py_cerebro_classes.attach_data(self.__event_id, self.__message_id, self.__attach_id)[AbstractAttachment.DATA_FILE_SIZE]
[документация] def file_path(self):
"""
:returns: путь до файла. Может отсутствовать, если файла нет в файловом хранилище.
В этом случаи возвратится пустая строка.
:rtype: string
"""
return py_cerebro_classes.attach_data(self.__event_id, self.__message_id, self.__attach_id)[AbstractAttachment.DATA_FILE_PATH]
[документация] def review_path(self):
"""
:returns: путь до файла рецензии (аудио-визуальных комментариев).
Может отсутствовать, если файла нет в файловом хранилище. В этом случаи возвратится пустая строка.
:rtype: string
"""
return py_cerebro_classes.attach_data(self.__event_id, self.__message_id, self.__attach_id)[AbstractAttachment.DATA_REVIEW_PATH]
[документация]class AbstractMessage:
"""
Базовый класс сообщения.
Имеет основной функционал для доступа к свойствам сообщения.
.. rubric:: Методы
* :py:meth:`approved_time() <cerebro.aclasses.AbstractMessage.approved_time>`
* :py:meth:`hashtags() <cerebro.aclasses.AbstractMessage.hashtags>`
* :py:meth:`is_approved() <cerebro.aclasses.AbstractMessage.is_approved>`
* :py:meth:`is_client_visible() <cerebro.aclasses.AbstractMessage.is_client_visible>`
* :py:meth:`parent_message_id() <cerebro.aclasses.AbstractMessage.parent_message_id>`
* :py:meth:`posted_time() <cerebro.aclasses.AbstractMessage.posted_time>`
* :py:meth:`task_id() <cerebro.aclasses.AbstractMessage.task_id>`
* :py:meth:`text_as_html() <cerebro.aclasses.AbstractMessage.text_as_html>`
* :py:meth:`text_as_plain() <cerebro.aclasses.AbstractMessage.text_as_plain>`
* :py:meth:`type() <cerebro.aclasses.AbstractMessage.type>`
* :py:meth:`work_time() <cerebro.aclasses.AbstractMessage.work_time>`
"""
TYPE_ = ''
"""
.. rubric:: Типы сообщений
"""
TYPE_DEFINITION =0
"""Постановка задачи."""
TYPE_REVIEW =1
"""Рецензия."""
TYPE_REPORT =2
"""Отчет."""
TYPE_NOTE =3
"""Заметка."""
TYPE_CLIENT_REVIEW =4
"""Рецензия клиента."""
TYPE_RESOURCE_REPORT =5
"""Отчет за ресурс."""
TYPE_STATUS_CHANGES =6
"""Сообщение об изменении статуса задачи."""
FLAG_ = ''
"""
.. rubric:: Флаги сообщения
"""
FLAG_CLIENT_VISIBLE = 0
"""Сообщение видимо для клиентов."""
FLAG_APPROVED = 1
"""Сообщение принято (Отчет принят)."""
DATA_ = ''
"""
.. rubric:: Поля кортежа данных сообщения
"""
DATA_MTM = 0
"""Время модификации данных. Тип datetime."""
DATA_ID = 1
"""Идентификатор сообщения."""
DATA_PID = 2
"""Идентификатор родительского сообщения."""
DATA_TYPE = 3
""":py:const:`Тип сообщения <cerebro.aclasses.AbstractMessage.TYPE_>`."""
DATA_CREATOR_NAME = 4
"""Имя автора собщения."""
DATA_CREATED = 5
"""Время создания сообщения. Тип datetime."""
DATA_WORK_TIME = 6
"""Рабочее время в минутах."""
DATA_TEXT = 7
"""Текст сообщения в формате html."""
DATA_APPROVED_TIME = 8
"""Принятое время в минутах."""
DATA_FLAGS = 9
""":py:const:`Флаги сообщения <cerebro.aclasses.AbstractMessage.FLAG_>`."""
DATA_MODERATOR_NAME = 10
"""Имя пользователя, изменившего сообщение."""
DATA_TID = 11
"""Идентификатор задачи, к которой относится сообщение."""
DATA_XMTM = 12
"""Реальное время модификации данных. Тип datetime."""
DATA_CREATOR_ID = 13
"""Идентификатор автора собщения."""
DATA_MODERATOR_ID = 14
"""Идентификатор пользователя, изменившего сообщение."""
DATA_STATUS_ID = 15
DATA_STATUS_NAME = 16
def __init__(self, event_id, message_id):
self.__event_id = event_id
self.__message_id = message_id
[документация] def type(self):
"""
:returns: :py:const:`тип сообщения <cerebro.aclasses.AbstractMessage.TYPE_>`.
:rtype: int
::
if message.type() == message.TYPE_REPORT:
print('Рабочие время отчета', message.work_time())
"""
return py_cerebro_classes.message_data(self.__event_id, self.__message_id)[AbstractMessage.DATA_TYPE]
[документация] def text_as_html(self):
"""
:returns: текст сообщения в формате html.
:rtype: string
"""
return py_cerebro_classes.message_text_html(self.__event_id, self.__message_id)
[документация] def text_as_plain(self):
"""
:returns: текст сообщения в формате простого текста.
:rtype: string
"""
return py_cerebro_classes.message_text_plain(self.__event_id, self.__message_id)
[документация] def work_time(self):
"""
:returns: рабочее время сообщения в минутах.
Если сообщение типа Отчет или Отчет за ресурс, то это заявленное время отчета.
Если тип сообщения Рецензия, то это принятое время за предыдущий отчет.
Для остальных типов это значение равно 0.
:rtype: int
"""
return py_cerebro_classes.message_data(self.__event_id, self.__message_id)[AbstractMessage.DATA_WORK_TIME]
[документация] def approved_time(self):
"""
:returns: принятое время сообщения в минутах.
Если сообщение типа Отчет или Отчет за ресурс, то это принятое время отчета.
Для остальных типов это значение равно 0.
:rtype: int
"""
return py_cerebro_classes.message_data(self.__event_id, self.__message_id)[AbstractMessage.DATA_APPROVED_TIME]
[документация] def posted_time(self):
"""
:returns: время создания сообщения.
:rtype: datetime
"""
return py_cerebro_classes.message_data(self.__event_id, self.__message_id)[AbstractMessage.DATA_CREATED]
[документация] def is_client_visible(self):
"""
:returns: True, если сообщение помечено как видимое для клиентов.
:rtype: bool
"""
flags = py_cerebro_classes.message_data(self.__event_id, self.__message_id)[AbstractMessage.DATA_FLAGS]
return cerebro.core.has_flag(flags, AbstractMessage.FLAG_CLIENT_VISIBLE) != 0
[документация] def is_approved(self):
"""
:returns: True, если тип сообщения Отчет или Отчет за ресурс и он помечен как принятый.
У такого отчета заявленое время равно принятому.
:rtype: bool
::
if message.is_approved() == True:
print('work_time == approved_time', message.work_time() == message.approved_time())
"""
flags = py_cerebro_classes.message_data(self.__event_id, self.__message_id)[AbstractMessage.DATA_FLAGS]
return cerebro.core.has_flag(flags, AbstractMessage.FLAG_APPROVED) != 0
[документация] def parent_message_id(self):
"""
:returns: идентификатор родительского сообщения, то есть сообщения на которое это сообщение является ответом.
У сообщений типа "Постановка задачи", как правило, идентификатор родительского сообщения равен 0,
что означает что у постановки задачи нет родительского сообщения.
:rtype: int
::
if message.type() != message.TYPE_DEFINITION:
parent_id = message.parent_message_id()
print('Родительское сообщение', cerebro.core.message(parent_id).text_as_plain())
"""
return py_cerebro_classes.message_data(self.__event_id, self.__message_id)[AbstractMessage.DATA_PID]
[документация] def task_id(self):
"""
:returns: идентификатор задачи, к которой относится сообщение.
:rtype: int
"""
return py_cerebro_classes.message_data(self.__event_id, self.__message_id)[AbstractMessage.DATA_TID]
[документация]class NewAttachment(AbstractAttachment):
"""
Класс нового вложения.
.. rubric:: Методы
* :py:meth:`add_hashtags() <cerebro.aclasses.NewAttachment.add_hashtags>`
* :py:meth:`remove_hashtags() <cerebro.aclasses.NewAttachment.remove_hashtags>`
* :py:meth:`set_comment() <cerebro.aclasses.NewAttachment.set_comment>`
* :py:meth:`set_name() <cerebro.aclasses.NewAttachment.set_name>`
* :py:class:`методы базового класса cerebro.aclasses.AbstractAttachment <cerebro.aclasses.AbstractAttachment>`
Объекты данного класса используются в событии :py:class:`cerebro.events.BeforeEventMessage`
в методе :py:meth:`new_attachments() <cerebro.events.BeforeEventMessage.new_attachments>`.
::
def before_event(event):
evtype = event.event_type()
if evtype == event.EVENT_CREATION_OF_MESSAGE or evtype == event.EVENT_CHANGING_OF_MESSAGE:
new_attachs = event.new_attachments()
for attach in new_attachs:
print(attach.name())
"""
def __init__(self, event_id, message_id, attach_id):
cerebro.aclasses.AbstractAttachment.__init__(self, event_id, message_id, attach_id)
[документация] def set_name(self, name):
"""
:param string name: имя вложения.
Изменяет имя нового вложения.
::
new_attachs = event.new_attachments()
for attach in new_attachs:
if attach.is_link() != True: # если новое вложение добавлено как файл
attach.set_name('Вложение - ' + i.name()) # изменим имя
"""
py_cerebro_classes.attach_set_name(self._AbstractAttachment__event_id, self._AbstractAttachment__attach_id, name)
[документация]class Attachment(AbstractAttachment):
"""
Класс вложения.
.. rubric:: Методы
* :py:meth:`add_hashtags() <cerebro.aclasses.Attachment.add_hashtags>`
* :py:meth:`data() <cerebro.aclasses.Attachment.data>`
* :py:meth:`file_hash() <cerebro.aclasses.Attachment.file_hash>`
* :py:meth:`id() <cerebro.aclasses.Attachment.id>`
* :py:meth:`message_id() <cerebro.aclasses.Attachment.message_id>`
* :py:meth:`remove_hashtags() <cerebro.aclasses.Attachment.remove_hashtags>`
* :py:meth:`review_hash() <cerebro.aclasses.Attachment.review_hash>`
* :py:meth:`set_comment() <cerebro.aclasses.Attachment.set_comment>`
* :py:meth:`thumbnail_hashs() <cerebro.aclasses.Attachment.thumbnail_hashs>`
* :py:class:`методы базового класса cerebro.aclasses.AbstractAttachment <cerebro.aclasses.AbstractAttachment>`
::
attach = cerebro.core.current_attachment()
::
attachs = message.attachments()
"""
def __init__(self, message_id, attach_id):
AbstractAttachment.__init__(self, -2, message_id, attach_id)
[документация] def id(self):
"""
:returns: идентификатор вложения.
:rtype: int
"""
return self._AbstractAttachment__attach_id
[документация] def message_id(self):
"""
:returns: идентификатор сообщения, к которому принодлежит вложение.
:rtype: int
"""
return self._AbstractAttachment__message_id
[документация] def file_hash(self):
"""
:returns: хеш файла.
:rtype: string
Хеш используется файловым хранилищем Cargador для идентификации файлов.
Зная хеш файла вы можете получить путь к файлу или поставить его на закачку,
если файла нет в вашем файловом хранилище.
::
if attach.is_link() != True: # проверяем, что вложение не является линком
# Скачивание вложения
file_name = cerebro.cargador.file_name_form_hash(attach.file_hash()) # пробуем получить имя файла по хешу
if file_name == '' or file_name == None: # если файла нет, пробуем его скачать
cerebro.cargador.download_file(attach.file_hash())
Если вложение является линком, у него нет хеша, поскольку вложения
добавленные как линки не добавляются в файловое хранилище Cargador.
"""
return py_cerebro_classes.attach_data(self._AbstractAttachment__event_id, self._AbstractAttachment__message_id, self._AbstractAttachment__attach_id)[AbstractAttachment.DATA_FILE_HASH]
[документация] def review_hash(self):
"""
:returns: хеш рецензии файла (аудио-визуальных комментариев).
:rtype: string
"""
return py_cerebro_classes.attach_data(self._AbstractAttachment__event_id, self._AbstractAttachment__message_id, self._AbstractAttachment__attach_id)[AbstractAttachment.DATA_REVIEW_HASH]
[документация] def thumbnail_hashs(self):
"""
:returns: список хешей уменшеных эскизов файла.
:rtype: list(string,)
"""
data = py_cerebro_classes.attach_data(self._AbstractAttachment__event_id, self._AbstractAttachment__message_id, self._AbstractAttachment__attach_id)
tumbs = list()
tumbs.append(data[AbstractAttachment.DATA_THUMB1_HASH])
tumbs.append(data[AbstractAttachment.DATA_THUMB2_HASH])
tumbs.append(data[AbstractAttachment.DATA_THUMB3_HASH])
return tumbs
[документация] def data(self):
"""
:returns: :py:const:`кортеж данных <cerebro.aclasses.AbstractAttachment.DATA_>` по вложению.
:rtype: tuple
По сути, большинство методов данного класса являются обёртками к этому кортежу.
Поэтому вы можете пользоваться напрямую данными из него.
::
attach.file_hash() == attach.data()[attach.DATA_FILE_HASH]
attach.is_link() == (attach.data()[attach.DATA_IS_LINK] != 0)
# и так далее
"""
return py_cerebro_classes.attach_data(self._AbstractAttachment__event_id, self._AbstractAttachment__message_id, self._AbstractAttachment__attach_id)
[документация]class Message(AbstractMessage):
"""
Kласс сообщения.
.. rubric:: Методы
* :py:meth:`add_hashtags() <cerebro.aclasses.Message.add_hashtags>`
* :py:meth:`attachments() <cerebro.aclasses.Message.attachments>`
* :py:meth:`creator_id() <cerebro.aclasses.Message.creator_id>`
* :py:meth:`data() <cerebro.aclasses.Message.data>`
* :py:meth:`id() <cerebro.aclasses.Message.id>`
* :py:meth:`moderator_id() <cerebro.aclasses.Message.moderator_id>`
* :py:meth:`modification_time() <cerebro.aclasses.Message.modification_time>`
* :py:meth:`remove_hashtags() <cerebro.aclasses.Message.remove_hashtags>`
* :py:class:`методы базового класса cerebro.aclasses.AbstractMessage <cerebro.aclasses.AbstractMessage>`
::
message = cerebro.core.current_message()
::
message = cerebro.core.message(message_id)
"""
def __init__(self, message_id):
AbstractMessage.__init__(self, -2, message_id)
[документация] def id(self):
"""
:returns: идентификатор сообщения.
:rtype: int
"""
return self._AbstractMessage__message_id
[документация] def creator_id(self):
"""
:returns: идентификатор автора сообщения.
:rtype: int
"""
return py_cerebro_classes.message_data(self._AbstractMessage__event_id, self._AbstractMessage__message_id)[AbstractMessage.DATA_CREATOR_ID]
[документация] def moderator_id(self):
"""
:returns: идентификатор пользователя, изменившего сообщение.
:rtype: int
"""
return py_cerebro_classes.message_data(self._AbstractMessage__event_id, self._AbstractMessage__message_id)[AbstractMessage.DATA_MODERATOR_ID]
[документация] def modification_time(self):
"""
:returns: время изменения сообщения.
:rtype: datetime
"""
return py_cerebro_classes.message_data(self._AbstractMessage__event_id, self._AbstractMessage__message_id)[AbstractMessage.DATA_MTM]
[документация] def data(self):
"""
:returns: :py:const:`кортеж данных <cerebro.aclasses.AbstractMessage.DATA_>` по сообщению.
:rtype: tuple
По сути, б2ольшинство методов данного класса являются обёртками к этому кортежу.
Поэтому вы можете пользоваться напрямую данными из него.
::
message.creator_id() == message.data()[message.DATA_CREATOR_ID]
message.is_client_visible() == cerebro.core.has_flag(message.data()[message.DATA_FLAGS], message.FLAG_CLIENT_VISIBLE)
# и так далее
"""
return py_cerebro_classes.message_data(self._AbstractMessage__event_id, self._AbstractMessage__message_id)
[документация] def attachments(self):
"""
:returns: список вложений в сообщение.
:rtype: list(:py:class:`cerebro.aclasses.Attachment`,)
"""
attachs = list()
ids = py_cerebro_classes.message_attach_ids(self._AbstractMessage__event_id, self._AbstractMessage__message_id)
if ids != None:
for id in ids:
attachs.append(Attachment(self._AbstractMessage__message_id, id))
return attachs
[документация]class AbstractTag:
"""
Базовый класс тега задачи.
.. rubric:: Методы
* :py:meth:`elements() <cerebro.aclasses.AbstractTag.elements>`
* :py:meth:`id() <cerebro.aclasses.AbstractTag.id>`
* :py:meth:`name() <cerebro.aclasses.AbstractTag.name>`
* :py:meth:`type() <cerebro.aclasses.AbstractTag.type>`
.. note:: Теги используются в Cerebro, как дополнительные свойства задач.
При назначении тега на проект, он автоматически становится свойством задачи.
В процесссе работы с задачами теги заполняются значениями.
"""
TYPE_ = ''
"""
.. rubric:: Типы тегов
"""
TYPE_INTEGER = 0
"""Целочисленный тип."""
TYPE_ENUM = 1
"""Перечисление."""
TYPE_REAL = 2
"""Вещественное число."""
TYPE_STRING = 3
"""Строка."""
TYPE_MULTI_ENUM = 4
"""Множественное перечисление."""
def __init__(self, tag_id):
self.__tag_id = tag_id
[документация] def id(self):
"""
:returns: идентификатор тега.
:rtype: int
"""
return self.__tag_id
[документация] def name(self):
"""
:returns: имя тега.
:rtype: string
"""
return py_cerebro_classes.tag_name(self.__tag_id)
[документация] def type(self):
"""
:returns: :py:const:`тип тега <cerebro.aclasses.AbstractTag.TYPE_>`.
:rtype: int
"""
return py_cerebro_classes.tag_type(self.__tag_id)
[документация] def elements(self):
"""
:returns: список возможных элементов перечесления.
Если тип тега не перечисление либо множественное перечисление, возвращается None.
:rtype: [(element_id, element_name),] - список кортежей из двух полей:
идентификатор элемента перечисления, имя перечисления
"""
return py_cerebro_classes.tag_elements(self.__tag_id)
[документация]class Tag(AbstractTag):
"""
Класс тега задачи.
.. rubric:: Методы
* :py:meth:`set_value() <cerebro.aclasses.Tag.set_value>`
* :py:meth:`task_id() <cerebro.aclasses.Tag.task_id>`
* :py:meth:`value() <cerebro.aclasses.Tag.value>`
* :py:class:`методы базового класса cerebro.aclasses.AbstractTag <cerebro.aclasses.AbstractTag>`
.. note:: Теги используются в Cerebro, как дополнительные свойства задач.
При назначении тега на проект, он автоматически становится свойством задачи.
В процесссе работы с задачами теги заполняются значениями.
::
tags = task.tags()
for tag in tags:
print('Тег задачи', tag.name(), tag.value())
"""
def __init__(self, task_id, tag_id):
AbstractTag.__init__(self, tag_id)
self.__task_id = task_id
[документация] def task_id(self):
"""
:returns: идентификатор задачи.
:rtype: int
"""
return self.__task_id
[документация] def set_value(self, val):
"""
Устанавливает значение тега. Значение None переводит значение тега в не задано.
В зависимости от типа тега устанавливаются значения различных типов::
if tag.type() == tag.TYPE_INTEGER: # целочисленный тип
tag.set_value(int)
elif tag.type() == tag.TYPE_ENUM: # тип перечисление
tag.set_value(element_id) # идентификатор элемента перечисления
elif tag.type() == tag.TYPE_REAL: # вещественное число
tag.set_value(float)
elif tag.type() == tag.TYPE_STRING: # строка
tag.set_value(string)
elif tag.type() == tag.TYPE_MULTI_ENUM: # тип множественное перечисление
tag.set_value([element_id,]) # список идентификаторов элементов перечисления
Сбрасывание значения тега::
if tag.value() != None:
tag.set_value(None)
При работе с тегами типов перечисление и множественное перечисление,
идентификаторы для установки значения берутся из списка элементов :py:meth:`elements() <cerebro.aclasses.AbstractTag.elements>`.
::
elems = tag.elements()
if len(elems) > 0: # для типа перечисление
tag.set_value(elems[0][0])
::
if len(elems) > 1: # для типа множественное перечисление.
# Устанавливается два елемента
elems_to_set = [ elems[0][0], elems[1][0] ]
tag.set_value(elems_to_set)
.. seealso:: :py:meth:`value() <cerebro.aclasses.Tag.value>`.
"""
if val == None:
py_cerebro_classes.tag_clear(self._AbstractTag__tag_id, self.__task_id)
else:
type = py_cerebro_classes.tag_type(self._AbstractTag__tag_id)
if type == Tag.TYPE_INTEGER:
py_cerebro_classes.tag_set_int(self._AbstractTag__tag_id, self.__task_id, val)
elif type == Tag.TYPE_ENUM:
py_cerebro_classes.tag_set_enum(self._AbstractTag__tag_id, self.__task_id, val)
elif type == Tag.TYPE_REAL:
py_cerebro_classes.tag_set_real(self._AbstractTag__tag_id, self.__task_id, val)
elif type == Tag.TYPE_STRING:
py_cerebro_classes.tag_set_str(self._AbstractTag__tag_id, self.__task_id, val)
elif type == Tag.TYPE_MULTI_ENUM:
py_cerebro_classes.tag_set_multi_enum(self._AbstractTag__tag_id, self.__task_id, val)
[документация] def value(self):
"""
:returns: значение тега. Если значение тега не задано, возвращается None.
В зависимости от типа тега возвращаются значения различных типов::
if tag.type() == tag.TYPE_INTEGER: # целочисленный тип
return int
elif tag.type() == tag.TYPE_ENUM: # тип перечисление
return (element_id, element_name) # кортеж из двух полей: идентификатор элемента перечисления, имя перечисления
elif tag.type() == tag.TYPE_REAL: # вещественное число
return float
elif tag.type() == tag.TYPE_STRING: # строка
return string
elif tag.type() == tag.TYPE_MULTI_ENUM: # тип множественное перечисление
return [(element_id, element_name),] # список кортежей из двух полей: идентификатор элемента перечисления, имя перечисления
.. seealso:: :py:meth:`set_value() <cerebro.aclasses.Tag.set_value>`.
"""
return py_cerebro_classes.tag_value(self._AbstractTag__tag_id, self.__task_id)
[документация]class Users:
"""
Класс пользователей.
.. rubric:: Методы
* :py:meth:`data() <cerebro.aclasses.Users.data>`
* :py:meth:`is_resource() <cerebro.aclasses.Users.is_resource>`
Список пользователей состоит из пользователей с аккаунтами в системе Cerebro
и материальных ресурсов, которые не имеют аккаунтов, но при этом учавствуют в производстве.
Примером материального ресурса может служить монтажная комната или видеокамера.
::
users = cerebro.core.users()
"""
DATA_ = ''
"""
.. rubric:: Поля кортежа данных пользователя
"""
DATA_ID = 0
"""Идентификатор пользователя."""
DATA_FULL_NAME = 1
"""Полное имя пользователя."""
DATA_FLAGS = 2
""":py:const:`Флаги пользователя <cerebro.aclasses.Users.FLAG_>`."""
DATA_LOGIN = 3
"""Логин пользователя."""
DATA_FIRST_NAME = 4
"""Имя пользователя."""
DATA_LAST_NAME = 5
"""Фамилия пользователя."""
DATA_EMAIL = 6
"""E-mail пользователя."""
DATA_PHONE = 7
"""Телефон пользователя."""
DATA_ICQ = 8
"""ICQ/Skype пользователя."""
FLAG_ = ''
"""
.. rubric:: Флаги пользователя
"""
FLAG_IS_RESOURCE = 1 #
"""Является материльным ресурсом."""
def __init__(self):
pass
[документация] def data(self):
"""
:returns: список :py:const:`кортежей данных <cerebro.aclasses.Users.DATA_>` по пользователям.
:rtype: list(tuple,)
"""
return py_cerebro_classes.users()
[документация] def is_resource(user_flags):
"""
:param int user_flags: значение флагов пользователя.
:returns: True, если :py:const:`флаг <cerebro.aclasses.Users.FLAG_>` установлен как материальный ресурс.
:rtype: bool
Пример выборки материальных ресурсов из списка пользователей::
resources = list()
users = cerebro.core.users()
for user in users.data():
if cerebro.aclasses.Users.is_resource(user[users.DATA_FLAGS]) == True:
resources.append(user)
"""
return cerebro.core.has_flag(user_flags, Users.FLAG_IS_RESOURCE)
[документация]class Statuses:
"""
Класс статусов.
.. rubric:: Методы
* :py:meth:`data() <cerebro.aclasses.Statuses.data>`
* :py:meth:`inheritable() <cerebro.aclasses.Statuses.inheritable>`
* :py:meth:`type() <cerebro.aclasses.Statuses.type>`
::
statuses = cerebro.core.statuses()
"""
DATA_ = ''
"""
.. rubric:: Поля кортежа данных статуса
"""
DATA_ID = 0
"""Идентификатор статуса."""
DATA_NAME = 1
"""Имя статуса."""
DATA_FLAGS = 2
""":py:const:`Флаги статуса <cerebro.aclasses.Statuses.FLAG_>`."""
DATA_ORDER = 3
"""Порядковый номер статуса."""
DATA_DESCRIPTION = 4
"""Описание статуса."""
DATA_ICON = 5
"""Иконка статуса. Формат иконки XPM."""
DATA_COLOR = 6
"""Цвет статуса. Формат RGB представлен целым числом."""
FLAG_ = ''
"""
.. rubric:: Флаги статуса
"""
FLAG_INHERITABLE = 1
"""Являтся наследуемым."""
FLAG_WORK_STARTED = 2
FLAG_WORK_STOPPED = 3
TYPE_ = ''
"""
.. rubric:: Типы статусов
"""
TYPE_IS_SUSPENDED = 0
"""Задача преостановлена."""
TYPE_IS_IN_PROGRESS = 1
"""Задача выполняется."""
TYPE_IS_STOPPED = 2
"""Задача остановлена."""
def __init__(self):
pass
[документация] def data(self):
"""
:returns: список :py:const:`кортежей данных <cerebro.aclasses.Statuses.DATA_>` по всем статусам.
:rtype: list(tuple,)
. seealso:: :py:meth:`possible_statuses() <cerebro.aclasses.Task.possible_statuses>`.
"""
return py_cerebro_classes.statuses()
[документация] def type(status_flags):
"""
:param int status_flags: значение флагов статуса.
:returns: :py:const:`тип <cerebro.aclasses.Statuses.TYPE_>` статуса.
:rtype: int
Тип статуса означает в каком состоянии находится задача, когда ей установлен этот статус.
"""
type_status = Statuses.TYPE_IS_SUSPENDED
if cerebro.core.has_flag(status_flags, Statuses.FLAG_WORK_STARTED) == True:
type_status = Statuses.TYPE_IS_IN_PROGRESS
elif cerebro.core.has_flag(status_flags, Statuses.FLAG_WORK_STOPPED) == True:
type_status = Statuses.TYPE_IS_STOPPED
return type_status
[документация] def inheritable(status_flags):
"""
:param int status_flags: значение флагов статуса.
:returns: True, если :py:const:`флаг <cerebro.aclasses.Statuses.FLAG_>` установлен как наследуемый.
:rtype: bool
Наследуемый статус при установке на задачу-контейнер наследуется всеми подзадачами внутри этой задачи.
Пример выборки статусов, которые можно установить задачам-контейнерам::
inherit_statuses = list()
statuses = cerebro.core.statuses()
for status in statuses.data():
if cerebro.aclasses.Statuses.inheritable(status[statuses.DATA_FLAGS]) == True:
inherit_statuses.append(status)
"""
return cerebro.core.has_flag(status_flags, Statuses.FLAG_INHERITABLE)
[документация]class Activities:
"""
Класс видов деятельности.
.. rubric:: Методы
* :py:meth:`data() <cerebro.aclasses.Activities.data>`
::
activities = cerebro.core.activities()
"""
DATA_ = ''
"""
.. rubric:: Поля кортежа данных вида деятельности
"""
DATA_ID = 0
"""Идентификатор вида деятельности."""
DATA_NAME = 1
"""Имя вида деятельности."""
DATA_COLOR = 2
"""Цвет вида деятельности. Формат RGB представлен целым числом."""
def __init__(self):
pass
[документация] def data(self):
"""
:returns: список :py:const:`кортежей данных <cerebro.aclasses.Activities.DATA_>` по видам деятельности.
:rtype: list(tuple,)
"""
return py_cerebro_classes.activities()
[документация]class Task:
"""
Класс задачи.
.. rubric:: Методы
* :py:meth:`activity() <cerebro.aclasses.Task.activity>`
* :py:meth:`add_hashtags() <cerebro.aclasses.Task.add_hashtags>`
* :py:meth:`allocated() <cerebro.aclasses.Task.allocated>`
* :py:meth:`budget() <cerebro.aclasses.Task.budget>`
* :py:meth:`creation_time() <cerebro.aclasses.Task.creation_time>`
* :py:meth:`creator_id() <cerebro.aclasses.Task.creator_id>`
* :py:meth:`data() <cerebro.aclasses.Task.data>`
* :py:meth:`finish() <cerebro.aclasses.Task.finish>`
* :py:meth:`flags() <cerebro.aclasses.Task.flags>`
* :py:meth:`hashtags() <cerebro.aclasses.Task.hashtags>`
* :py:meth:`id() <cerebro.aclasses.Task.id>`
* :py:meth:`moderator_id() <cerebro.aclasses.Task.moderator_id>`
* :py:meth:`modification_time() <cerebro.aclasses.Task.modification_time>`
* :py:meth:`name() <cerebro.aclasses.Task.name>`
* :py:meth:`parent_id() <cerebro.aclasses.Task.parent_id>`
* :py:meth:`parent_url() <cerebro.aclasses.Task.parent_url>`
* :py:meth:`payments() <cerebro.aclasses.Task.payments>`
* :py:meth:`planned_time() <cerebro.aclasses.Task.planned_time>`
* :py:meth:`possible_statuses() <cerebro.aclasses.Task.possible_statuses>`
* :py:meth:`priority() <cerebro.aclasses.Task.priority>`
* :py:meth:`progress() <cerebro.aclasses.Task.progress>`
* :py:meth:`project_id() <cerebro.aclasses.Task.project_id>`
* :py:meth:`remove_allocated() <cerebro.aclasses.Task.remove_allocated>`
* :py:meth:`remove_hashtags() <cerebro.aclasses.Task.remove_hashtags>`
* :py:meth:`set_activity() <cerebro.aclasses.Task.set_activity>`
* :py:meth:`set_allocated() <cerebro.aclasses.Task.set_allocated>`
* :py:meth:`set_budget() <cerebro.aclasses.Task.set_budget>`
* :py:meth:`set_finish() <cerebro.aclasses.Task.set_finish>`
* :py:meth:`set_flag() <cerebro.aclasses.Task.set_flag>`
* :py:meth:`set_name() <cerebro.aclasses.Task.set_name>`
* :py:meth:`set_planned_time() <cerebro.aclasses.Task.set_planned_time>`
* :py:meth:`set_priority() <cerebro.aclasses.Task.set_priority>`
* :py:meth:`set_progress() <cerebro.aclasses.Task.set_progress>`
* :py:meth:`set_start() <cerebro.aclasses.Task.set_start>`
* :py:meth:`set_status() <cerebro.aclasses.Task.set_status>`
* :py:meth:`spent() <cerebro.aclasses.Task.spent>`
* :py:meth:`start() <cerebro.aclasses.Task.start>`
* :py:meth:`status() <cerebro.aclasses.Task.status>`
* :py:meth:`tags() <cerebro.aclasses.Task.tags>`
::
task = cerebro.core.current_task()
::
task = cerebro.core.task(task_id)
::
tasks = cerebro.core.selected_tasks(task_id)
"""
PRIORITY_ = ''
"""
.. rubric:: Значения приоритета
"""
PRIORITY_LOW = -2
"""Низкий."""
PRIORITY_BELOW_NORMAL = -1
"""Ниже нормального."""
PRIORITY_NORMAL = 0
"""Нормальный."""
PRIORITY_ABOVE_NORMAL = 1
"""Выше нормального."""
PRIORITY_HIGH = 2
"""Высокий."""
PRIORITY_CRITICAL = 3
"""Критичный."""
FLAG_ = ''
"""
.. rubric:: Флаги задачи
"""
FLAG_DELETED = 0
"""Задача удалена."""
FLAG_PERM_INHERIT_BLOCK = 1
"""У задачи сброшено наследование прав доступа."""
FLAG_CLOSED = 2
"""Задача закрыта."""
FLAG_TASK_AS_EVENT = 3
"""Задача помечена как событие."""
FLAG_SUSPENED = 4
"""Задача остановлена (на паузе)."""
FLAG_FORUM_LOCKED = 5
"""Форум задачи только для чтения."""
FLAG_CLOSED_EFFECTIVE = 30
"""Задача закрыта, поскольку закрыта задача более верхнего уровня."""
FLAG_SUSPENED_EFFECTIVE = 31
"""Задача остановлена, поскольку остановлена задача более верхнего уровня."""
FLAG_HAS_CHILD = 32
"""Задача имеет подзадачи."""
FLAG_HAS_MESSAGES = 33
"""Задача имеет сообщения в форуме."""
FLAG_NEED_ANSWER = 34
"""Задача требует ответа (в соответствии с правами доступа текущего пользователя)."""
FLAG_HAS_SUB_PERMS = 35
"""На задаче установленны собственные права доступа"""
FLAG_ASSIGNED = 38
"""Текуший пользователь является исполнителем на задаче."""
FLAG_INTEREST = 39
"""Текуший пользователь следит за задачей."""
FLAG_LAST_EV_CLIENT_VIS = 44
"""Последнее сообщение в задаче видимо для клиентов."""
FLAG_LAST_EV_APPROVED = 45
"""Последнее сообщение в задаче принято."""
FLAG_HAS_PLANNED = 56
"""Задача имеет собственное запланированное время."""
FLAG_HAS_PROGRESS = 59
"""Задача имеет собственный прогресс."""
FLAG_IS_REFERENCE = 61
"""Задача является ссылкой."""
FLAG_HAS_REFERENCE = 62
"""На задачу имеется одна или несколько ссылок."""
DATA_ = ''
"""
.. rubric:: Поля кортежа данных задачи
"""
DATA_MTM = 0
"""Время модификации данных. Тип datetime."""
DATA_ID = 1
"""Идентификатор задачи."""
DATA_PARENT_ID = 2
"""Идентификатор родительской задачи."""
DATA_NAME = 3
"""Имя задачи."""
DATA_PARENT_URL = 4
"""Полный путь до родителькой задачи. Пример: /Test project/Scene 1/."""
DATA_ACTIVITY_NAME = 5
"""Имя вида деятельности."""
DATA_ACTIVITY_ID = 6
"""Идентификатор вида деятельности."""
DATA_SELF_USERS_DECLARED = 7
"""Заявленное время пользователей по задаче в минутах. Тип float."""
DATA_SELF_USERS_APPROVED = 8
"""Принятое время пользователей по задаче в минутах. Тип float."""
DATA_CREATED = 9
"""Время создания задачи. Тип datetime."""
DATA_PRIORITY = 10
""":py:const:`Приоритет <cerebro.aclasses.Task.PRIORITY_>`."""
DATA_PROGRESS = 11
"""Прогресс. Тип float от 0.0 до 100.0."""
DATA_PLANNED = 12
"""Запланированное время на задачу в часах. Тип float."""
DATA_USERS_DECLARED = 13
"""Заявленное время пользователей по задаче и её подзадачам в часах. Тип float."""
DATA_USERS_APPROVED = 14
"""Принятое время пользователей по задаче и её подзадачам в часах. Тип float."""
DATA_THUMBS = 15
"""Хеши эскизов. Тип string. Разделитель ';'."""
DATA_FLAGS = 16
""":py:const:`Флаги задачи <cerebro.aclasses.Task.FLAG_>`."""
DATA_MODERATOR_ID = 17
"""Идентификатор пользователя, изменившего задачу."""
DATA_CREATOR_ID = 18
"""Идентификатор автора задачи."""
DATA_MODIFIED = 19
"""Время изменения задачи. Тип datetime."""
DATA_ALLOCATED = 20
"""Назначенные пользователи (исполнители) на задачу. Тип string. Разделитель ';'."""
DATA_OFFSET = 21
"""Рассчитанное время начала задачи в днях от 01.01.2000. Тип float."""
DATA_DURATION = 22
"""Рассчитанная длительность задачи в календарных днях. Тип float."""
DATA_PROJECT_ID = 23
"""Идентификатор проекта задачи."""
DATA_PRIVILEGE = 24
"""Права доступа текущего пользователя к задаче. Тип int."""
DATA_HUMAN_START = 25
"""Заданное время начала задачи в днях от 01.01.2000. Тип float."""
DATA_HUMAN_FINISH = 26
"""Заданное время окончания задачи в днях от 01.01.2000. Тип float."""
DATA_SELF_BUDGET = 27
"""Бюджет задачи."""
DATA_SELF_SPENT = 28
"""Затраты (сумма платежи) по задаче."""
DATA_BUDGET = 29
"""Бюджет задачи с её подзадачами."""
DATA_SPENT = 30
"""Затраты (сумма платежей) по задаче с её подзадачами."""
DATA_RESOURCE_SELF_DECLARED = 31
"""Заявленное время материальных ресурсов по задаче в минутах. Тип float."""
DATA_RESOURCE_SELF_APPROVED = 32
"""Принятое время материальных ресурсов по задаче в минутах. Тип float."""
DATA_RESOURCE_DECLARED = 33
"""Заявленное время материальных ресурсов по задаче с её подзадачами в часах. Тип float."""
DATA_RESOURCE_APPROVED = 34
"""Принятое время материальных ресурсов по задаче с её подзадачами в часах. Тип float."""
DATA_STATUS_ID = 35
"""Идентификатор статуса."""
PAYMENT_ = ''
"""
.. rubric:: Поля кортежа данных платежа
"""
PAYMENT_MTM = 0
"""Время модификации данных. Тип datetime."""
PAYMENT_USER_ID = 1
"""Идентификатор пользователя, совершившего платеж."""
PAYMENT_ID = 2
"""Идентификатор платежа."""
PAYMENT_TASK_ID = 3
"""Идентификатор задачи."""
PAYMENT_FLAGS = 4
""":py:const:`Флаги платежа <cerebro.aclasses.Task.PAYMENT__FLAG_>`."""
PAYMENT_MONEY = 5
"""Сумма платежа в условных единицах."""
PAYMENT_RECORD_TIME = 6
"""Время записи о платеже. Тип datetime."""
PAYMENT_COMMENT = 7
"""Текстовый комментарий к платежу."""
PAYMENT__FLAG_ = ''
"""
.. rubric:: Флаги платежа
"""
PAYMENT__FLAG_CANCEL = 1
"""Платеж отменен."""
ALLOCATED_ = ''
"""
.. rubric:: Поля кортежа данных назначенного пользователя (исполнителя)
"""
ALLOCATED_ID = 0
"""Идентификатор пользователя."""
ALLOCATED_NAME = 1
"""Полное имя пользователя."""
ALLOCATED_FLAGS = 2
"""Флаги пользователя. :py:const:`Флаги пользователя <cerebro.aclasses.Users.FLAG_>` описаны в классе :py:class:`cerebro.aclasses.Users`."""
def __init__(self, task_id):
self.__task_id = task_id
[документация] def id(self):
"""
:returns: идентификатор задачи.
:rtype: int
(parameter_1, parameter_2)
"""
return self.__task_id
[документация] def parent_id(self):
"""
:returns: идентификатор родительской задачи.
:rtype: int
"""
return py_cerebro_classes.task_data(self.__task_id)[Task.DATA_PARENT_ID]
[документация] def project_id(self):
"""
:returns: идентификатор проекта задачи.
:rtype: int
"""
return py_cerebro_classes.task_data(self.__task_id)[Task.DATA_PROJECT_ID]
[документация] def name(self):
"""
:returns: имя задачи.
:rtype: string
.. seealso:: :py:meth:`set_name() <cerebro.aclasses.Task.set_name>`.
"""
return py_cerebro_classes.task_data(self.__task_id)[Task.DATA_NAME]
[документация] def parent_url(self):
"""
:returns: полный путь до родителькой задачи. Пример: '/Test project/Scene 1/'.
:rtype: string
"""
return py_cerebro_classes.task_data(self.__task_id)[Task.DATA_PARENT_URL]
[документация] def priority(self):
"""
:returns: :py:const:`приоритет <cerebro.aclasses.Task.PRIORITY_>` задачи.
:rtype: int
::
if task.priority() == task.PRIORITY_CRITICAL:
cerebro.core.print_warning('Задача критичного приоритета', task.name())
.. seealso:: :py:meth:`set_priority() <cerebro.aclasses.Task.set_priority>`.
"""
return py_cerebro_classes.task_data(self.__task_id)[Task.DATA_PRIORITY]
[документация] def activity(self):
"""
:returns: вид деятельности задачи.
'(0,'')' означает, что вид деятельности задачи не задан.
:rtype: tuple(activity_id, activity_name) - кортеж из двух полей:
идентификатор вида деятельности, имя вида деятельности.
.. seealso:: :py:meth:`set_activity() <cerebro.aclasses.Task.set_activity>`.
"""
data = py_cerebro_classes.task_data(self.__task_id)
act = (data[Task.DATA_ACTIVITY_ID], data[Task.DATA_ACTIVITY_NAME])
return act
[документация] def creation_time(self):
"""
:returns: время создания задачи.
:rtype: datetime
"""
return py_cerebro_classes.task_data(self.__task_id)[Task.DATA_CREATED]
[документация] def modification_time(self):
"""
:returns: время изменения задачи.
:rtype: datetime
"""
return py_cerebro_classes.task_data(self.__task_id)[Task.DATA_MODIFIED]
[документация] def creator_id(self):
"""
:returns: идентификатор автора задачи.
:rtype: int
"""
return py_cerebro_classes.task_data(self.__task_id)[Task.DATA_CREATOR_ID]
[документация] def moderator_id(self):
"""
:returns: идентификатор пользователя, изменившего задачу.
:rtype: int
"""
return py_cerebro_classes.task_data(self.__task_id)[Task.DATA_MODERATOR_ID]
[документация] def flags(self):
"""
:returns: :py:const:`флаги <cerebro.aclasses.Task.FLAG_>` задачи.
:rtype: int
::
if cerebro.core.has_flag(task.flags(), task.FLAG_FORUM_LOCKED): # проверка на залоченый форум задачи
return
.. seealso:: :py:meth:`set_flag() <cerebro.aclasses.Task.set_flag>`.
"""
return py_cerebro_classes.task_data(self.__task_id)[Task.DATA_FLAGS]
[документация] def progress(self):
"""
:returns: прогресс задачи от 0.0 до 100.0.
:rtype: float
.. seealso:: :py:meth:`set_progress() <cerebro.aclasses.Task.set_progress>`.
"""
return py_cerebro_classes.task_data(self.__task_id)[Task.DATA_PROGRESS]
[документация] def planned_time(self):
"""
:returns: запланированное время на задачу в часах.
:rtype: float
.. seealso:: :py:meth:`set_planned_time() <cerebro.aclasses.Task.set_planned_time>`.
"""
return py_cerebro_classes.task_data(self.__task_id)[Task.DATA_PLANNED]
[документация] def start(self):
"""
:returns: время начала задачи.
:rtype: datetime
.. seealso:: :py:meth:`set_start() <cerebro.aclasses.Task.set_start>`.
"""
return py_cerebro_classes.task_start(self.__task_id)
[документация] def finish(self):
"""
:returns: время окончания задачи.
:rtype: datetime
.. seealso:: :py:meth:`set_finish() <cerebro.aclasses.Task.set_finish>`.
"""
return py_cerebro_classes.task_stop(self.__task_id)
[документация] def budget(self):
"""
:returns: бюджет задачи в условных единицах.
:rtype: float
.. seealso:: :py:meth:`set_budget() <cerebro.aclasses.Task.set_budget>`.
"""
return py_cerebro_classes.task_data(self.__task_id)[Task.DATA_BUDGET]
[документация] def spent(self):
"""
:returns: сумму расходов (платежей) на задачу.
:rtype: float
"""
return py_cerebro_classes.task_data(self.__task_id)[Task.DATA_SPENT]
[документация] def payments(self):
"""
:returns: список :py:const:`кортежей данных по платежам <cerebro.aclasses.Task.PAYMENT_>` задачи.
:rtype: list(tuple,)
Пример проверки на отмененные платежи::
for pay in task.payments():
if pay[task.PAYMENT_MONEY] > 1000 and cerebro.core.has_flag(pay[task.PAYMENT_FLAGS], task.PAYMENT__FLAG_CANCEL)==True:
cerebro.core.print_warning('Платеж по задаче больше 1000 бфл отменен', task.name())
"""
return py_cerebro_classes.task_payments(self.__task_id)
[документация] def allocated(self):
"""
:returns: список :py:const:`кортежей данных по аллоцированным пользователям (исполнителям) <cerebro.aclasses.Task.ALLOCATED_>` на задачу.
:rtype: list(tuple,)
Пример определения аллоцированного материального ресурса на задачу::
for user in task.allocated():
if cerebro.aclasses.Users.is_resource(user[task.ALLOCATED_FLAGS]) == True:
print('На задачу назначен ресурс', user[task.ALLOCATED_NAME])
.. seealso:: :py:meth:`set_allocated() <cerebro.aclasses.Task.set_allocated>`,
:py:meth:`remove_allocated() <cerebro.aclasses.Task.remove_allocated>`.
"""
return py_cerebro_classes.task_allocated(self.__task_id)
[документация] def status(self):
"""
:returns: статус задачи.
'(0,'')' означает, что статус задачи не задан.
:rtype: tuple(status_id, status_name) - кортеж из двух полей:
идентификатор статуса, имя статуса.
.. seealso:: :py:meth:`set_status() <cerebro.aclasses.Task.set_status>`,
:py:meth:`possible_statuses() <cerebro.aclasses.Task.possible_statuses>`.
"""
return py_cerebro_classes.task_status(self.__task_id)
[документация] def set_status(self, status_id):
"""
:param int status_id: идентификатор статуса.
Устанавливает статус задачи. '0' переводит статус задачи в 'Нет статуса'.
Пример установки статуса closed:
::
statuses = cerebro.core.statuses()
for status in statuses.data():
if status[statuses.DATA_NAME] == 'closed':
task.set_status(status[statuses.DATA_ID])
break
.. seealso:: :py:meth:`status() <cerebro.aclasses.Task.status>`,
:py:meth:`possible_statuses() <cerebro.aclasses.Task.possible_statuses>`.
"""
py_cerebro_classes.task_set_status(self.__task_id, status_id)
[документация] def possible_statuses(self):
"""
:returns: список :py:const:`кортежей данных по статусам <cerebro.aclasses.Statuses.DATA_>`, которые можно установить задаче.
:rtype: list(tuple,)
В системе Cerebro для каждого статуса настраиваются разрешения на переключение для каждого статуса.
Кроме того, у каждого статуса есть флаг наследственности.
На задачи-контейнеры можно устанавливать только те статусы, у которых включен этот флаг.
Поэтому список возможных статусов зависит от прав пользователя, текущего статуса,
а так же наличия/отсутсвия подзадач у задачи.
Пример определения возможности установить задаче статус completed:
::
possible_statuses = task.possible_statuses()
for status in possible_statuses:
if status[cerebro.aclasses.Statuses.DATA_NAME] == 'completed':
task.set_status(status[cerebro.aclasses.Statuses.DATA_ID])
break
.. seealso:: :py:meth:`status() <cerebro.aclasses.Task.status>`,
:py:meth:`set_status() <cerebro.aclasses.Task.set_status>`,
:py:class:`cerebro.aclasses.Statuses`.
"""
return py_cerebro_classes.task_possible_statuses(self.__task_id)
[документация] def data(self):
"""
:returns: :py:const:`кортеж данных по задаче <cerebro.aclasses.Task.DATA_>`.
:rtype: tuple
По сути, большинство методов данного класса являются обёртками к этому кортежу.
Поэтому вы можете пользоваться напрямую данными из него.
::
task.creator_id() == task.data()[task.DATA_CREATOR_ID]
task.priority() == task.data()[task.DATA_PRIORITY]
# и так далее
"""
return py_cerebro_classes.task_data(self.__task_id)
[документация] def set_name(self, name):
"""
:param string name: имя задачи.
Устанавливает новое имя задаче.
.. warning::
Задача не может содержать в имени следующие символы \ / # : ? & ' " , + |
.. seealso:: :py:meth:`name() <cerebro.aclasses.Task.name>`.
"""
py_cerebro_classes.task_set_name(self.__task_id, name)
[документация] def set_activity(self, activity_id):
"""
:param int activity_id: идентификатор вида деятельности.
Устанавливает вид деятельности задачи. '0' переводит вид деятельности задачи в 'Нет вида деятельности'.
Пример установки вида деятельности 'animation'::
activities = cerebro.core.activities()
for activity in activities.data():
if activity[activities.DATA_NAME] == 'animation':
task.set_activity(activity[activities.DATA_ID])
break
.. seealso:: :py:meth:`activity() <cerebro.aclasses.Task.activity>`.
"""
py_cerebro_classes.task_set_activity(self.__task_id, activity_id)
[документация] def set_priority(self, prior):
"""
:param int prior: приоритет задачи.
Устанавливает :py:const:`приоритет <cerebro.aclasses.Task.PRIORITY_>` задачи.
::
task.set_priority(task.PRIORITY_HIGHT)
.. seealso:: :py:meth:`priority() <cerebro.aclasses.Task.priority>`.
"""
py_cerebro_classes.task_set_priority(self.__task_id, prior)
[документация] def set_flag(self, flag, is_set):
"""
:param int flag: :py:const:`флаг <cerebro.aclasses.Task.FLAG_>` задачи.
:param bool is_set: выбор действия.
Устанавливает :py:const:`флаг <cerebro.aclasses.Task.FLAG_>` у задачи.
Если аргумент is_set равен True флаг устанавливается, иначе сбрасывается.
::
# Установка задачи в статус Закрыта
task.set_flag(task.FLAG_CLOSED, True)
.. seealso:: :py:meth:`flags() <cerebro.aclasses.Task.flags>`.
"""
py_cerebro_classes.task_set_flag(self.__task_id, flag, is_set)
[документация] def set_progress(self, progress):
"""
:param float progress: прогресс задачи от 0.0 до 100.0.
Устанавливает прогресс задачи.
При установке прогреса в 100, задача считается Выполненой(Done).
Значение None сбрасывает собственный прогресс задачи.
После сброса прогресс расчитывается из подзадач.
.. seealso:: :py:meth:`progress() <cerebro.aclasses.Task.progress>`.
"""
if progress == None:
py_cerebro_classes.task_set_progress(self.__task_id, -2)
else:
py_cerebro_classes.task_set_progress(self.__task_id, progress)
[документация] def set_planned_time(self, hours):
"""
:param float hours: запланированные на задачу часы.
Устанавливает запланированное время задачи в часах.
Значение None сбрасывает запланированное время задачи.
После сброса запланированное время расчитывается исходя из календарных сроков задачи и расписания.
.. seealso:: :py:meth:`planned_time() <cerebro.aclasses.Task.planned_time>`.
"""
if hours == None:
py_cerebro_classes.task_set_planned_time(self.__task_id, -2)
else:
py_cerebro_classes.task_set_planned_time(self.__task_id, hours)
[документация] def set_start(self, time):
"""
:param float time: время в днях от 01.01.2000.
Устанавливает время начала задачи в днях от 01.01.2000 в UTC.
::
task.set_start(4506.375) # время старта 03.05.2012 9:00 UTC
Значение None сбрасывает установленное время начала задачи.
После сброса время начала расчитывается исходя из связей задачи и расписания.
Пример установки времени начала задачи в текущее::
import datetime
datetime_now = datetime.datetime.utcnow()
datetime_2000 = datetime.datetime(2000, 1, 1)
timedelta = datetime_now - datetime_2000
days = timedelta.total_seconds()/(24*60*60)
task.set_start(days)
.. seealso:: :py:meth:`start() <cerebro.aclasses.Task.start>`.
"""
if time == None:
py_cerebro_classes.task_set_start(self.__task_id, -2)
else:
py_cerebro_classes.task_set_start(self.__task_id, time)
[документация] def set_finish(self, time):
"""
:param float time: время в днях от 01.01.2000.
Устанавливает время окончания задачи в днях от 01.01.2000 в UTC.
::
task.set_finish(4506.75) # время окончания 03.05.2012 18:00 UTC
Значение None сбрасывает установленное время окончания задачи.
После сброса время окончания расчитывается исходя из запланированного времени на задачу и расписания.
Пример установки времени окончания задачи через 3 дня от текущего::
import datetime
datetime_now = datetime.datetime.utcnow()
datetime_2000 = datetime.datetime(2000, 1, 1)
timedelta = datetime_now - datetime_2000
days = timedelta.total_seconds()/(24*60*60) + 3
task.set_finish(days)
.. seealso:: :py:meth:`finish() <cerebro.aclasses.Task.finish>`.
"""
if time == None:
py_cerebro_classes.task_set_finish(self.__task_id, -2)
else:
py_cerebro_classes.task_set_finish(self.__task_id, time)
[документация] def set_budget(self, budget):
"""
:param float budget: в условных единицах.
Устанавливает бюджет.
Значение None сбрасывает собственный бюджет задачи.
После сброса бюджет расчитывается из подзадач.
.. seealso:: :py:meth:`budget() <cerebro.aclasses.Task.budget>`.
"""
if budget == None:
py_cerebro_classes.task_drop_budget(self.__task_id)
else:
py_cerebro_classes.task_set_budget(self.__task_id, budget)
[документация] def set_allocated(self, user_id):
"""
:param int user_id: идентификатор пользователя.
Назначает исполнителя на задачу.
Пример назначения на задачу всех пользователей, кроме материальных ресурсов::
users = cerebro.core.users()
for user in users.data():
if cerebro.aclasses.Users.is_resource(user[users.DATA_FLAGS]) != True:
task.set_allocated(user[users.DATA_ID])
.. seealso:: :py:meth:`allocated() <cerebro.aclasses.Task.allocated>`,
:py:meth:`remove_allocated() <cerebro.aclasses.Task.remove_allocated>`.
"""
py_cerebro_classes.task_set_allocated(self.__task_id, user_id)
[документация] def remove_allocated(self, user_id):
"""
:param int user_id: идентификатор пользователя.
Убирает исполнителя с задачи.
Пример удаления материальных ресурсов с задачи::
allocated = task.allocated()
for user in allocated:
if cerebro.aclasses.Users.is_resource(user[task.ALLOCATED_FLAGS]) == True:
task.remove_allocated(user[task.ALLOCATED_ID])
.. seealso:: :py:meth:`set_allocated() <cerebro.aclasses.Task.set_allocated>`,
:py:meth:`allocated() <cerebro.aclasses.Task.allocated>`.
"""
py_cerebro_classes.task_remove_allocated(self.__task_id, user_id)
[документация]class Perm:
"""
Класс прав доступа.
Для тех или иных операций с объектами в системе Cerebro,
будь то создание, редактирование свойств задачи или сообщения, создание проектов или пользователей,
требуются права доступа.
Здась описаны типы операций требующие разрешения.
Для проверки разрешений воспользуйтесь функциями модуля :py:mod:`cerebro.core`:
* :py:func:`cerebro.core.has_perm_global`
* :py:func:`cerebro.core.has_perm_message`
* :py:func:`cerebro.core.has_perm_task`
"""
PERM_TASK_ = ''
"""
.. rubric:: Права доступа к задаче
"""
PERM_TASK_MANAGMENT = 6
"""Управление задачами. Позволяет удалять и создавать задачи."""
PERM_TASK_PROPERTIES = 8
"""Редактирование свойств задачи. Позволяет редактировать почти все свойства задачи, кроме тегов и бюджета."""
PERM_TASK_TAG = 14
"""Редактирование тегов задачи. Позволяет редактировать теги задачи."""
PERM_TASK_BUDGET = 30
"""Редактирование бюджета задачи. Позволяет редактировать бюджет задачи."""
PERM_TASK_PROGRESS = 32
"""Редактирование прогресса задачи. Позволяет редактировать прогресс задачи но не позволяет его выставить в 100%."""
PERM_TASK_CREATE_DEFINITION = 18
"""Создание постановки задачи. Позволяет создавать сообщения типа 'Постановка задачи'."""
PERM_TASK_CREATE_REVIEW = 22
"""Создание рецензии. Позволяет создавать сообщения типа 'Рецензия."""
PERM_TASK_CREATE_REPORT = 20
"""Создание отчета. Позволяет создавать сообщения типа 'Отчет' и 'Отчет за ресурс'."""
PERM_TASK_CREATE_NOTE = 24
"""Создание заметки. Позволяет создавать сообщения типа 'Заметка'."""
PERM_TASK_CREATE_CLIENT_REVIEW = 26
"""Создание рецензии клиента. Позволяет создавать сообщения типа 'Рецензия клиента'."""
PERM_TASK_MESSAGES_PROPERTIES = 16
"""Редактирование свойств сообщения. Позволяет редактировать такие свойства сообщений, как 'Видимость для клиента' и 'Подтветждение отчета'."""
PERM_TASK_LAST_MESSAGE = 34
"""Редактирование последнего сообщения. Позволяет редактировать сообщения других пользователей, если на них еще нет ответа."""
PERM_TASK_ANY_MESSAGE = 10
"""Редактирование любого сообщения. Позволяет редактировать сообщения других пользователей, даже если на них уже есть ответ."""
PERM_MESSAGE_ = ''
"""
.. rubric:: Права доступа к сообщению
"""
PERM_MESSAGE_EDITABLE = 3
"""Позволяет редактировать текст и вложения сообщения. А также удалить сообщение."""
PERM_MESSAGE_PROPERTIES = 16
"""Позволяет редактировать такие свойства сообщения, как 'Видимость для клиента' и 'Подтветждение отчета'."""
PERM_GLOBAL_ = ''
"""
.. rubric:: Глобальные права доступа
"""
PERM_GLOBAL_USERS = 62
"""Управление пользователями. Позволяет создавать пользователей, группы, роли и настраивать видимость людей друг друга."""
PERM_GLOBAL_MATERIAL_RESOURCES = 56
"""Управление материальными ресурсами. Позволяет создавать и удалять материальные ресурсы."""
PERM_GLOBAL_SALARIES_AND_WORKING_SCHEDULES = 59
"""Управление зарплатой и рабочими расписаниями. Позволяет задавать пользователям ставку и рабочие расписания."""
PERM_GLOBAL_TAGS_AND_ACTIVITIES = 61
"""Управление тегами и видами деятельности. Позволяет создавать и удалять теги и виды деятельности."""
PERM_GLOBAL_FILE_STORAGES = 60
"""Управление файловыми хранилищами. Позволяет задавать возможные файловые хранилища."""
def __init__(self):
pass