def view_entity_department(request):
"""create department dialog
"""
logger.debug('***view_entity_department method starts ***')
logged_in_user = get_logged_in_user(request)
entity_id = request.matchdict.get('eid', -1)
entity = Entity.query.filter_by(id=entity_id).first()
logger.debug('entity_type : %s' % entity.entity_type)
department_id = request.matchdict.get('id', -1)
department = Department.query.filter_by(id=department_id).first()
studio = Studio.query.first()
projects = Project.query.all()
return {
'entity': entity,
'department': department,
'actions': defaults.actions,
'logged_in_user': logged_in_user,
'stalker_pyramid': stalker_pyramid,
'has_permission': PermissionChecker(request),
'studio': studio,
'projects': projects
}
def list_group_permissions(request):
"""create group dialog
"""
logger.debug('***view_entity_group method starts ***')
logged_in_user = get_logged_in_user(request)
permissions = Permission.query.all()
entity_types = EntityType.query.all()
group_id = request.matchdict.get('id', -1)
group = Group.query.filter_by(id=group_id).first()
studio = Studio.query.first()
projects = Project.query.all()
return {
'entity': group,
'actions': defaults.actions,
'permissions': permissions,
'entity_types': entity_types,
'logged_in_user': logged_in_user,
'stalker_pyramid': stalker_pyramid,
'has_permission': PermissionChecker(request),
'studio': studio,
'projects': projects
}
def get_entity_related_data(request):
"""view for generic data
"""
logger.debug('get_entity_related_data')
logged_in_user = get_logged_in_user(request)
studio = Studio.query.first()
entity_id = request.matchdict.get('id')
if not entity_id:
entity = studio
else:
entity = Entity.query.filter_by(id=entity_id).first()
projects = Project.query.all()
mode = request.matchdict.get('mode', None)
came_from = request.params.get('came_from', request.url)
return {
'mode': mode,
'entity': entity,
'has_permission': PermissionChecker(request),
'logged_in_user': logged_in_user,
'milliseconds_since_epoch': milliseconds_since_epoch,
'stalker_pyramid': stalker_pyramid,
'projects': projects,
'studio': studio,
'came_from': came_from
}
def list_entity_tasks_by_filter(request):
"""creates a list_entity_tasks_by_filter by using the given entity and filter
"""
logger.debug('inside list_entity_tasks_by_filter')
# get logged in user
logged_in_user = get_logged_in_user(request)
entity_id = request.matchdict.get('id', -1)
entity = Entity.query.filter_by(id=entity_id).first()
filter_id = request.matchdict.get('f_id', -1)
filter = Entity.query.filter_by(id=filter_id).first()
studio = Studio.query.first()
if not studio:
studio = defaults
return {
'mode': 'create',
'has_permission': PermissionChecker(request),
'studio': studio,
'logged_in_user': logged_in_user,
'entity': entity,
'filter': filter,
'milliseconds_since_epoch': milliseconds_since_epoch,
}
def create_version_dialog(request):
"""creates a create_version_dialog by using the given task
"""
logger.debug('inside create_version_dialog')
# get logged in user
logged_in_user = get_logged_in_user(request)
task_id = request.matchdict.get('id', -1)
task = Task.query.filter(Task.task_id == task_id).first()
takes = map(
lambda x: x[0],
DBSession.query(distinct(Version.take_name))
.filter(Version.task == task)
.all()
)
if defaults.version_take_name not in takes:
takes.append(defaults.version_take_name)
return {
'mode': 'CREATE',
'has_permission': PermissionChecker(request),
'logged_in_user': logged_in_user,
'task': task,
'default_take_name': defaults.version_take_name,
'take_names': [defaults.version_take_name]
}
def assign_thumbnail(request):
"""assigns the thumbnail to the given entity
"""
link_ids = get_multi_integer(request, 'link_ids[]')
entity_id = request.params.get('entity_id', -1)
link = Link.query.filter(Link.id.in_(link_ids)).first()
entity = Entity.query.filter_by(id=entity_id).first()
logger.debug('link_ids : %s' % link_ids)
logger.debug('link : %s' % link)
logger.debug('entity_id : %s' % entity_id)
logger.debug('entity : %s' % entity)
logged_in_user = get_logged_in_user(request)
if entity and link:
entity.thumbnail = link
# resize the thumbnail
file_full_path = convert_file_link_to_full_path(link.full_path)
img = Image.open(file_full_path)
if img.format != 'GIF':
img.thumbnail((1024, 1024))
img.thumbnail((512, 512), Image.ANTIALIAS)
img.save(file_full_path)
DBSession.add(entity)
DBSession.add(link)
return HTTPOk()
def update_time_log_dialog(request):
"""updates a create_time_log_dialog by using the given task
"""
logger.debug('inside updates_time_log_dialog')
came_from = request.params.get('came_from','/')
logger.debug('came_from %s: '% came_from)
# get logged in user
logged_in_user = get_logged_in_user(request)
time_log_id = request.matchdict.get('id', -1)
time_log = TimeLog.query.filter_by(id=time_log_id).first()
studio = Studio.query.first()
if not studio:
studio = defaults
return {
'mode': 'update',
'has_permission': PermissionChecker(request),
'studio': studio,
'logged_in_user': logged_in_user,
'task': time_log.task,
'came_from': came_from,
'time_log': time_log,
'milliseconds_since_epoch': milliseconds_since_epoch
}
def update_structure(request):
"""updates a structure
"""
logged_in_user = get_logged_in_user(request)
# get params
structure_id = request.params.get('structure_id')
structure = Structure.query.filter_by(id=structure_id).first()
name = request.params.get('name')
custom_template = request.params.get('custom_template')
# get all FilenameTemplates
ft_ids = get_multi_integer(request, 'filename_templates')
fts = FilenameTemplate.query.filter(FilenameTemplate.id.in_(ft_ids)).all()
if name:
# update structure
structure.name = name
structure.custom_template = custom_template
structure.templates = fts
structure.updated_by = logged_in_user
structure.date_updated = datetime.datetime.now()
DBSession.add(structure)
return HTTPOk()
def create_ticket_dialog(request):
"""creates a create_ticket_dialog by using the given task
"""
logged_in_user = get_logged_in_user(request)
project_id = request.params.get('project_id', -1)
project = Project.query.filter(Project.id == project_id).first()
task_id = request.params.get('task_id', -1)
owner_id= request.params.get('owner_id', -1)
if not project:
return Response('No project found with id: %s' % project_id, 500)
return {
'mode': 'create',
'has_permission': PermissionChecker(request),
'logged_in_user': logged_in_user,
'task_id': task_id,
'owner_id':owner_id,
'project': project,
'ticket_types':
Type.query.filter_by(target_entity_type='Ticket').all(),
'ticket_priorities': [
"TRIVIAL",
"MINOR",
"MAJOR",
"CRITICAL",
"BLOCKER"
]
}
def update_sequence(request):
"""runs when adding a new sequence
"""
logged_in_user = get_logged_in_user(request)
sequence_id = request.params.get('sequence_id')
sequence = Sequence.query.filter_by(id=sequence_id).first()
name = request.params.get('name')
code = request.params.get('code')
status_id = request.params.get('status_id')
status = Status.query.filter_by(id=status_id).first()
if sequence and code and name and status:
# get descriptions
description = request.params.get('description')
#update the sequence
sequence.name = name
sequence.code = code
sequence.description = description
sequence.status = status
sequence.updated_by = logged_in_user
sequence.date_updated = datetime.datetime.now()
DBSession.add(sequence)
else:
logger.debug('there are missing parameters')
logger.debug('name : %s' % name)
logger.debug('status : %s' % status)
HTTPServerError()
return HTTPOk()
def create_image_format(request):
"""creates an image format
"""
logged_in_user = get_logged_in_user(request)
name = request.params.get('name')
width = int(request.params.get('width', -1))
height = int(request.params.get('height', -1))
pixel_aspect = float(request.params.get('pixel_aspect', -1))
if name and width and height and pixel_aspect:
# create a new ImageFormat and save it to the database
new_image_format = ImageFormat(
name=name,
width=width,
height=height,
pixel_aspect=pixel_aspect,
created_by=logged_in_user
)
DBSession.add(new_image_format)
logger.debug('created new image format')
logger.debug('new_image_format: %s' % new_image_format)
else:
logger.debug('some data is missing')
return HTTPServerError()
return HTTPOk()
def update_department(request):
"""updates an Department
"""
logger.debug('***update department method starts ***')
logged_in_user = get_logged_in_user(request)
# get params
came_from = request.params.get('came_from', '/')
department_id = request.matchdict.get('id', -1)
department = Department.query.filter_by(id=department_id).first()
name = request.params.get('name')
logger.debug('department : %s' % department)
logger.debug('department new name : %s' % name)
if department and name:
description = request.params.get('description')
lead_id = request.params.get('lead_id', -1)
lead = User.query.filter_by(id=lead_id).first()
# Tags
tags = get_tags(request)
logger.debug('department new description : %s' % description)
logger.debug('department new lead : %s' % lead)
logger.debug('department new tags : %s' % tags)
# update the department
department.name = name
department.description = description
department.lead = lead
department.tags = tags
department.updated_by = logged_in_user
department.date_updated = datetime.datetime.now()
DBSession.add(department)
logger.debug('department is updated successfully')
request.session.flash(
'success:Department <strong>%s</strong> is updated successfully' % name
)
logger.debug('***update department method ends ***')
else:
logger.debug('not all parameters are in request.params')
log_param(request, 'department_id')
log_param(request, 'name')
HTTPServerError()
return Response('Successfully updated department: %s' % department_id)
def update_group(request):
"""updates the group with data from request
"""
logger.debug('***update group method starts ***')
logged_in_user = get_logged_in_user(request)
# get parameters
post_multi_dict = request.POST
came_from = request.params.get('came_from', '/')
group_id = int(post_multi_dict['group_id'])
group = Group.query.filter_by(id=group_id).first()
name = post_multi_dict['name']
if group and name:
description = post_multi_dict['description']
# remove name and description to leave only permission in the dictionary
post_multi_dict.pop('name')
post_multi_dict.pop('description')
permissions = get_permissions_from_multi_dict(post_multi_dict)
# update the group
group.name = name
group.description = description
group.permissions = permissions
group.updated_by = logged_in_user
group.date_updated = datetime.datetime.now()
DBSession.add(group)
logger.debug('group is updated successfully')
request.session.flash(
'success:Group <strong>%s</strong> is updated successfully' % name
)
logger.debug('***update group method ends ***')
else:
logger.debug('not all parameters are in request.params')
log_param(request, 'group_id')
log_param(request, 'name')
response = Response(
'There are missing parameters: '
'group_id: %s, name: %s' % (group_id, name), 500
)
transaction.abort()
return response
response = Response('successfully updated %s group!' % name)
return response
def assign_reference(request):
"""assigns the link to the given entity as a new reference
"""
link_ids = get_multi_integer(request, 'link_ids[]')
removed_link_ids = get_multi_integer(request, 'removed_link_ids[]')
entity_id = request.params.get('entity_id', -1)
entity = Entity.query.filter_by(id=entity_id).first()
links = Link.query.filter(Link.id.in_(link_ids)).all()
removed_links = Link.query.filter(Link.id.in_(removed_link_ids)).all()
# Tags
tags = get_tags(request)
logged_in_user = get_logged_in_user(request)
logger.debug('link_ids : %s' % link_ids)
logger.debug('links : %s' % links)
logger.debug('entity_id : %s' % entity_id)
logger.debug('entity : %s' % entity)
logger.debug('tags : %s' % tags)
logger.debug('removed_links : %s' % removed_links)
# remove all the removed links
for removed_link in removed_links:
# no need to search for any linked tasks here
DBSession.delete(removed_link)
if entity and links:
entity.references.extend(links)
# assign all the tags to the links
for link in links:
link.tags.extend(tags)
# generate thumbnail
thumbnail = generate_thumbnail(link)
link.thumbnail = thumbnail
thumbnail.created_by = logged_in_user
DBSession.add(thumbnail)
DBSession.add(entity)
DBSession.add_all(links)
# return new links as json data
# in response text
return [
{
'id': link.id,
'full_path': link.full_path,
'original_filename': link.original_filename,
'thumbnail': link.thumbnail.full_path
if link.thumbnail else link.full_path,
'tags': [tag.name for tag in link.tags]
} for link in links
]
def update_project(request):
"""called when updating a Project
"""
logged_in_user = get_logged_in_user(request)
# parameters
project_id = request.params.get('project_id', -1)
project = Project.query.filter_by(id=project_id).first()
name = request.params.get('name')
fps = int(request.params.get('fps'))
imf_id = request.params.get('image_format', -1)
imf = ImageFormat.query.filter_by(id=imf_id).first()
repo_id = request.params.get('repository_id', -1)
repo = Repository.query.filter_by(id=repo_id).first()
structure_id = request.params.get('structure_id', -1)
structure = Structure.query.filter_by(id=structure_id).first()
lead_id = request.params.get('lead_id', -1)
lead = User.query.filter_by(id=lead_id).first()
status_id = request.params.get('status_id', -1)
status = Status.query.filter_by(id=status_id).first()
# get the dates
start = get_date(request, 'start')
end = get_date(request, 'end')
if project and name and imf and repo and structure and lead and \
status:
project.name = name
project.image_format = imf
project.repository = repo
project.updated_by = logged_in_user
project.date_updated = datetime.datetime.now()
project.fps = fps
project.structure = structure
project.lead = lead
project.status = status
project.start = start
project.end = end
DBSession.add(project)
else:
logger.debug('there are missing parameters')
HTTPServerError()
return HTTPOk()
def create_shot(request):
"""runs when adding a new shot
"""
logged_in_user = get_logged_in_user(request)
name = request.params.get("name")
code = request.params.get("code")
status_id = request.params.get("status_id")
status = Status.query.filter_by(id=status_id).first()
project_id = request.params.get("project_id")
project = Project.query.filter_by(id=project_id).first()
logger.debug("project_id : %s" % project_id)
if name and code and status and project:
# get descriptions
description = request.params.get("description")
sequence_id = request.params["sequence_id"]
sequence = Sequence.query.filter_by(id=sequence_id).first()
# get the status_list
status_list = StatusList.query.filter_by(target_entity_type="Shot").first()
# there should be a status_list
# TODO: you should think about how much possible this is
if status_list is None:
return HTTPServerError(detail="No StatusList found")
new_shot = Shot(
name=name,
code=code,
description=description,
sequence=sequence,
status_list=status_list,
status=status,
created_by=logged_in_user,
project=project,
)
DBSession.add(new_shot)
else:
logger.debug("there are missing parameters")
logger.debug("name : %s" % name)
logger.debug("code : %s" % code)
logger.debug("status : %s" % status)
logger.debug("project : %s" % project)
HTTPServerError()
return HTTPOk()
def create_sequence(request):
"""runs when adding a new sequence
"""
logged_in_user = get_logged_in_user(request)
name = request.params.get('name')
code = request.params.get('code')
status_id = request.params.get('status_id')
status = Status.query.filter_by(id=status_id).first()
project_id = request.params.get('project_id')
project = Project.query.filter_by(id=project_id).first()
logger.debug('project_id : %s' % project_id)
if name and code and status and project:
# get descriptions
description = request.params.get('description')
# get the status_list
status_list = StatusList.query.filter_by(
target_entity_type='Sequence'
).first()
# there should be a status_list
# TODO: you should think about how much possible this is
if status_list is None:
return HTTPServerError(detail='No StatusList found')
new_sequence = Sequence(
name=name,
code=code,
description=description,
status_list=status_list,
status=status,
created_by=logged_in_user,
project=project
)
DBSession.add(new_sequence)
else:
logger.debug('there are missing parameters')
logger.debug('name : %s' % name)
logger.debug('code : %s' % code)
logger.debug('status : %s' % status)
logger.debug('project : %s' % project)
HTTPServerError()
return HTTPOk()
def update_version_dialog(request):
"""updates a create_version_dialog by using the given task
"""
# get logged in user
logged_in_user = get_logged_in_user(request)
version_id = request.matchdict.get('id', -1)
version = Version.query.filter_by(id=version_id).first()
return {
'mode': 'UPDATE',
'has_permission': PermissionChecker(request),
'logged_in_user': logged_in_user,
'task': version.task,
'version': version
}
def update_asset(request):
"""updates an Asset
"""
logger.debug('***update_asset method starts ***')
logged_in_user = get_logged_in_user(request)
# get params
asset_id = request.matchdict.get('id', -1)
asset = Asset.query.filter_by(id=asset_id).first()
name = request.params.get('name')
code = request.params.get('code')
description = request.params.get('description')
type_name = request.params.get('type_name')
status_id = request.params.get('status_id')
status = Status.query.filter_by(id=status_id).first()
if asset and name and code and type_name and status:
# get the type
type_ = Type.query\
.filter_by(target_entity_type='Asset')\
.filter_by(name=type_name)\
.first()
if type_ is None:
# create a new Type
type_ = Type(
name=type_name,
code=type_name,
target_entity_type='Asset'
)
# update the asset
logger.debug('code : %s' % code)
asset.name = name
asset.code = code
asset.description = description
asset.type = type_
asset.status = status
asset.updated_by = logged_in_user
asset.date_updated = datetime.datetime.now()
DBSession.add(asset)
return HTTPOk()
def create_entity_note(request):
logger.debug('create_entity_note is running')
entity_id = request.matchdict.get('id', -1)
entity = Entity.query.filter(Entity.id == entity_id).first()
content = request.params.get('message', '')
utc_now = local_to_utc(datetime.datetime.now())
logged_in_user = get_logged_in_user(request)
if not entity:
transaction.abort()
return Response('There is no entity with id: %s' % entity_id, 500)
logger.debug('content %s' % content)
if content != '':
note_type = Type.query.filter_by(name='Simple Text').first()
if note_type is None:
# create a new Type
note_type = Type(
name='Simple Text',
code='Simple_Text',
target_entity_type='Note',
html_class='grey'
)
note = Note(
content=content,
created_by=logged_in_user,
date_created=utc_now,
date_updated=utc_now,
type = note_type
)
DBSession.add(note)
entity.notes.append(note)
return Response('Task note is created')
def update_shot(request):
"""runs when adding a new shot
"""
logged_in_user = get_logged_in_user(request)
shot_id = request.params.get("shot_id")
shot = Shot.query.filter_by(id=shot_id).first()
name = request.params.get("name")
code = request.params.get("code")
cut_in = int(request.params.get("cut_in", 1))
cut_out = int(request.params.get("cut_out", 1))
status_id = request.params.get("status_id")
status = Status.query.filter_by(id=status_id).first()
if shot and code and name and status:
# get descriptions
description = request.params.get("description")
sequence_id = request.params["sequence_id"]
sequence = Sequence.query.filter_by(id=sequence_id).first()
# update the shot
shot.name = name
shot.code = code
shot.description = description
shot.sequences = [sequence]
shot.status = status
shot.updated_by = logged_in_user
shot.date_updated = datetime.datetime.now()
shot.cut_in = cut_in
shot.cut_out = cut_out
DBSession.add(shot)
else:
logger.debug("there are missing parameters")
logger.debug("name : %s" % name)
logger.debug("status : %s" % status)
HTTPServerError()
return HTTPOk()
def update_version(request):
"""runs when updating a version
"""
logged_in_user = get_logged_in_user(request)
version_id = request.params.get('version_id')
version = TimeLog.query.filter_by(id=version_id).first()
name = request.params.get('name')
if version and name:
version.name = name
version.updated_by = logged_in_user
else:
DBSession.add(version)
return HTTPOk()
def home(request):
logged_in_user = get_logged_in_user(request)
studio = Studio.query.first()
projects = Project.query.all()
flash_message = request.params.get('flash')
if flash_message:
request.session.flash(flash_message)
return {
'stalker_pyramid': stalker_pyramid,
'studio': studio,
'logged_in_user': logged_in_user,
'has_permission': PermissionChecker(request),
'milliseconds_since_epoch': milliseconds_since_epoch,
'projects': projects,
'entity': logged_in_user
}
def list_groups(request):
"""
"""
logger.debug('***list_groups method starts ***')
logged_in_user = get_logged_in_user(request)
groups = Group.query.all()
studio = Studio.query.first()
projects = Project.query.all()
return {
'stalker_pyramid': stalker_pyramid,
'studio': studio,
'logged_in_user': logged_in_user,
'milliseconds_since_epoch': milliseconds_since_epoch,
'has_permission': PermissionChecker(request),
'projects': projects,
'groups': groups
}
def create_structure(request):
"""creates a structure
"""
logged_in_user = get_logged_in_user(request)
# get parameters
name = request.params.get('name')
custom_template = request.params.get('custom_template')
ft_ids = get_multi_integer(request, 'filename_templates')
fts = FilenameTemplate.query.filter(FilenameTemplate.id.in_(ft_ids)).all()
if name and custom_template:
# create a new structure
new_structure = Structure(
name=name,
custom_template=custom_template,
templates=fts,
created_by=logged_in_user,
)
DBSession.add(new_structure)
return HTTPOk()
def update_filename_template(request):
"""updates a FilenameTemplate instance
"""
logged_in_user = get_logged_in_user(request)
name = request.params.get('name')
path = request.params.get('path')
filename = request.params.get('filename')
ft_id = request.params.get('ft_id')
ft = FilenameTemplate.query.filter_by(id=ft_id).first()
if name and path and filename and ft:
ft.name = name
ft.path = path
ft.filename = filename
ft.updated_by = logged_in_user
ft.date_updated = datetime.datetime.now()
DBSession.add(ft)
return HTTPOk()
def create_filename_template(request):
"""creates a new FilenameTemplate
"""
logged_in_user = get_logged_in_user(request)
# get parameters
name = request.params.get('name')
target_entity_type = request.params.get('target_entity_type')
path = request.params.get('path')
filename = request.params.get('filename')
if name and target_entity_type and path and filename:
new_ft = FilenameTemplate(
name=name,
target_entity_type=target_entity_type,
path=path,
filename=filename,
created_by=logged_in_user
)
DBSession.add(new_ft)
return HTTPOk()
def create_repository(request):
"""creates a new repository
"""
logged_in_user = get_logged_in_user(request)
# get params
name = request.params.get('name')
windows_path = request.params.get('windows_path')
linux_path = request.params.get('linux_path')
osx_path = request.params.get('osx_path')
if name and windows_path and linux_path and osx_path:
# create a new Repository and save it to the database
new_repository = Repository(
name=name,
windows_path=windows_path,
linux_path=linux_path,
osx_path=osx_path,
created_by=logged_in_user
)
DBSession.add(new_repository)
return HTTPOk()
def update_image_format(request):
"""updates an image format
"""
logged_in_user = get_logged_in_user(request)
# get params
imf_id = request.params.get('imf_id', -1)
imf = ImageFormat.query.filter_by(id=imf_id).first()
name = request.params.get('name')
width = int(request.params.get('width', -1))
height = int(request.params.get('height', -1))
pixel_aspect = float(request.params.get('pixel_aspect', -1))
if imf and name and width and height and pixel_aspect:
imf.name = request.params['name']
imf.width = int(request.params['width'])
imf.height = int(request.params['height'])
imf.pixel_aspect = float(request.params['pixel_aspect'])
imf.updated_by = logged_in_user
imf.date_updated = datetime.datetime.now()
DBSession.add(imf)
return HTTPOk()
def list_search_result(request):
qString = request.params.get('str', None)
entity_id = request.params.get('eid', None)
entity = Entity.query.filter_by(id=entity_id).first()
results = Entity.query.filter(
Entity.name.ilike('%' + qString + '%')
).all()
projects = Project.query.all()
logged_in_user = get_logged_in_user(request)
studio = Studio.query.first()
return {
'entity': entity,
'has_permission': PermissionChecker(request),
'logged_in_user': logged_in_user,
'milliseconds_since_epoch': milliseconds_since_epoch,
'stalker_pyramid': stalker_pyramid,
'projects': projects,
'studio': studio,
'results':results
}
