def run_fix_definition(self):
"""runs fix definitions for publishers
"""
m = QtWidgets.QMessageBox()
m.setWindowTitle('Continue?')
m.setText('This command will try to fix<br/>'
'[ <b>%s</b> ] issue<br/>'
'automatically.<br/><br/>'
'Confirm ? <b>(BETA)</b>' %
self.publisher.__doc__.split('\n')[0].strip())
m.setStandardButtons(QtWidgets.QMessageBox.Yes
| QtWidgets.QMessageBox.No)
m.setDefaultButton(QtWidgets.QMessageBox.Yes)
m.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
m.exec_()
if m.clickedButton() == m.defaultButton():
fix_def_name = '%s%s' % (self.publisher.__name__,
self.fix_identifier)
try:
from anima.env.mayaEnv import publish
fix_func = publish.__dict__[fix_def_name]
fix_func()
except KeyError:
pass
self.check_push_button.click()
def create_render_jobs(self):
"""creates render jobs
"""
# first check duplicate shots
if not self.check_duplicate_shots():
return
if not self.validate_shot_codes():
return
project = self.project_combo_box.get_current_project()
sequence = self.sequence_combo_box.get_current_sequence()
im = ShotManager(project, sequence)
message_box = QtWidgets.QMessageBox(self)
# message_box.setTitle("Which Shots?")
message_box.setText("Which Shots?")
current_shot = QtWidgets.QPushButton("Current")
all_shots = QtWidgets.QPushButton("All")
message_box.addButton(current_shot, QtWidgets.QMessageBox.YesRole)
message_box.addButton(all_shots, QtWidgets.QMessageBox.NoRole)
message_box.exec_()
try:
clicked_button = message_box.clickedButton()
message_box.deleteLater()
if clicked_button == all_shots:
for shot in im.get_shots():
shot.create_render_job()
else:
im.get_current_shot().create_render_job()
except BaseException as e:
QtWidgets.QMessageBox.critical(
self,
"Error",
str(e)
)
raise e
finally:
QtWidgets.QMessageBox.information(
self,
"Created Shots and Render Jobs 👍",
"Created Shots and Render Jobs 👍"
)
def update_versions(self):
"""updates the versions if it is checked in the UI
"""
reference_resolution = self.generate_reference_resolution()
# send them back to environment
try:
self.environment.update_versions(reference_resolution)
except RuntimeError as e:
# display as a Error message and return without doing anything
message_box = QtWidgets.QMessageBox(self)
message_box.critical(self, "Error", str(e),
QtWidgets.QMessageBox.Ok)
return
# close the interface
self.close()
def show_publisher_docs(self):
"""Help dialog for publishers
"""
# TODO: Too much string interpretation. Needs improvement.
if self.publisher:
m = QtWidgets.QMessageBox()
m.setWindowTitle('Help')
import sys
if sys.version_info.major > 2:
stringify = str
else:
stringify = unicode
# cleanup exception message format
import re
error = str(''.join([
i for i in stringify(self.publisher_state_label.toolTip())
if ord(i) < 128
]))
publish_error = ''
for exception in ['PublishError:', 'RuntimeError:']:
try:
clean_error = error.split(exception)[1]
formatted_error = clean_error.replace('<br>', '\n')
publish_error = re.sub('<[^>]*>', '', formatted_error)
except IndexError:
continue
# display message
message = self.publisher.__doc__
message += '\n--------------------\n'
message += publish_error
m.setText(message)
m.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
m.exec_()
def accept(self):
"""overridden accept method
"""
# get the info
task = self.tasks_combo_box.currentTask()
resource = self.get_current_resource()
# war the user if the resource is not the logged_in_user
if resource != self.logged_in_user:
msg_box = QtWidgets.QMessageBox(self)
msg_box.setWindowTitle(
'Entering TimeLog On Behalf of Somebody Else'
)
msg_box.setText(
"You're entering a TimeLog on behalf of somebody else???"
)
accept_button = msg_box.addButton(
'Accept the responsibility',
QtWidgets.QMessageBox.AcceptRole
)
cancel_button = msg_box.addButton(
'Cancel',
QtWidgets.QMessageBox.RejectRole
)
msg_box.setDefaultButton(cancel_button)
msg_box.exec_()
clicked_button = msg_box.clickedButton()
msg_box.deleteLater()
if clicked_button == cancel_button:
return
description = self.description_plain_text_edit.toPlainText()
revision_cause_text = \
self.revision_type_combo_box.currentText().replace(' ', '_')
is_complete = self.set_as_complete_radio_button.isChecked()
submit_to_final_review = \
self.submit_for_final_review_radio_button.isChecked()
# get the revision Types
from stalker import Type
revision_type = Type.query\
.filter(Type.target_entity_type == 'Note')\
.filter(Type.name == revision_cause_text)\
.first()
date = self.calendar_widget.selectedDate()
start = self.start_time_edit.time()
end = self.end_time_edit.time()
# construct proper datetime.DateTime instances
import datetime
start_date = datetime.datetime(
date.year(), date.month(), date.day(),
start.hour(), start.minute()
)
end_date = datetime.datetime(
date.year(), date.month(), date.day(),
end.hour(), end.minute()
)
today_midnight = datetime.datetime.now().replace(
hour=23, minute=59, second=59, microsecond=999
)
# raise an error if the user is trying to enter a TimeLog to the future
if start_date > today_midnight or end_date > today_midnight:
QtWidgets.QMessageBox.critical(
self,
'Error',
'Gelecege TimeLog giremezsiniz!!!',
)
return
# convert them to utc
from anima.utils import local_to_utc
utc_start_date = local_to_utc(start_date)
utc_end_date = local_to_utc(end_date)
# create a TimeLog
# print('Task : %s' % task.name)
# print('Resource : %s' % resource.name)
# print('utc_start_date: %s' % utc_start_date)
# print('utc_end_date : %s' % utc_end_date)
# now if we are not using extra time just create the TimeLog
from stalker import TimeLog
from stalker.db.session import DBSession
from stalker.exceptions import (OverBookedError,
DependencyViolationError)
utc_now = local_to_utc(datetime.datetime.now())
# TODO: Remove this in a later version
import stalker
from distutils.version import LooseVersion
if LooseVersion(stalker.__version__) >= LooseVersion('0.2.18'):
# inject timezone info
import pytz
utc_start_date = utc_start_date.replace(tzinfo=pytz.utc)
utc_end_date = utc_end_date.replace(tzinfo=pytz.utc)
utc_now = utc_now.replace(tzinfo=pytz.utc)
from sqlalchemy.exc import IntegrityError
if not self.timelog:
try:
new_time_log = TimeLog(
task=task,
resource=resource,
start=utc_start_date,
end=utc_end_date,
description=description,
date_created=utc_now
)
except (OverBookedError, DependencyViolationError) as e:
# inform the user that it can not do that
QtWidgets.QMessageBox.critical(
self,
'Error',
'%s' % e
)
DBSession.rollback()
return
try:
DBSession.add(new_time_log)
DBSession.commit()
self.timelog_created = True
except IntegrityError as e:
DBSession.rollback()
QtWidgets.QMessageBox.critical(
self,
'Error',
'Database Error!!!'
'<br>'
'%s' % e
)
return
else:
# just update the date values
self.timelog.start = utc_start_date
self.timelog.end = utc_end_date
self.timelog.date_updated = utc_now
DBSession.add(self.timelog)
DBSession.commit()
if self.no_time_left:
# we have no time left so automatically extend the task
from stalker import Task
schedule_timing, schedule_unit = \
task.least_meaningful_time_unit(
task.total_logged_seconds
)
if schedule_timing != 0:
task.schedule_timing = schedule_timing
task.schedule_unit = schedule_unit
# also create a Note
from stalker import Note
new_note = Note(
content='Extending timing of the task <b>%s h %s min.</b>' % (
self.extended_hours,
self.extended_minutes
),
type=revision_type,
created_by=self.logged_in_user,
date_created=utc_now
)
DBSession.add(new_note)
task.notes.append(new_note)
try:
DBSession.commit()
except IntegrityError as e:
QtWidgets.QMessageBox.critical(
self,
'Error',
'Database Error!!!'
'<br>'
'%s' % e
)
DBSession.rollback()
return
if is_complete:
# set the status to complete
from stalker import Type, Status
status_cmpl = Status.query.filter(Status.code == 'CMPL').first()
forced_status_type = \
Type.query.filter(Type.name == 'Forced Status').first()
# also create a Note
from stalker import Note
new_note = Note(
content='%s has changed this task status to Completed' %
resource.name,
type=forced_status_type,
created_by=self.logged_in_user,
date_created=utc_now
)
DBSession.add(new_note)
task.notes.append(new_note)
task.status = status_cmpl
DBSession.commit()
elif submit_to_final_review:
# clip the Task timing to current time logs
from stalker import Task
schedule_timing, schedule_unit = \
task.least_meaningful_time_unit(
task.total_logged_seconds
)
task.schedule_timing = schedule_timing
task.schedule_unit = schedule_unit
DBSession.add(task)
try:
DBSession.commit()
except IntegrityError as e:
QtWidgets.QMessageBox.critical(
self,
'Error',
'Database Error!!!'
'<br>'
'%s' % e
)
DBSession.rollback()
return
# request a review
reviews = task.request_review()
for review in reviews:
review.created_by = review.updated_by = self.logged_in_user
review.date_created = utc_now
review.date_updated = utc_now
DBSession.add_all(reviews)
# and create a Note for the Task
request_review_note_type = \
Type.query\
.filter(Type.target_entity_type == 'Note')\
.filter(Type.name == 'Request Review')\
.first()
from stalker import Note
request_review_note = Note(
type=request_review_note_type,
created_by=self.logged_in_user,
date_created=utc_now
)
DBSession.add(request_review_note)
DBSession.add(task)
task.notes.append(request_review_note)
try:
DBSession.commit()
except IntegrityError as e:
DBSession.rollback()
QtWidgets.QMessageBox.critical(
self,
'Error',
'Database Error!!!'
'<br>'
'%s' % e
)
return
# Fix statuses
from anima import utils
utils.fix_task_statuses(task)
try:
DBSession.commit()
except IntegrityError as e:
DBSession.rollback()
QtWidgets.QMessageBox.critical(
self,
'Error',
'Database Error!!!'
'<br>'
'%s' % e
)
return
# if nothing bad happens close the dialog
super(MainDialog, self).accept()
def accept(self):
"""overridden accept method
"""
# get the info
task = self.tasks_comboBox.currentTask()
resource = self.get_current_resource()
# war the user if the resource is not the logged_in_user
if resource != self.logged_in_user:
msg_box = QtWidgets.QMessageBox(self)
msg_box.setWindowTitle('Baskasi Adina TimeLog Giriyorsun')
msg_box.setText('Baskasi adina TimeLog giriyorsun???')
accept_button = msg_box.addButton('Sorumlulugu Kabul Ediyorum',
QtWidgets.QMessageBox.AcceptRole)
cancel_button = msg_box.addButton('Cancel',
QtWidgets.QMessageBox.RejectRole)
msg_box.setDefaultButton(cancel_button)
msg_box.exec_()
clicked_button = msg_box.clickedButton()
if clicked_button == cancel_button:
return
description = self.description_plainTextEdit.toPlainText()
revision_cause_text = \
self.revision_type_comboBox.currentText().replace(' ', '_')
is_complete = self.set_as_complete_radioButton.isChecked()
submit_to_final_review = \
self.submit_for_final_review_radioButton.isChecked()
# get the revision Types
from stalker import Type
revision_type = Type.query\
.filter(Type.target_entity_type == 'Note')\
.filter(Type.name == revision_cause_text)\
.first()
date = self.calendarWidget.selectedDate()
start = self.start_timeEdit.time()
end = self.end_timeEdit.time()
# construct proper datetime.DateTime instances
import datetime
start_date = datetime.datetime(date.year(), date.month(), date.day(),
start.hour(), start.minute())
end_date = datetime.datetime(date.year(), date.month(), date.day(),
end.hour(), end.minute())
today_midnight = datetime.datetime.now().replace(hour=23,
minute=59,
second=59,
microsecond=999)
# raise an error if the user is trying to enter a TimeLog to the future
if start_date > today_midnight or end_date > today_midnight:
QtWidgets.QMessageBox.critical(
self,
'Error',
'Gelecege TimeLog giremezsiniz!!!',
)
return
# convert them to utc
from anima.utils import local_to_utc
utc_start_date = local_to_utc(start_date)
utc_end_date = local_to_utc(end_date)
# create a TimeLog
# print('Task : %s' % task.name)
# print('Resource : %s' % resource.name)
# print('utc_start_date: %s' % utc_start_date)
# print('utc_end_date : %s' % utc_end_date)
# now if we are not using extra time just create the TimeLog
from stalker import db, TimeLog
from stalker.exceptions import OverBookedError
utc_now = local_to_utc(datetime.datetime.now())
if not self.timelog:
try:
new_time_log = TimeLog(task=task,
resource=resource,
start=utc_start_date,
end=utc_end_date,
description=description,
date_created=utc_now)
except OverBookedError:
# inform the user that it can not do that
QtWidgets.QMessageBox.critical(
self, 'Error', 'O saatte baska time log var!!!')
return
from sqlalchemy.exc import IntegrityError
try:
db.DBSession.add(new_time_log)
db.DBSession.commit()
self.timelog_created = True
except IntegrityError as e:
QtWidgets.QMessageBox.critical(
self, 'Error', 'Database hatasi!!!'
'<br>'
'%s' % e)
db.DBSession.rollback()
return
else:
# just update the date values
self.timelog.start = utc_start_date
self.timelog.end = utc_end_date
self.timelog.date_updated = utc_now
db.DBSession.add(self.timelog)
db.DBSession.commit()
if self.no_time_left:
# we have no time left so automatically extend the task
from stalker import Task
schedule_timing, schedule_unit = \
task.least_meaningful_time_unit(
task.total_logged_seconds
)
if schedule_timing != 0:
task.schedule_timing = schedule_timing
task.schedule_unit = schedule_unit
# also create a Note
from stalker import Note
new_note = Note(
content='Extending timing of the task <b>%s h %s min.</b>' %
(self.extended_hours, self.extended_minutes),
type=revision_type,
created_by=self.logged_in_user,
date_created=local_to_utc(datetime.datetime.now()))
db.DBSession.add(new_note)
task.notes.append(new_note)
try:
db.DBSession.commit()
except IntegrityError as e:
QtWidgets.QMessageBox.critical(
self, 'Error', 'Database hatasi!!!'
'<br>'
'%s' % e)
db.DBSession.rollback()
return
if is_complete:
# set the status to complete
from stalker import Type, Status
status_cmpl = Status.query.filter(Status.code == 'CMPL').first()
forced_status_type = \
Type.query.filter(Type.name == 'Forced Status').first()
# also create a Note
from stalker import Note
new_note = Note(
content='%s has changed this task status to Completed' %
resource.name,
type=forced_status_type,
created_by=self.logged_in_user,
date_created=local_to_utc(datetime.datetime.now()))
db.DBSession.add(new_note)
task.notes.append(new_note)
task.status = status_cmpl
db.DBSession.commit()
task.update_parent_statuses()
db.DBSession.commit()
elif submit_to_final_review:
# clip the Task timing to current time logs
from stalker import Task
schedule_timing, schedule_unit = \
task.least_meaningful_time_unit(
task.total_logged_seconds
)
task.schedule_timing = schedule_timing
task.schedule_unit = schedule_unit
db.DBSession.add(task)
try:
db.DBSession.commit()
except IntegrityError as e:
QtWidgets.QMessageBox.critical(
self, 'Error', 'Database hatasi!!!'
'<br>'
'%s' % e)
db.DBSession.rollback()
return
# request a review
reviews = task.request_review()
utc_now = local_to_utc(datetime.datetime.now())
for review in reviews:
review.created_by = review.updated_by = self.logged_in_user
review.date_created = utc_now
review.date_updated = utc_now
db.DBSession.add_all(reviews)
# and create a Note for the Task
request_review_note_type = \
Type.query\
.filter(Type.target_entity_type == 'Note')\
.filter(Type.name == 'Request Review')\
.first()
from stalker import Note
request_review_note = Note(type=request_review_note_type,
created_by=self.logged_in_user,
date_created=local_to_utc(
datetime.datetime.now()))
db.DBSession.add(request_review_note)
db.DBSession.add(task)
task.notes.append(request_review_note)
try:
db.DBSession.commit()
except IntegrityError as e:
QtWidgets.QMessageBox.critical(
self, 'Error', 'Database hatasi!!!'
'<br>'
'%s' % e)
db.DBSession.rollback()
return
# if nothing bad happens close the dialog
super(MainDialog, self).accept()
