def commit(self, data):
# TODO make with threads
stype = self.get_stype()
project = stype.get_project()
if self.view == 'edit':
# Logging info
dl.log('Making Commit Update for {}'.format(
stype.get_pretty_name()),
group_id=stype.get_code())
runtime_command = 'thenv.get_tc().server_start(project="{0}").update("{1}", {2})'.format(
project.get_code(), self.get_search_key(), str(data))
dl.info(runtime_command, group_id=stype.get_code())
return tc.server_start(project=project.get_code()).update(
self.get_search_key(), data)
else:
# Logging info
dl.log('Making Commit Insert for {}'.format(
stype.get_pretty_name()),
group_id=stype.get_code())
runtime_command = 'thenv.get_tc().server_start(project="{0}").insert("{1}", {2}, parent_key="{3}")'.format(
project.get_code(), self.get_search_type(), str(data),
self.get_parent_search_key())
dl.info(runtime_command, group_id=stype.get_code())
return tc.server_start(project=project.get_code()).insert(
self.get_search_type(),
data,
parent_key=self.get_parent_search_key())
def save_preset_to_server(self, preset_name=None, pretty_preset_name=None):
if not preset_name:
idx = self.presets_combo_box.currentIndex()
preset_name = self.presets_combo_box.itemData(idx)
server = tc.server_start()
data = self.get_preset_config(preset_name, pretty_preset_name)
search_type = 'sthpw/wdg_settings'
# Checking for existing key
filters = [('key', data['key'])]
columns = ['code', 'project']
widget_settings = server.query(search_type,
filters,
columns,
single=True)
if widget_settings:
code = widget_settings['code']
project = widget_settings['project']
search_key = server.build_search_key(search_type, code, project)
server.insert_update(search_key, data, triggers=False)
else:
tc.server_start().insert(search_type, data, triggers=False)
self.get_all_presets_from_server()
self.fill_presets_combo_box(preset_name)
def subscriptions_query(self):
import collections
stub = tc.server_start()
all_sobjects = tc.query_tab_names(True)
filters = [('login', env.Env.get_user()), ('project_code', env.Env.get_project())]
subscriptions = stub.query('sthpw/subscription', filters)
spl = collections.defaultdict(list)
for sub in subscriptions:
split = stub.split_search_key(sub['message_code'])
spl[split[0]].append(split[1])
parents = collections.defaultdict(list)
for key, values in spl.items():
parents[key.split('?')[0]] = \
tc.get_sobjects(sobjects_list=stub.query(key, [('code', values)]), get_snapshots=False)
pprint(all_sobjects)
pprint(dict(parents))
# print(stub.get_parent('cgshort/shot?project=the_pirate&code=SHOT00001'))
server = tc.server_start()
expr = "@GET(cgshort/shot.cgshort/scenes.code)"
result = server.eval(expr)
pprint(result)
pprint(stub.query('cgshort/shot', [('scenes_code', 'SCENES00001')]))
def save_current_script(self):
script_folder = self.first_path_part_line_edit.text()
script_title = self.second_path_part_line_edit.text()
current_language = self.get_current_script_language()[1]
if script_folder and script_title:
script_sobject = self.get_current_script_sobject()
if script_sobject:
script_sobject.set_value('script', self.get_current_script())
script_sobject.set_value('language', current_language)
script_sobject.set_value('folder', script_folder)
script_sobject.set_value('title', script_title)
script_sobject.commit(False)
else:
search_type = tc.server_start().build_search_type(
'config/custom_script',
project_code=env_inst.get_current_project())
filters = [('script', self.get_current_script()),
('folder', script_folder), ('title', script_title),
('language', current_language)]
tc.server_start().insert(search_type, dict(filters))
self.refresh_scripts_tree()
def commit_multiple_task(self, changed_data):
print 'COMMINT MULTIPLE', self.current_task_sobject
do_commit = False
data = {}
for column, val in changed_data.items():
if val not in ['--user--', '--status--']:
do_commit = True
if self.current_task_sobject:
self.current_task_sobject.set_value(column, val)
else:
# If no current tasks we create it later
data[column] = val
elif self.initial_task_data_dict.get(column) != val:
if self.current_task_sobject:
do_commit = True
self.current_task_sobject.set_value(column, '')
print do_commit, data
if do_commit:
data['process'] = self.process
# update multiple sobjects
for task_sobject in self.tasks_sobjects_list:
print task_sobject.get_search_key()
# insert new sobjects if it doesn't created earlier
print data
for sobject in self.parent_sobjects_list:
print sobject.get_search_key()
tc.server_start(project=self.parent_sobject.project.get_code(
)).insert_multiple('sthpw/task',
data,
parent_key=self.parent_sobject.get_search_key(),
triggers=True)
def simple_save_task(self):
self.save_task_button.setHidden(True)
changed_data = self.get_changed_data()
# fetching data to commit
if changed_data:
do_commit = False
data = {}
for column, val in changed_data.items():
if val not in ['--user--', '--status--']:
do_commit = True
if self.current_task_sobject:
self.current_task_sobject.set_value(column, val)
else:
# If no current tasks we create it later
data[column] = val
elif self.initial_task_data_dict.get(column) != val:
if self.current_task_sobject:
do_commit = True
self.current_task_sobject.set_value(column, '')
if do_commit:
if self.current_task_sobject:
self.current_task_sobject.commit(triggers=True)
else:
data['process'] = self.process
tc.server_start(
project=self.parent_sobject.project.get_code()).insert(
'sthpw/task',
data,
parent_key=self.parent_sobject.get_search_key(),
triggers=True)
self.refresh_tasks_sobjects()
else:
self.set_empty_task()
def select_current_tree_widget_item(self):
selected_items = self.usersTreeWidget.selectedItems()
if selected_items:
# print selected_items[0]
# print selected_items[0].data(0, QtCore.Qt.UserRole)
item_data = selected_items[0].data(0, QtCore.Qt.UserRole)
if item_data.get_object_type() == 'login':
# print item_data.get_subscriptions()
print item_data
import random
key = random.randrange(0, 255)
tc.server_start().subscribe(key, category='chat')
def post_reply(self, chat_widget, chat_subscription, partner_login, reply_text):
key = chat_subscription.get_message_code()
message = reply_text
category = 'chat'
tc.server_start().log_message(key, message, category=category, status='in_progress')
chat_widget.clear()
# current_login.get_subscriptions_and_messages(True)
self.fill_chat_messages(chat_widget, chat_subscription, partner_login)
print reply_text
def get_all_presets_from_server(self):
server = tc.server_start()
key = 'search_type:{0}'.format(self.stype.get_code())
search_type = 'sthpw/wdg_settings'
project_code = self.stype.get_project().get_code()
filters = [('key', 'like', '{0}%'.format(key)),
('project_code', project_code)]
columns = ['data']
presets = server.query(search_type, filters, columns)
if not presets:
self.presets_list = [{
'pretty_preset_name': 'Default',
'preset_name': 'default',
}]
else:
new_presets_list = []
for preset in presets:
new_presets_list.append(gf.from_json(preset['data']))
self.presets_list = new_presets_list
def check_name_uniqueness(self, data):
name = data.get('name')
if not name:
return True
search_type = self.tactic_widget.get_search_type()
if not search_type and self.sobject:
search_key_split = tc.split_search_key(self.sobject.get_search_key())
search_type = search_key_split.get('search_type')
if name and search_type:
filters = [('name', name)]
project = self.stype.get_project()
existing = tc.server_start(project=project.get_code()).query(search_type, filters)
if self.get_view() == 'edit':
# check if we editing and leaved the same name, not warn about uniqueness
if self.init_data.get('name') == name:
existing = False
if existing:
msb = QtGui.QMessageBox(QtGui.QMessageBox.Question, 'This Name already used!',
"Do you want to use this name anyway?",
QtGui.QMessageBox.NoButton, self)
msb.addButton("Yes", QtGui.QMessageBox.YesRole)
msb.addButton("No", QtGui.QMessageBox.NoRole)
msb.exec_()
reply = msb.buttonRole(msb.clickedButton())
if reply == QtGui.QMessageBox.YesRole:
return True
elif reply == QtGui.QMessageBox.NoRole:
return False
return True
def commit(self, data):
# TODO make with threads
# print 'BEGIN SAVING', data
stype = self.get_stype()
parent_stype = self.get_parent_stype()
if parent_stype:
project = parent_stype.get_project()
else:
project = stype.get_project()
if self.view == 'edit':
# Logging info
dl.log('Making Commit Update for {}'.format(
stype.get_pretty_name()),
group_id=stype.get_code())
runtime_command = 'thenv.get_tc().server_start(project="{0}").update("{1}", {2})'.format(
project.get_code(), self.get_search_key(), str(data))
dl.info(runtime_command, group_id=stype.get_code())
return tc.server_start(project=project.get_code()).update(
self.get_search_key(), data)
else:
instance_type = None
instance_type_str = None
sobject = self.get_sobject()
if sobject:
parent_stype = sobject.get_stype()
schema = self.stype.get_schema()
child = schema.get_child(parent_stype.get_code(),
self.stype.get_code())
if child:
relationship = child.get('relationship')
if relationship == 'instance':
instance_type = child.get('instance_type')
# Logging info
dl.log('Making Commit Insert for {}'.format(
stype.get_pretty_name()),
group_id=stype.get_code())
parent_key = self.get_parent_search_key()
if parent_key:
parent_key = '"{}"'.format(parent_key)
if instance_type:
instance_type_str = '"{}"'.format(instance_type)
runtime_command = u'thenv.get_tc().insert_sobjects("{0}", "{1}", {2}, parent_key={3}, instance_type={4})'.format(
self.get_search_type(), project.get_code(), str(data),
parent_key, instance_type_str)
dl.info(runtime_command, group_id=stype.get_code())
return tc.insert_sobjects(self.get_search_type(),
project.get_code(),
data,
parent_key=self.get_parent_search_key(),
instance_type=instance_type)
def dynamic_query(self, limit=0, offset=0):
filters = []
order_bys = ['timestamp desc']
columns = []
# sobjects_list = tc.server_start(project=env_inst.current_project).query(self.current_stype, filters, columns, order_bys, limit=limit, offset=offset)
# print self.current_stype
# print sobjects_list
# print filters
search_type = tc.server_start().build_search_type(
self.current_stype, env_inst.current_project)
# all_process = self.context_items[self.current_stype]
# sobjects = tc.get_sobjects(all_process, sobjects_list)
# sobjects = tc.get_sobjects_objects(sobjects_list, env_inst.current_project)
sobjects = tc.get_sobjects(
search_type=search_type,
project_code=env_inst.current_project,
filters=filters,
order_bys=order_bys,
limit=limit,
offset=offset,
include_info=False,
include_snapshots=True,
)
return sobjects
def query_widgets(kwargs):
code = tq.prepare_serverside_script(tq.query_EditWdg,
kwargs,
return_dict=True)
result = tq.get_result(
tc.server_start(project=kwargs['project']).execute_python_script(
'', kwargs=code))
return json.loads(result)
def run_script(self):
code = self.scriptTextEdit.toPlainText()
code_dict = {
'code': code
}
result = tc.server_start().execute_python_script('', kwargs=code_dict)
import pprint
if not result['info']['spt_ret_val']:
self.stackTraceTextEdit.setText(str(result['status']))
else:
self.stackTraceTextEdit.setText(pprint.pformat(result['info']['spt_ret_val']))
def dynamic_query(self, limit=0, offset=0):
filters = []
order_bys = ['timestamp desc']
columns = []
sobjects_list = tc.server_start().query(self.current_stype, filters, columns, order_bys, limit=limit, offset=offset)
print self.current_stype
print sobjects_list
print filters
all_process = self.context_items[self.current_stype]
sobjects = tc.get_sobjects(all_process, sobjects_list)
return sobjects
def query_base_dirs(self):
import thlib.tactic_classes as tc
default_base_dirs = tc.server_start().get_base_dirs()
self.default_base_dirs = default_base_dirs
unique_id = '{0}/environment_config/server_presets'.format(
env_mode.node)
tactic_dirs_filename = 'tactic_dirs_{}'.format(
env_server.get_cur_srv_preset())
env_write_config(default_base_dirs,
filename=tactic_dirs_filename,
unique_id=unique_id,
sub_id='TACTIC_DEFAULT_DIRS',
update_file=True)
return default_base_dirs
def create_parent_widget(self):
self.parent_tree_widget = QtGui.QTreeWidget()
self.parent_tree_widget.setTabKeyNavigation(True)
self.parent_tree_widget.setVerticalScrollMode(
QtGui.QAbstractItemView.ScrollPerPixel)
self.parent_tree_widget.setRootIsDecorated(False)
self.parent_tree_widget.setAllColumnsShowFocus(True)
self.parent_tree_widget.setWordWrap(True)
self.parent_tree_widget.setHeaderHidden(True)
self.parent_tree_widget.setSelectionMode(
QtGui.QAbstractItemView.ExtendedSelection)
self.parent_tree_widget.setObjectName("parent_tree_widget")
search_type = tc.server_start().build_search_type(
self.stype.get_code(), self.stype.project.get_code())
sobjects, data = tc.get_sobjects_new(search_type=search_type,
filters=[],
order_bys=['name'])
self.parent_tree_widget.clear()
for sobject in sobjects.itervalues():
item_info = {
'relates_to': 'checkin_out',
'sep_versions': True,
'children_states': None,
'simple_view': True,
}
gf.add_sobject_item(
self.parent_tree_widget,
self,
sobject,
self.stype,
item_info,
ignore_dict=None,
)
self.parent_vertical_layout.addWidget(self.parent_tree_widget)
def save_all_changes(self):
if self.multiple_mode:
data_to_update = {}
for item in self.items:
update_dict = {}
for column_widget in self.columns_widgets:
changed_data = column_widget.get_changed_data()
if changed_data is not None:
update_dict[column_widget.get_column()] = changed_data
if self.item.type == 'snapshot':
sobject = item.get_snapshot()
sobject.project = self.project # Snapshot class created without project in it
else:
sobject = item.get_sobject()
data_to_update[sobject.get_search_key()] = update_dict
return tc.server_start(
project=self.project.get_code()).update_multiple(
data=data_to_update, triggers=True)
else:
if self.item.type == 'snapshot':
sobject = self.item.get_snapshot()
sobject.project = self.project # Snapshot class created without project in it
else:
sobject = self.item.get_sobject()
for column_widget in self.columns_widgets:
changed_data = column_widget.get_changed_data()
if changed_data is not None:
sobject.set_value(column_widget.get_column(), changed_data)
sobject.commit()
def delete_preset_from_server(self, preset_name=None):
if not preset_name:
idx = self.presets_combo_box.currentIndex()
preset_name = self.presets_combo_box.itemData(idx)
# ask before delete
buttons = (('Yes', QtGui.QMessageBox.YesRole), ('Cancel', QtGui.QMessageBox.NoRole))
reply = gf.show_message_predefined(
'Removing preset from server',
u'Are You sure want to remove <b>" {0} "</b> preset from Server?'.format(preset_name),
buttons=buttons,
message_type='question',
parent=self
)
if reply == QtGui.QMessageBox.YesRole:
server = tc.server_start()
data = self.get_preset_config(preset_name)
search_type = 'sthpw/wdg_settings'
# Checking for existing key
filters = [('key', data['key'])]
columns = ['code', 'project']
widget_settings = server.query(search_type, filters, columns, single=True)
search_key = widget_settings['__search_key__']
server.delete_sobject(search_key)
self.get_all_presets_from_server()
self.fill_presets_combo_box(preset_name)
