def get_entity(self):
"""returns one Structure instance data as JSON
"""
response = super(StructureViews, self).get_entity()
from stalker import Structure
from stalker.db.session import DBSession
r = DBSession.query(Structure.custom_template)\
.filter(Structure.id == self.entity_id)\
.first()
# get template counts
from stalker.models.structure import Structure_FilenameTemplates
template_count = \
DBSession.query(
Structure_FilenameTemplates.c.filenametemplate_id
).filter(
Structure_FilenameTemplates.c.structure_id == self.entity_id
).count()
from stalker_pyramid import entity_type_to_url
data = {
'custom_template': r[0],
'templates': {
'$ref': '%s/%s/templates' %
(entity_type_to_url['Structure'], self.entity_id),
'length': template_count
}
}
return self.update_response_data(response, data)
def get_entity(self):
"""return one StatusList instance as json
"""
sql = """select
"StatusLists".target_entity_type
from "StatusLists"
where "StatusLists".id = :id
"""
from sqlalchemy import text
from stalker.db.session import DBSession
conn = DBSession.connection()
result = conn.execute(text(sql), id=self.entity_id)
r = result.fetchone()
# get statuses count
from stalker.models.status import StatusList_Statuses
statuses_count = DBSession.query(StatusList_Statuses.c.status_id)\
.filter(StatusList_Statuses.c.status_list_id == self.entity_id)\
.count()
from stalker_pyramid import entity_type_to_url
data = {
'statuses': {
'$ref':
'%s/%s/statuses' %
(entity_type_to_url['StatusList'], self.entity_id),
'length':
statuses_count
},
'target_entity_type': r[0]
}
# update with super data
response = super(StatusListViews, self).get_entity()
return self.update_response_data(response, data)
def get_filtered_entities(self):
"""returns the filtered entities according to the filter selection
"""
project_id = self.get_project_id()
entity_type = self.filter_by_entity_type_combo_box.currentText()
sequence_id = self.get_sequence_id()
task_type_id = self.get_task_type_id()
resource_id = self.get_resource_id()
from stalker import db, Task
from stalker.db.session import DBSession
query = DBSession.query(Task.id, Task.name)
if project_id != -1:
query = query.filter(Task.project_id == project_id)
if task_type_id != -1:
query = query.filter(Task.type_id == task_type_id)
if entity_type != self.generic_selection_text:
query = query.filter(Task.entity_type == entity_type)
# if entity_type == 'Shot':
# from stalker.models.shot import Shot_Sequences
# query = query.filter(Shot_Sequences)
# query the child tasks
query = query.order_by(Task.name)
return query.all()
def get_filtered_entities(self):
"""returns the filtered entities according to the filter selection
"""
project_id = self.get_project_id()
entity_type = self.filter_by_entity_type_combo_box.currentText()
sequence_id = self.get_sequence_id()
task_type_id = self.get_task_type_id()
resource_id = self.get_resource_id()
from stalker import db, Task
from stalker.db.session import DBSession
query = DBSession.query(Task.id, Task.name)
if project_id != -1:
query = query.filter(Task.project_id == project_id)
if task_type_id != -1:
query = query.filter(Task.type_id == task_type_id)
if entity_type != self.generic_selection_text:
query = query.filter(Task.entity_type == entity_type)
# if entity_type == 'Shot':
# from stalker.models.shot import Shot_Sequences
# query = query.filter(Shot_Sequences)
# query the child tasks
query = query.order_by(Task.name)
return query.all()
def _fill_task_type_widget(self):
"""fills the task type widget
"""
if self.task is None:
return
# get the types
from stalker import Type
from stalker.db.session import DBSession
all_types = \
DBSession.query(Type.id, Type.name)\
.filter(Type.target_entity_type == self.task.entity_type)\
.all()
self.type_field_is_updating = True
self.type_field.clear()
self.type_field.addItem('-- No Type --', -1)
for type_data in all_types:
self.type_field.addItem(type_data.name, type_data.id)
# and select the corresponding type
if self.task.type:
index = self.type_field.findData(self.task.type.id)
if index != -1:
self.type_field.setCurrentIndex(index)
self.type_field_is_updating = False
def list_all(self):
"""lists other representations
"""
base_take_name = self.get_base_take_name(self.version)
# find any version that starts with the base_repr_name
# under the same task
from stalker import Version
from stalker.db.session import DBSession
from sqlalchemy import distinct
take_names = map(
lambda x: x[0],
DBSession.query(distinct(Version.take_name))
.filter(Version.task == self.version.task)
.all()
)
take_names.sort()
repr_names = []
for take_name in take_names:
if take_name.startswith(base_take_name):
if take_name != base_take_name:
repr_names.append(
take_name[len(base_take_name) +
len(self.repr_separator):]
)
else:
repr_names.append(self.base_repr_name)
return repr_names
def project_changed(self, project_name):
"""runs when the project in the combo box changed
"""
try:
project_id = self.projects_combo_box.currentData()
except AttributeError:
index = self.projects_combo_box.currentIndex()
project_id = self.projects_combo_box.itemData(index)
# refresh the items on the double list widget
self.users_double_list_widget.clear()
# get users not in the project
from stalker.db.session import DBSession
from stalker import User
from stalker.models.project import ProjectUser
project_users = DBSession.query(User.id, User.name).join(ProjectUser)\
.filter(ProjectUser.project_id == project_id)\
.filter(User.id == ProjectUser.user_id)\
.all()
project_user_ids = [u.id for u in project_users]
if project_user_ids:
users_not_in_project = [
u.name
for u in DBSession.query(User.name)
.filter(~User.id.in_(project_user_ids)).all()
]
else:
users_not_in_project = [
u.name
for u in DBSession.query(User.name).all()
]
self.users_double_list_widget.add_primary_items(
users_not_in_project
)
users_in_project = \
[u.name for u in project_users]
self.users_double_list_widget.add_secondary_items(
users_in_project
)
def _set_defaults(self):
"""setup the default values
"""
# set size policies
# self.name_lineEdit
self.type_comboBox.setSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Fixed)
self.status_comboBox.setSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Fixed)
self.client_comboBox.setSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Fixed)
self.agency_comboBox.setSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Fixed)
self.production_company_comboBox.setSizePolicy(
QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
# invalidate the name and code fields by default
self.name_lineEdit.set_invalid('Enter a name')
self.code_lineEdit.set_invalid('Enter a code')
# update type field
from stalker import Type
from stalker.db.session import DBSession
project_types = \
DBSession.query(Type.id, Type.name)\
.filter(Type.target_entity_type == 'Project')\
.order_by(Type.name)\
.all()
self.type_comboBox.clear()
self.type_comboBox.addItem('', -1)
for type_id, type_name in project_types:
self.type_comboBox.addItem(type_name, type_id)
self.image_format.fill_combo_box()
self.fill_repository_combo_box()
self.fill_structure_combo_box()
# fill status field
sql = """select
"SimpleEntities".id,
"SimpleEntities".name
from "Statuses"
join "SimpleEntities" on "Statuses".id = "SimpleEntities".id
join "StatusList_Statuses" on "Statuses".id = "StatusList_Statuses".status_id
join "StatusLists" on "StatusLists".id = "StatusList_Statuses".status_list_id
where "StatusLists".target_entity_type = 'Project'"""
all_project_statuses = \
DBSession.connection().execute(sql).fetchall()
for st_id, st_name in all_project_statuses:
self.status_comboBox.addItem(st_name, st_id)
def get_current_resource_id(self):
"""returns the current resource
"""
resource_name = self.resource_combo_box.currentText()
from stalker import User
from stalker.db.session import DBSession
return DBSession.query(User.id)\
.filter(User.name == resource_name)\
.first()
def get_entity(self):
"""returns one Entity instance
"""
sql = """
select
"Entities".id
from "Entities"
where "Entities".id = :id
"""
from stalker.db.session import DBSession
conn = DBSession.connection()
from sqlalchemy import text
result = conn.execute(text(sql), id=self.entity_id)
r = result.fetchone()
# get notes count
from stalker.models.entity import Entity_Notes
notes_count = DBSession.query(Entity_Notes.c.entity_id)\
.filter(Entity_Notes.c.entity_id == self.entity_id)\
.count()
# get tags count
from stalker.models.entity import Entity_Tags
tags_count = DBSession.query(Entity_Tags.c.entity_id)\
.filter(Entity_Tags.c.entity_id == self.entity_id)\
.count()
from stalker_pyramid import entity_type_to_url
data = {
'id': r[0],
'notes': {
'$ref': '%s/%s/notes' % (entity_type_to_url['Entity'], r[0]),
'length': notes_count
},
'tags': {
'$ref': '%s/%s/tags' % (entity_type_to_url['Entity'], r[0]),
'length': tags_count
},
}
# update with super data
response = super(EntityViews, self).get_entity()
return self.update_response_data(response, data)
def user_names_lut(self):
"""fills the _user_names_lut
"""
if not self._user_names_lut:
from anima.utils import do_db_setup
do_db_setup()
from stalker import User
from stalker.db.session import DBSession
map(lambda x: self._user_names_lut.__setitem__(x[0], x[1]),
DBSession.query(User.id, User.name).all())
return self._user_names_lut
def get_entity(self):
"""returns the DAGMixin portion of this mixed in class
"""
from stalker.db.session import DBSession
parent_id = DBSession.query(self.som_class.parent_id,)\
.filter(self.som_class.id == self.entity_id).first()
parent_data = []
if parent_id:
from stalker import SimpleEntity
parent_data = DBSession.query(
SimpleEntity.id, SimpleEntity.name,
SimpleEntity.entity_type).filter(
SimpleEntity.id == parent_id[0]).first()
children_count = DBSession.query(
self.som_class.children
).filter(self.som_class.id == self.entity_id)\
.count()
from stalker_pyramid import entity_type_to_url
data = {
'parent': {
'id':
parent_data[0],
'name':
parent_data[1],
'entity_type':
parent_data[2],
'$ref':
'%s/%s' % (entity_type_to_url[parent_data[2]], parent_data[0])
} if parent_data else None,
'children': {
'%ref': '%s/%s/children',
'length': children_count
}
}
return data
def user_names_lut(self):
"""fills the _user_names_lut
"""
if not self._user_names_lut:
from anima.utils import do_db_setup
do_db_setup()
from stalker import User
from stalker.db.session import DBSession
for result in DBSession.query(User.id, User.name).all():
self._user_names_lut.__setitem__(result.id, result.name)
return self._user_names_lut
def project_changed(self, project_name):
"""runs when the project in the combo box changed
"""
try:
project_id = self.projects_combo_box.currentData()
except AttributeError:
index = self.projects_combo_box.currentIndex()
project_id = self.projects_combo_box.itemData(index)
# refresh the items on the double list widget
self.users_double_list_widget.clear()
# get users not in the project
from stalker.db.session import DBSession
from stalker import User
from stalker.models.project import ProjectUser
project_users = DBSession.query(User.id, User.name).join(ProjectUser)\
.filter(ProjectUser.project_id == project_id)\
.filter(User.id == ProjectUser.user_id)\
.all()
project_user_ids = [u.id for u in project_users]
if project_user_ids:
users_not_in_project = [
u.name for u in DBSession.query(User.name).filter(
~User.id.in_(project_user_ids)).all()
]
else:
users_not_in_project = [
u.name for u in DBSession.query(User.name).all()
]
self.users_double_list_widget.add_primary_items(users_not_in_project)
users_in_project = \
[u.name for u in project_users]
self.users_double_list_widget.add_secondary_items(users_in_project)
def update_defaults_with_studio():
"""updates the default values from Studio instance if a database and a
Studio instance is present
"""
from stalker.db.session import DBSession
if DBSession:
with DBSession.no_autoflush:
from stalker.models.studio import Studio
# studio = Studio.query.first()
studio = DBSession.query(Studio).first()
if studio:
logger.debug('found a studio, updating defaults')
studio.update_defaults()
def user_names_lut(self):
"""fills the _user_names_lut
"""
if not self._user_names_lut:
from anima.utils import do_db_setup
do_db_setup()
from stalker import User
from stalker.db.session import DBSession
map(
lambda x: self._user_names_lut.__setitem__(x[0], x[1]),
DBSession.query(User.id, User.name).all()
)
return self._user_names_lut
def get_entity(self):
"""returns one Task instance data
"""
response = super(TaskViews, self).get_entity()
# add the others
# StatusMixinViews, DateRangeMixinViews,
# ReferenceMixinViews, ScheduleMixinViews, DAGMixinViews
response = self.update_response_data(response,
StatusMixinViews.get_entity(self))
response = self.update_response_data(
response, DateRangeMixinViews.get_entity(self))
response = self.update_response_data(
response, ReferenceMixinViews.get_entity(self))
response = self.update_response_data(
response, ScheduleMixinViews.get_entity(self))
response = self.update_response_data(response,
DAGMixinViews.get_entity(self))
from stalker import Task
from stalker.db.session import DBSession
r = DBSession.query(
Task.allocation_strategy,
Task.bid_timing,
Task.bid_unit,
Task.is_milestone,
Task.persistent_allocation,
Task.priority,
Task.schedule_constraint,
Task.schedule_model,
Task.schedule_timing,
Task.schedule_unit,
).filter(Task.id == self.entity_id).first()
data = {
'allocation_strategy': r[0],
'bid_timing': r[1],
'bid_unit': r[2],
'is_milestone': r[3],
'persistent_allocation': r[4],
'priority': r[5],
'schedule_constraint': r[6],
'schedule_model': r[7],
'schedule_timing': r[8],
'schedule_unit': r[9]
}
return self.update_response_data(response, data)
def fill(self):
"""fills the tree view with data
"""
logger.debug('start filling tasks_treeView')
logger.debug('creating a new model')
if not self.project:
from sqlalchemy import alias
from stalker import Task, Project
from stalker.db.session import DBSession
# projects = Project.query.order_by(Project.name).all()
inner_tasks = alias(Task.__table__)
subquery = DBSession.query(inner_tasks.c.id).filter(
inner_tasks.c.project_id == Project.id)
query = DBSession\
.query(
Project.id, Project.name, Project.entity_type,
Project.status_id,
subquery.exists().label('has_children')
)
if not self.show_completed_projects:
from stalker import Status
status_cmpl = \
Status.query.filter(Status.code == 'CMPL').first()
query = query.filter(Project.status != status_cmpl)
query = query.order_by(Project.name)
projects = query.all()
else:
self.project.has_children = bool(self.project.tasks)
projects = [self.project]
logger.debug('projects: %s' % projects)
# delete the old model if any
if self.model() is not None:
self.model().deleteLater()
task_tree_model = TaskTreeModel()
task_tree_model.populateTree(projects)
self.setModel(task_tree_model)
self.is_updating = False
self.auto_fit_column()
logger.debug('finished filling tasks_treeView')
def fill(self):
"""fills the tree view with data
"""
logger.debug('start filling tasks_treeView')
logger.debug('creating a new model')
if not self.project:
from sqlalchemy import alias
from stalker import Task, Project
from stalker.db.session import DBSession
# projects = Project.query.order_by(Project.name).all()
inner_tasks = alias(Task.__table__)
subquery = DBSession.query(inner_tasks.c.id).filter(
inner_tasks.c.project_id == Project.id)
query = DBSession\
.query(
Project.id, Project.name, Project.entity_type,
Project.status_id,
subquery.exists().label('has_children')
)
if not self.show_completed_projects:
from stalker import Status
status_cmpl = \
Status.query.filter(Status.code == 'CMPL').first()
query = query.filter(Project.status != status_cmpl)
query = query.order_by(Project.name)
projects = query.all()
else:
self.project.has_children = bool(self.project.tasks)
projects = [self.project]
logger.debug('projects: %s' % projects)
# delete the old model if any
if self.model() is not None:
self.model().deleteLater()
task_tree_model = TaskTreeModel()
task_tree_model.populateTree(projects)
self.setModel(task_tree_model)
self.is_updating = False
self.auto_fit_column()
logger.debug('finished filling tasks_treeView')
def logged_in_user(self):
"""Returns the logged in user as JSON data
"""
from pyramid.security import authenticated_userid
login_name = authenticated_userid(self.request)
from stalker import User
from stalker.db.session import DBSession
from sqlalchemy import or_
user_id = DBSession.query(User.id) \
.filter(or_(User.login == login_name, User.email == login_name)) \
.first()
if not user_id:
from pyramid.exceptions import HTTPForbidden
raise HTTPForbidden(self.request)
else:
self.entity_id = user_id
return self.get_entity()
def hasChildren(self, index):
"""returns True or False depending on to the index and the item on the
index
"""
logger.debug('TaskTreeModel.hasChildren() is started for index: %s' %
index)
if not index.isValid():
from stalker import Project
from stalker.db.session import DBSession
projects_count = DBSession.query(Project.id).count()
return_value = projects_count > 0
else:
item = self.itemFromIndex(index)
return_value = False
if item:
return_value = item.hasChildren()
logger.debug('TaskTreeModel.hasChildren() is finished for index: %s' %
index)
return return_value
def get_entity(self):
"""returns StatusMixin part of the entity
"""
from stalker_pyramid import entity_type_to_url
from stalker.db.session import DBSession
from stalker import Status, StatusList
status_id, status_list_id = DBSession.query(
self.som_class.status_id, self.som_class.status_list_id).filter(
self.som_class.id == self.entity_id).first()
status_data = DBSession\
.query(Status.id, Status.name, Status.entity_type)\
.filter(Status.id == status_id)\
.first()
status_list_data = DBSession\
.query(StatusList.id, StatusList.name, StatusList.entity_type)\
.filter(StatusList.id == status_list_id)\
.first()
data = {
'status': {
'id':
status_data[0],
'name':
status_data[1],
'entity_type':
status_data[2],
'$ref':
'%s/%s' % (entity_type_to_url[status_data[2]], status_data[0])
},
'status_list': {
'id':
status_list_data[0],
'name':
status_list_data[1],
'entity_type':
status_list_data[2],
'$ref':
'%s/%s' %
(entity_type_to_url[status_list_data[2]], status_list_data[0])
}
}
return data
def hasChildren(self, index):
"""returns True or False depending on to the index and the item on the
index
"""
logger.debug(
'TaskTreeModel.hasChildren() is started for index: %s' % index
)
if not index.isValid():
from stalker import Project
from stalker.db.session import DBSession
projects_count = DBSession.query(Project.id).count()
return_value = projects_count > 0
else:
item = self.itemFromIndex(index)
return_value = False
if item:
return_value = item.hasChildren()
logger.debug(
'TaskTreeModel.hasChildren() is finished for index: %s' % index
)
return return_value
def get_entity(self):
"""return one Group instance data as JSON
"""
# get supers response
response = super(GroupViews, self).get_entity()
# get entity type
entity_type = response.json_body['entity_type']
# get user count
from stalker.db.session import DBSession
from stalker.models.auth import Group_Users
user_count = DBSession.query(Group_Users.c.uid)\
.filter(Group_Users.c.gid == self.entity_id)\
.count()
# get permission count
sql = """select
"Permissions".access || '_' || "Permissions".action || '_' || "Permissions".class_name
from "Group_Permissions"
join "Permissions" on "Group_Permissions".permission_id = "Permissions".id
where "Group_Permissions".group_id = :id
"""
from sqlalchemy import text
conn = DBSession.connection()
permissions = conn.execute(text(sql), id=self.entity_id).fetchall()
# prepare data
from stalker_pyramid import entity_type_to_url
data = {
'permissions': [r[0] for r in permissions],
'users': {
'$ref': '%s/%s/users' %
(entity_type_to_url[entity_type], self.entity_id),
'length': user_count
}
}
# update supers response with our data and return
return self.update_response_data(response, data)
def get_entity(self):
"""returns one Department instance data as JSON
"""
response = super(DepartmentViews, self).get_entity()
# get entity type
from stalker import SimpleEntity
from stalker.db.session import DBSession
entity_type = DBSession.query(SimpleEntity.entity_type)\
.filter(SimpleEntity.id == self.entity_id)\
.first()[0]
# get user count
from stalker import DepartmentUser
user_count = DBSession\
.query(DepartmentUser.user_id)\
.filter(DepartmentUser.department_id == self.entity_id)\
.count()
from stalker_pyramid import entity_type_to_url
data = {
'user_roles': {
'$ref':
'%s/%s/user_roles' %
(entity_type_to_url[entity_type], self.entity_id),
'length':
user_count
},
'users': {
'$ref':
'%s/%s/users' %
(entity_type_to_url[entity_type], self.entity_id),
'length':
user_count
}
}
return self.update_response_data(response, data)
def get_entity(self):
"""returns one User instance
"""
sql_query = """select
"Users".id,
"Users".login,
"Users".email,
"Users".rate
from "Users"
where "Users".id = :id
"""
from sqlalchemy import text
from stalker.db.session import DBSession
conn = DBSession.connection()
result = conn.execute(text(sql_query), id=self.entity_id)
r = result.fetchone()
# get department count
from stalker import DepartmentUser
department_count = DBSession.query(DepartmentUser.user_id)\
.filter(DepartmentUser.user_id == self.entity_id)\
.count()
# get group count
from stalker.models.auth import Group_Users
group_count = DBSession.query(Group_Users.c.gid)\
.filter(Group_Users.c.uid == self.entity_id)\
.count()
# get project count
from stalker import ProjectUser
projects_count = DBSession.query(ProjectUser.project_id)\
.filter(ProjectUser.user_id == self.entity_id)\
.count()
# get reviews count
from stalker import Review
reviews_count = DBSession.query(Review.id)\
.filter(Review.reviewer_id == self.entity_id)\
.count()
# get pending reviews count
from stalker import Status
new_status_id = DBSession.query(Status.id)\
.filter(Status.code == 'NEW')\
.first()
pending_reviews_count = DBSession.query(Review.id)\
.filter(Review.reviewer_id == self.entity_id)\
.filter(Review.status_id == new_status_id)\
.count()
# get tasks count
from stalker.models.task import Task_Resources
tasks_count = DBSession.query(Task_Resources.c.task_id)\
.filter(Task_Resources.c.resource_id == self.entity_id)\
.count()
# get tickets count
from stalker import Ticket
tickets_count = DBSession.query(Ticket.id)\
.filter(Ticket.owner_id == self.entity_id)\
.count()
# get open tickets count
closed_status_id = DBSession.query(Status.id)\
.filter(Status.code=='CLS')\
.first()
open_ticket_count = DBSession.query(Ticket.id)\
.filter(Ticket.owner_id == self.entity_id)\
.filter(Ticket.status_id != closed_status_id)\
.count()
# get vacations count
from stalker import Vacation
vacations_count = DBSession.query(Vacation.id)\
.filter(Vacation.user_id == self.entity_id)\
.count()
if r:
from stalker_pyramid import entity_type_to_url
users_url = entity_type_to_url['User']
data = {
'id': r[0],
'login': r[1],
'email': r[2],
'rate': r[3],
'departments': {
'$ref': '%s/%s/departments' % (users_url, r[0]),
'length': department_count
},
'groups': {
'$ref': '%s/%s/groups' % (users_url, r[0]),
'length': group_count
},
'projects': {
'$ref': '%s/%s/projects' % (users_url, r[0]),
'length': projects_count
},
'reviews': {
'$ref': '%s/%s/reviews' % (users_url, r[0]),
'length': reviews_count
},
'pending_reviews': {
'$ref': '%s/%s/reviews?status=new' % (users_url, r[0]),
'length': pending_reviews_count
},
'tasks': {
'$ref': '%s/%s/tasks' % (users_url, r[0]),
'length': tasks_count
},
'tickets': {
'$ref': '%s/%s/tickets' % (users_url, r[0]),
'length': tickets_count
},
'open_tickets': {
'$ref': '%s/%s/tickets?status=open' % (users_url, r[0]),
'length': open_ticket_count
},
'vacations': {
'$ref': '%s/%s/vacations' % (users_url, r[0]),
'length': vacations_count
},
}
response = super(UserViews, self).get_entity()
return self.update_response_data(response, data)
else:
from pyramid.response import Response
return Response(body='Not Found', status=404)
def fetchMore(self):
logger.debug('TaskItem.fetchMore() is started for item: %s' %
self.text())
if self.canFetchMore():
from sqlalchemy.orm import aliased
from sqlalchemy.dialects.postgresql import array_agg
from stalker import Task, User
from stalker.models.task import Task_Resources
from stalker.db.session import DBSession
inner_tasks = aliased(Task)
subquery = DBSession.query(Task.id) \
.filter(Task.id == inner_tasks.parent_id)
query = DBSession.query(
Task.id,
Task.name,
Task.entity_type,
Task.status_id,
subquery.exists().label('has_children'),
array_agg(User.name).label('resources')
) \
.outerjoin(Task_Resources, Task.__table__.c.id == Task_Resources.c.task_id) \
.outerjoin(User, Task_Resources.c.resource_id == User.id) \
.group_by(
Task.id,
Task.name,
Task.entity_type,
Task.status_id,
subquery.exists().label('has_children')
)
if self.task.entity_type != 'Project':
# query child tasks
query = query.filter(Task.parent_id == self.task.id)
else:
# query only root tasks
query = query.filter(Task.project_id == self.task.id)\
.filter(Task.parent_id==None)
tasks = query.order_by(Task.name).all()
# # model = self.model() # This will cause a SEGFAULT
# # TODO: update it later on
# start = time.time()
from anima import defaults
task_items = []
for task in tasks:
task_item = TaskItem(0, 4, task=task)
task_item.parent = self
# color with task status
task_item.setData(
QtGui.QColor(
*defaults.status_colors_by_id[task.status_id]),
QtCore.Qt.BackgroundRole)
# use black text
task_item.setForeground(QtGui.QBrush(QtGui.QColor(0, 0, 0)))
task_items.append(task_item)
if task_items:
# self.appendRows(task_items)
for task_item in task_items:
# TODO: Create a custom QStandardItem for each data type in different columns
entity_type_item = QtGui.QStandardItem()
entity_type_item.setData(task_item.task.entity_type,
QtCore.Qt.DisplayRole)
resources_item = QtGui.QStandardItem()
if task_item.task.resources != [None]:
resources_item.setData(
', '.join(map(str, task_item.task.resources)),
QtCore.Qt.DisplayRole)
self.appendRow(
[task_item, entity_type_item, resources_item])
self.fetched_all = True
logger.debug('TaskItem.fetchMore() is finished for item: %s' %
self.text())
def get_entity(self):
"""returns one simple entity instance data
"""
sql = """
select
"SimpleEntities".id,
"SimpleEntities".name,
"SimpleEntities".description,
"SimpleEntities".created_by_id,
"SimpleEntities".updated_by_id,
(extract(epoch from "SimpleEntities".date_created::timestamp at time zone 'UTC') * 1000)::bigint as date_created,
(extract(epoch from "SimpleEntities".date_updated::timestamp at time zone 'UTC') * 1000)::bigint as date_updated,
"SimpleEntities".thumbnail_id,
"SimpleEntities".stalker_version,
"SimpleEntities".generic_text,
"SimpleEntities".entity_type,
"SimpleEntities".type_id
from "SimpleEntities"
where "SimpleEntities".id = :id
"""
from sqlalchemy import text
from stalker.db.session import DBSession
conn = DBSession.connection()
result = conn.execute(text(sql), id=self.entity_id)
r = result.fetchone()
# get generic_data_count
from stalker.models.entity import SimpleEntity_GenericData
generic_data_count = \
DBSession.query(SimpleEntity_GenericData.c.simple_entity_id)\
.filter(
SimpleEntity_GenericData.c.simple_entity_id == self.entity_id
)\
.count()
# get created_by name
created_by_name = created_by_entity_type = None
if r[3]:
sub_query_result = DBSession\
.query(SimpleEntity.name, SimpleEntity.entity_type)\
.filter(SimpleEntity.id == r[3])\
.first()
created_by_name = sub_query_result[0]
created_by_entity_type = sub_query_result[1]
# get updated_by name
updated_by_name = updated_by_entity_type = None
if r[4]:
if r[3] == r[4]:
updated_by_name = created_by_name
updated_by_entity_type = created_by_entity_type
else:
sub_query_result = DBSession \
.query(SimpleEntity.name, SimpleEntity.entity_type)\
.filter(SimpleEntity.id == r[4]) \
.first()
updated_by_name = sub_query_result[0]
updated_by_entity_type = sub_query_result[1]
# get thumbnail name - we need to do that to be consistent
thumbnail_name = thumbnail_entity_type = None
if r[7]:
sub_query_result = DBSession\
.query(SimpleEntity.name, SimpleEntity.entity_type)\
.filter(SimpleEntity.id == r[7])\
.first()
thumbnail_name = sub_query_result[0]
thumbnail_entity_type = sub_query_result[1]
# get type name
type_name = type_entity_type = None
if r[11]:
sub_query_result = DBSession\
.query(SimpleEntity.name, SimpleEntity.entity_type)\
.filter(SimpleEntity.id == r[11])\
.first()
type_name = sub_query_result[0]
type_entity_type = sub_query_result[1]
from stalker_pyramid import entity_type_to_url
data = {
'id': r[0],
'name': r[1],
'description': r[2],
'created_by': {
'id':
r[3],
'$ref':
'%s/%s' % (entity_type_to_url[created_by_entity_type], r[3]),
'name':
created_by_name,
'entity_type':
created_by_entity_type
} if r[3] else None,
'updated_by': {
'id':
r[4],
'$ref':
'%s/%s' % (entity_type_to_url[updated_by_entity_type], r[4]),
'name':
updated_by_name,
'entity_type':
updated_by_entity_type
} if r[4] else None,
'date_created': r[5],
'date_updated': r[6],
'thumbnail': {
'id': r[7],
'$ref': '%s/%s' %
(entity_type_to_url[thumbnail_entity_type], r[7]),
'name': thumbnail_name,
'entity_type': thumbnail_entity_type
} if r[7] else None,
'stalker_version': r[8],
'generic_text': r[9],
'generic_data': {
'$ref':
'%s/%s/generic_data' %
(entity_type_to_url['SimpleEntity'], r[0]),
'length':
generic_data_count
},
'entity_type': r[10],
'type': {
'id': r[11],
'$ref': '%s/%s' %
(entity_type_to_url[type_entity_type], r[11]),
'name': type_name,
'entity_type': type_entity_type
} if r[11] else None
}
from pyramid.response import Response
return Response(json_body=data)
def fetchMore(self):
logger.debug(
'TaskItem.fetchMore() is started for item: %s' % self.text()
)
if self.canFetchMore():
from sqlalchemy import alias
from stalker import Task
from stalker.db.session import DBSession
inner_tasks = alias(Task.__table__)
subquery = DBSession.query(Task.id)\
.filter(Task.id == inner_tasks.c.parent_id)
query = DBSession.query(
Task.id,
Task.name,
Task.entity_type,
Task.status_id,
subquery.exists().label('has_children')
)
if self.task.entity_type != 'Project':
# query child tasks
query = query.filter(Task.parent_id == self.task.id)
else:
# query only root tasks
query = query.filter(Task.project_id == self.task.id)\
.filter(Task.parent_id==None)
tasks = query.order_by(Task.name).all()
# # model = self.model() # This will cause a SEGFAULT
# # TODO: update it later on
# start = time.time()
from anima import defaults
task_items = []
for task in tasks:
task_item = TaskItem(0, 3, entity=task)
task_item.parent = self
# color with task status
task_item.setData(
QtGui.QColor(
*defaults.status_colors_by_id[task.status_id]
),
QtCore.Qt.BackgroundRole
)
# use black text
task_item.setForeground(
QtGui.QBrush(QtGui.QColor(0, 0, 0))
)
task_items.append(task_item)
if task_items:
self.appendRows(task_items)
self.fetched_all = True
logger.debug(
'TaskItem.fetchMore() is finished for item: %s' % self.text()
)
def copy_versions(self):
"""copies versions from one task to another
"""
# get from task
from_task = self.get_task_from_tree_view(self.from_task_tree_view)
# get logged in user
logged_in_user = self.get_logged_in_user()
if not from_task:
QtWidgets.QMessageBox.critical(
self, 'Error',
'Please select a task from <b>From Task</b> list')
return
# get to task
to_task = self.get_task_from_tree_view(self.to_task_tree_view)
if not to_task:
QtWidgets.QMessageBox.critical(
self, 'Error', 'Please select a task from <b>To Task</b> list')
return
# check if tasks are the same
if from_task == to_task:
QtWidgets.QMessageBox.critical(
self, 'Error', 'Please select two different tasks')
return
# get take names and related versions
# get distinct take names
from stalker.db.session import DBSession
from_take_names = map(
lambda x: x[0],
DBSession.query(distinct(Version.take_name)).filter(
Version.task == from_task).order_by(Version.take_name).all())
# create versions for each take
answer = QtWidgets.QMessageBox.question(
self, 'Info', "Will copy %s versions from take names:<br><br>"
"%s"
"<br><br>"
"Is that Ok?" %
(len(from_take_names), '<br>'.join(from_take_names)),
QtWidgets.QMessageBox.Yes, QtWidgets.QMessageBox.No)
if answer == QtWidgets.QMessageBox.Yes:
for take_name in from_take_names:
latest_version = Version.query\
.filter_by(task=from_task)\
.filter_by(take_name=take_name)\
.order_by(Version.version_number.desc())\
.first()
# create a new version
new_version = Version(task=to_task, take_name=take_name)
new_version.created_by = logged_in_user
new_version.extension = latest_version.extension
new_version.description = \
'Moved from another task (id=%s) with Version Mover' % \
latest_version.task.id
new_version.created_with = latest_version.created_with
DBSession.add(new_version)
DBSession.commit()
# update path
new_version.update_paths()
DBSession.add(new_version)
DBSession.commit()
# now copy the last_version file to the new_version path
try:
os.makedirs(new_version.absolute_path)
except OSError: # path exists
pass
# move the file there
shutil.copyfile(latest_version.absolute_full_path,
new_version.absolute_full_path)
# inform the user
QtWidgets.QMessageBox.information(
self, 'Success',
'Successfully copied %s versions' % len(from_take_names))
def _set_defaults(self):
"""setup the default values
"""
# set size policies
# self.name_lineEdit
self.type_comboBox.setSizePolicy(
QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Fixed
)
self.status_comboBox.setSizePolicy(
QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Fixed
)
self.client_comboBox.setSizePolicy(
QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Fixed
)
self.agency_comboBox.setSizePolicy(
QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Fixed
)
self.production_company_comboBox.setSizePolicy(
QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Fixed
)
# invalidate the name and code fields by default
self.name_lineEdit.set_invalid('Enter a name')
self.code_lineEdit.set_invalid('Enter a code')
# update type field
from stalker import Type
from stalker.db.session import DBSession
project_types = \
DBSession.query(Type.id, Type.name)\
.filter(Type.target_entity_type == 'Project')\
.order_by(Type.name)\
.all()
self.type_comboBox.clear()
self.type_comboBox.addItem('', -1)
for type_id, type_name in project_types:
self.type_comboBox.addItem(type_name, type_id)
self.image_format.fill_combo_box()
self.fill_repository_combo_box()
self.fill_structure_combo_box()
# fill status field
sql = """select
"SimpleEntities".id,
"SimpleEntities".name
from "Statuses"
join "SimpleEntities" on "Statuses".id = "SimpleEntities".id
join "StatusList_Statuses" on "Statuses".id = "StatusList_Statuses".status_id
join "StatusLists" on "StatusLists".id = "StatusList_Statuses".status_list_id
where "StatusLists".target_entity_type = 'Project'"""
all_project_statuses = \
DBSession.connection().execute(sql).fetchall()
for st_id, st_name in all_project_statuses:
self.status_comboBox.addItem(st_name, st_id)
def fetchMore(self):
logger.debug(
'TaskItem.fetchMore() is started for item: %s' % self.text()
)
if self.canFetchMore():
from sqlalchemy import alias
from sqlalchemy.dialects.postgresql import array_agg
from stalker import Task, User
from stalker.models.task import Task_Resources
from stalker.db.session import DBSession
inner_tasks = alias(Task.__table__)
subquery = DBSession.query(Task.id)\
.filter(Task.id == inner_tasks.c.parent_id)
query = DBSession.query(
Task.id,
Task.name,
Task.entity_type,
Task.status_id,
subquery.exists().label('has_children'),
array_agg(User.name).label('resources')
)\
.outerjoin(Task_Resources, Task.id == Task_Resources.c.task_id)\
.outerjoin(User, Task_Resources.c.resource_id == User.id) \
.group_by(
Task.id,
Task.name,
Task.entity_type,
Task.status_id,
subquery.exists().label('has_children')
)
if self.task.entity_type != 'Project':
# query child tasks
query = query.filter(Task.parent_id == self.task.id)
else:
# query only root tasks
query = query.filter(Task.project_id == self.task.id)\
.filter(Task.parent_id==None)
tasks = query.order_by(Task.name).all()
# # model = self.model() # This will cause a SEGFAULT
# # TODO: update it later on
# start = time.time()
from anima import defaults
task_items = []
for task in tasks:
task_item = TaskItem(0, 4, entity=task)
task_item.parent = self
# color with task status
task_item.setData(
QtGui.QColor(
*defaults.status_colors_by_id[task.status_id]
),
QtCore.Qt.BackgroundRole
)
# use black text
task_item.setForeground(
QtGui.QBrush(QtGui.QColor(0, 0, 0))
)
task_items.append(task_item)
if task_items:
# self.appendRows(task_items)
for task_item in task_items:
# TODO: Create a custom QStandardItem for each data type in different columns
entity_type_item = QtGui.QStandardItem()
entity_type_item.setData(task_item.task.entity_type, QtCore.Qt.DisplayRole)
resources_item = QtGui.QStandardItem()
if task_item.task.resources != [None]:
resources_item.setData(', '.join(map(str, task_item.task.resources)), QtCore.Qt.DisplayRole)
self.appendRow([task_item, entity_type_item, resources_item])
self.fetched_all = True
logger.debug(
'TaskItem.fetchMore() is finished for item: %s' % self.text()
)
