def GET(self):
method = self.kwargs.get("method")
print self.kwargs
print "method: ", method
print "expression: ", self.kwargs.get("expression")
# /rest/get_by_code/cars/CAR00009
# /rest/query?search_type=sthpw/cars
if method == "query":
code = self.kwargs.get("data")
from pyasm.search import Search
sobject = Search.get_by_code(search_type, code)
sobject_dict = sobject.get_sobject_dict()
return sobject_dict
# /rest/expression/@SOBJECT(sthpw/task)
elif method == "expression":
expression = self.kwargs.get("expression")
server = TacticServerStub.get()
return server.eval(expression)
# /rest/simple_checkin?search_key=dfadfdsas&data={}
elif method == "expression":
expression = self.kwargs.get("expression")
server = TacticServerStub.get()
return server.eval(expression)
return {}
def GET(my):
method = my.kwargs.get("method")
print my.kwargs
print "method: ", method
print "expression: ", my.kwargs.get("expression")
# /rest/get_by_code/cars/CAR00009
# /rest/query?search_type=sthpw/cars
if method == "query":
code = my.kwargs.get("data")
from pyasm.search import Search
sobject = Search.get_by_code(search_type, code)
sobject_dict = sobject.get_sobject_dict()
return sobject_dict
# /rest/expression/@SOBJECT(sthpw/task)
elif method == "expression":
expression = my.kwargs.get("expression")
server = TacticServerStub.get()
return server.eval(expression)
# /rest/simple_checkin?search_key=dfadfdsas&data={}
elif method == "expression":
expression = my.kwargs.get("expression")
server = TacticServerStub.get()
return server.eval(expression)
return {}
def update_related(self, login_group, prev_login_group):
'''Update related table login_in_group'''
search = Search('sthpw/login_in_group')
search.add_filter('login_group', prev_login_group)
login_in_groups = search.get_sobjects()
if login_in_groups:
server = TacticServerStub.get()
login_in_group_dict = {}
data = {"login_group": login_group}
for login_in_group in login_in_groups:
login_in_group_code = login_in_group.get("code")
login_in_group_sk = server.build_search_key(
"sthpw/login_in_group", login_in_group_code)
login_in_group_dict[login_in_group_sk] = data
try:
server.update_multiple(login_in_group_dict)
except Exception, e:
raise TacticException('Error updating login_in_group %s' %
e.str())
def execute(my):
#protocol = 'xmlrpc'
protocol = 'local'
if protocol == 'local':
server = TacticServerStub.get()
else:
server = TacticServerStub(protocol=protocol, setup=False)
TacticServerStub.set(server)
project = my.data.get("project")
ticket = my.data.get("ticket")
assert project
assert ticket
server.set_server("localhost")
server.set_project(project)
server.set_ticket(ticket)
my.class_name = my.data.get('class_name')
assert my.class_name
my.kwargs = my.data.get('kwargs')
if not my.kwargs:
my.kwags = {}
#trigger = eval("%s(**my.kwargs)" % my.class_name)
trigger = Common.create_from_class_path(my.class_name,
kwargs=my.kwargs)
input_data = my.get_input_data()
trigger.set_input(input_data)
trigger.execute()
def execute(my):
#protocol = 'xmlrpc'
protocol = 'local'
if protocol == 'local':
server = TacticServerStub.get()
else:
server = TacticServerStub(protocol=protocol, setup=False)
TacticServerStub.set(server)
project = my.data.get("project")
ticket = my.data.get("ticket")
assert project
assert ticket
server.set_server("localhost")
server.set_project(project)
server.set_ticket(ticket)
my.class_name = my.data.get('class_name')
assert my.class_name
# get the script to run
script_code = my.data.get("script_code")
if script_code:
search_type = "config/custom_script"
search_key = server.build_search_key(search_type, script_code)
script_obj = server.get_by_search_key(search_key)
script = script_obj.get('script')
my.run_script(script)
else:
print "Nothing to run"
def execute(my):
#protocol = 'xmlrpc'
protocol = 'local'
if protocol == 'local':
server = TacticServerStub.get()
else:
server = TacticServerStub(protocol=protocol,setup=False)
TacticServerStub.set(server)
project = my.data.get("project")
ticket = my.data.get("ticket")
assert project
assert ticket
server.set_server("localhost")
server.set_project(project)
server.set_ticket(ticket)
my.class_name = my.data.get('class_name')
assert my.class_name
my.kwargs = my.data.get('kwargs')
if not my.kwargs:
my.kwags = {}
#trigger = eval("%s(**my.kwargs)" % my.class_name)
trigger = Common.create_from_class_path(my.class_name, kwargs=my.kwargs)
input_data = my.get_input_data()
trigger.set_input(input_data)
trigger.execute()
def execute(my):
#protocol = 'xmlrpc'
protocol = 'local'
if protocol == 'local':
server = TacticServerStub.get()
else:
server = TacticServerStub(protocol=protocol,setup=False)
TacticServerStub.set(server)
project = my.data.get("project")
ticket = my.data.get("ticket")
assert project
assert ticket
server.set_server("localhost")
server.set_project(project)
server.set_ticket(ticket)
my.class_name = my.data.get('class_name')
assert my.class_name
# get the script to run
script_code = my.data.get("script_code")
if script_code:
search_type = "config/custom_script"
search_key = server.build_search_key(search_type, script_code)
script_obj = server.get_by_search_key(search_key)
script = script_obj.get('script')
my.run_script(script)
else:
print "Nothing to run"
def accesshandler(request):
cookies = Cookie.get_cookies(request)
# if login ticket cookie does not exist, then deny
if not cookies.has_key('login_ticket'):
# just refuse access
return apache.HTTP_FORBIDDEN
ticket = cookies['login_ticket'].value
if not ticket:
return apache.HTTP_FORBIDDEN
server = TacticServerStub.get(protocol='local')
expr = "@SOBJECT(sthpw/ticket['ticket','%s'])" % ticket
sobject = server.eval(expr, single=True)
now = SPTDate.now()
expiry = sobject.get("expiry")
if expiry and expiry < str(now):
return apache.HTTP_FORBIDDEN
request.add_common_vars()
path = str(request.subprocess_env['REQUEST_URI'])
if path == None:
return apache.HTTP_FORBIDDEN
# FIXME: find some mechanism which is more acceptable ... like /icons
#if path.find("_icon_") != -1:
# return apache.OK
return apache.OK
def main(server=None, input_data=None):
if not input_data:
input_data = {}
if not server:
server = TacticServerStub.get()
input_sobject = input_data.get('sobject')
order_code = input_sobject.get('code')
priority = input_sobject.get('priority')
component_search = Search('twog/component')
component_search.add_filter('order_code', order_code)
component_sobjects = component_search.get_sobjects()
for component_sobject in component_sobjects:
tasks = get_task_sobjects_from_component_sobject(component_sobject)
data_to_insert = {}
for task in tasks:
task_search_key = server.build_search_key('sthpw/task', task.get_code(), project_code='twog')
data_to_insert[task_search_key] = {'priority': priority}
server.update_multiple(data_to_insert)
def get_client_img(client_code):
img_path = ''
client_search = Search("twog/client")
client_search.add_filter('code', client_code)
client_search_object = client_search.get_sobject()
if client_search_object:
client_id = client_search_object.get_id()
snaps_s = Search("sthpw/snapshot")
snaps_s.add_filter('search_id', client_id)
snaps_s.add_filter('search_type', 'twog/client?project=twog')
snaps_s.add_filter('is_current', '1')
snaps_s.add_filter('version', '0', op='>')
snaps_s.add_where("\"context\" in ('publish','icon','MISC')")
snaps_s.add_order_by('timestamp desc')
snaps = snaps_s.get_sobjects()
if len(snaps) > 0:
server = TacticServerStub.get()
snap = snaps[0]
img_path = server.get_path_from_snapshot(snap.get_code(), mode="web")
if img_path:
img_path = 'http://' + server.get_server_name() + img_path
return img_path
else:
return None
def init(my):
from client.tactic_client_lib import TacticServerStub
from pyasm.common import Environment
my.server = TacticServerStub.get()
my.login = Environment.get_login()
my.user = my.login.get_login()
my.movement_code = my.kwargs.get('movement_code')
def get_input_state(self, sobject, process):
pipeline = Pipeline.get_by_sobject(sobject)
# use the first input process
input_processes = pipeline.get_input_processes(process)
if not input_processes:
return {}
# get the first process for now
p = input_processes[0]
process_name = p.get_name()
key = self.get_state_key(sobject, process_name)
from tactic_client_lib import TacticServerStub
server = TacticServerStub.get()
from pyasm.common import jsonloads
message = server.get_message(key)
message = message.get("message")
if not message:
state = {}
else:
state = jsonloads(message)
return state
def init(my):
from client.tactic_client_lib import TacticServerStub
from pyasm.common import Environment
my.server = TacticServerStub.get()
my.sk = ''
my.code = ''
my.name = ''
def get_display(my):
from tactic_client_lib import TacticServerStub
server = TacticServerStub.get()
print "MY.KWARGS = %s" % my.kwargs
title_codes = my.kwargs.get('title_codes').split('|')
order_titles = {}
for title_code in title_codes:
title = server.eval("@SOBJECT(twog/title['code','%s'])" % title_code)
if title:
title = title[0]
order_code = title.get('order_code')
if order_code not in order_titles.keys():
order = server.eval("@SOBJECT(twog/order['code','%s'])" % order_code)[0]
order_titles[order_code] = {'order': order, 'titles': []}
order_titles[order_code]['titles'].append(title)
widget = DivWdg()
table = Table()
for order_code in order_titles.keys():
table.add_row()
table.add_cell('ORDER: %s' % order_titles[order_code]['order'].get('name'))
for title in order_titles[order_code]['titles']:
table.add_row()
title_name = title.get('title')
if title.get('episode') not in [None,'']:
title_name = '%s: %s' % (title_name, title.get('episode'))
table.add_cell('TITLE: %s' % title_name)
widget.add(table)
return widget
def get_subject(my):
from tactic_client_lib import TacticServerStub
server = TacticServerStub.get()
eq = my.sobject
equipment_name = eq.get_value('name')
work_order_code = eq.get_value('work_order_code')
work_order = None
proj = None
title = None
order = None
if work_order_code not in [None,'']:
work_order = server.eval("@SOBJECT(twog/work_order['code','%s'])" % work_order_code)[0]
proj = server.eval("@SOBJECT(twog/proj['code','%s'])" % work_order.get('proj_code'))[0]
title = server.eval("@SOBJECT(twog/title['code','%s'])" % proj.get('title_code'))[0]
order = server.eval("@SOBJECT(twog/order['code','%s'])" % title.get('order_code'))[0]
po_number = ''
order_name = ''
title_title = ''
title_episode = ''
proj_code = ''
if order:
po_number = order.get('po_number')
order_name = order.get('name')
if title:
title_title = title.get('title')
title_episode = title.get('episode')
if proj:
proj_code = proj.get('code')
subject = 'Equipment Added by Operator in %s (%s), to %s: %s-%s-%s ' % (order_name, po_number, title_title, title_episode, proj_code, work_order_code)
return subject
def get_to(my):
from tactic_client_lib import TacticServerStub
from pyasm.common import Environment
recipients = set()
to = '*****@*****.**'
login_obj = Environment.get_login()
login = login_obj.get_login()
server = TacticServerStub.get()
eq = my.sobject
wo_code = eq.get_value('work_order_code')
if wo_code not in [None,'']:
wo = server.eval("@SOBJECT(twog/work_order['code','%s'])" % wo_code)
if wo:
wo = wo[0]
if wo.get('login') != login:
the_obj = Login.get_by_code(wo.get('login'))
if the_obj:
recipients.add(the_obj)
# creator_login_obj = server.eval("@SOBJECT(sthpw/login['login','%s'])" % wo.get('login'))
# if creator_login_obj:
# creator_login_obj = creator_login_obj[0]
# #to = creator_login_obj.get('email')
# to = creator_login_obj
print "RETURN Recipients: %s" % recipients
return recipients
def main(args):
# USAGE: create_project.py <project_code> <project_title> <project_type>
project_code = args[0]
project_title = args[1]
project_type = args[2]
assert project_type in ['prod','flash','simple','unittest']
assert project_title
regexs = '^\d|\W'
m = re.search(r'%s' % regexs, project_code)
if m:
raise TacticApiException('<project_code> cannot contain special characters or start with a number.')
server = TacticServerStub.get();
# do the actual work
server.start("Create Project", "Project creation for [%s] of type [%s]" % (project_code, project_type))
try:
args = {
'project_code': project_code,
'project_title': project_title,
'project_type': project_type}
class_name = "tactic.command.CreateProjectCmd";
ret_val = server.execute_cmd(class_name, args=args);
print ret_val
except:
server.abort()
raise
else:
server.finish()
def execute(self):
Container.put("TestApiHandler", "test_api_handler")
# test that you can run the client api from here
server = TacticServerStub.get()
server.start("Api Trigger test")
try:
test = server.ping()
Container.put("TestApiHandler/ping", test)
# do some more tests
search_type = "unittest/person"
code = "jack"
search_key = server.build_search_key(search_type, code)
Container.put("TestApiHandler/search_key", search_key)
# insert
data = { 'code': code }
server.insert(search_type, data)
# query
sobject = server.get_by_search_key(search_key)
Container.put("TestApiHandler/code", sobject.get('code'))
finally:
server.abort()
def execute(my):
server = TacticServerStub.get()
server.start("Starting city insert trigger",
"On inserting seoul, insert incheon")
try:
city_key = my.get_input_value("search_key")
mode = my.get_input_value("mode")
if mode == 'delete':
return
city = server.get_by_search_key(city_key)
if city.get('code') == 'seoul':
# make sure triggers=False to avoid infinite loop
server.insert('unittest/city', {
'code': 'incheon',
'country_code': 'korea'
},
triggers=False)
if city.get('code') == 'incheon':
raise TacticException(
'Should not have reached this point and fired this trigger.'
)
except:
server.abort()
raise
else:
server.finish()
def execute(self):
# ensure that the protocol is "local"
server = TacticServerStub.get()
if server.get_protocol() != "local":
raise Exception("TacticServerStub protocol is not 'local'")
# test some inputs
is_insert = self.get_input_value("is_insert")
if is_insert != True:
raise Exception("is_insert != True")
is_insert = self.get_input_value("is_insert")
if is_insert != True:
raise Exception("is_insert != True")
search_key = self.get_input_value('search_key')
if search_key != 'unittest/person?project=unittest&code=fred':
raise Exception("search_key != 'unittest/person?project=unittest&code=fred'")
prev_data = self.get_input_value('prev_data')
if prev_data.get('code') != None:
raise Exception("prev_data['code'] != None")
prev_data = self.get_input_value('update_data')
if prev_data.get('code') != 'fred':
raise Exception("update_data['code'] != 'fred'")
def execute(self):
# ensure that the protocol is "local"
server = TacticServerStub.get()
if server.get_protocol() != "local":
raise Exception("TacticServerStub protocol is not 'local'")
# test some inputs
is_insert = self.get_input_value("is_insert")
if is_insert != True:
raise Exception("is_insert != True")
is_insert = self.get_input_value("is_insert")
if is_insert != True:
raise Exception("is_insert != True")
search_key = self.get_input_value('search_key')
if search_key != 'unittest/person?project=unittest&code=fred':
raise Exception(
"search_key != 'unittest/person?project=unittest&code=fred'")
prev_data = self.get_input_value('prev_data')
if prev_data.get('code') != None:
raise Exception("prev_data['code'] != None")
prev_data = self.get_input_value('update_data')
if prev_data.get('code') != 'fred':
raise Exception("update_data['code'] != 'fred'")
def log_message(my, sobject, process, status):
# need to use API for now
key = "%s|%s|status" % (sobject.get_search_key(), process)
from tactic_client_lib import TacticServerStub
server = TacticServerStub.get()
server.log_message(key, status)
def execute(self):
Container.put("TestApiHandler", "test_api_handler")
# test that you can run the client api from here
server = TacticServerStub.get()
server.start("Api Trigger test")
try:
test = server.ping()
Container.put("TestApiHandler/ping", test)
# do some more tests
search_type = "unittest/person"
code = "jack"
search_key = server.build_search_key(search_type, code)
Container.put("TestApiHandler/search_key", search_key)
# insert
data = {'code': code}
server.insert(search_type, data)
# query
sobject = server.get_by_search_key(search_key)
Container.put("TestApiHandler/code", sobject.get('code'))
finally:
server.abort()
def accesshandler(request):
cookies = Cookie.get_cookies(request)
# if login ticket cookie does not exist, then deny
if not cookies.has_key('login_ticket'):
# just refuse access
return apache.HTTP_FORBIDDEN
ticket = cookies['login_ticket'].value
if not ticket:
return apache.HTTP_FORBIDDEN
server = TacticServerStub.get(protocol='local')
expr = "@SOBJECT(sthpw/ticket['ticket','%s'])" % ticket
sobject = server.eval(expr, single=True)
now = SPTDate.now()
expiry = sobject.get("expiry")
if expiry and expiry < str(now):
return apache.HTTP_FORBIDDEN
request.add_common_vars()
path = str(request.subprocess_env['REQUEST_URI'])
if path == None:
return apache.HTTP_FORBIDDEN
# FIXME: find some mechanism which is more acceptable ... like /icons
#if path.find("_icon_") != -1:
# return apache.OK
return apache.OK
def update_related(self, login_group, prev_login_group):
'''Update related table login_in_group'''
search = Search('sthpw/login_in_group')
search.add_filter('login_group', prev_login_group)
login_in_groups = search.get_sobjects()
if login_in_groups:
server = TacticServerStub.get()
login_in_group_dict = {}
data = {
"login_group": login_group
}
for login_in_group in login_in_groups:
login_in_group_code = login_in_group.get("code")
login_in_group_sk = server.build_search_key("sthpw/login_in_group", login_in_group_code)
login_in_group_dict[login_in_group_sk] = data
try:
server.update_multiple(login_in_group_dict)
except Exception, e:
raise TacticException('Error updating login_in_group %s' % e.str())
def add_task_to_component(self, process, component_code, login):
server = TacticServerStub.get()
component_search = Search('twog/component')
component_search.add_code_filter(component_code)
component = component_search.get_sobject()
server.insert('sthpw/task', {'process': process, 'login': login}, parent_key=component.get_search_key())
def init(self):
"""
The special tactic init.
:return: None
"""
super(SobjectEditLauncherWdg, self).init()
self.server = TacticServerStub.get()
def init(my):
from client.tactic_client_lib import TacticServerStub
from pyasm.common import Environment
my.server = TacticServerStub.get()
my.sk = ''
my.user = ''
my.groups = ''
my.login_group_rates = {}
def __init__(my, **kwargs):
from tactic_client_lib import TacticServerStub
my.server = TacticServerStub.get()
my.message_key = kwargs.get("message_key")
my.paths = kwargs.get("paths")
my.paths_sizes = kwargs.get("paths_sizes")
if not my.paths:
my.paths = []
def __init__(self, **kwargs):
from tactic_client_lib import TacticServerStub
self.server = TacticServerStub.get()
self.message_key = kwargs.get("message_key")
self.paths = kwargs.get("paths")
self.paths_sizes = kwargs.get("paths_sizes")
if not self.paths:
self.paths = []
def get_results(my):
code = my.kwargs.get("code")
script_path = my.kwargs.get("script_path")
file_path = my.kwargs.get("file_path")
# if a script path is specified, then get it from the custom_script
# table
if script_path:
folder = os.path.dirname(script_path)
title = os.path.basename(script_path)
search = Search("config/custom_script")
search.add_filter("folder", folder)
search.add_filter("title", title)
custom_script = search.get_sobject()
if not custom_script:
raise TacticException("Custom script with path [%s/%s] does not exist" % (folder, title) )
code = custom_script.get_value("script")
elif file_path:
f = open(file_path)
code = f.read()
f.close()
server = TacticServerStub.get(protocol='local')
server.login = Environment.get_user_name()
spt_mako_results = {}
#kwargs = {
# 'server': server,
# 'spt_mako_results': spt_mako_results
#}
code = '''
<%%def name='spt_run_code()'>
<%%
%s
%%>
</%%def>
<%%
spt_mako_results['spt_ret_val'] = spt_run_code()
%%>
''' % code
#template = Template(code, output_encoding='utf-8', input_encoding='utf-8')
try:
template = Template(code)
template.render(server=server,spt_mako_results=spt_mako_results, kwargs=my.kwargs,**my.kwargs)
except Exception, e:
print "Error in Mako code: "
print code
raise
def init(my):
from client.tactic_client_lib import TacticServerStub
from pyasm.common import Environment
my.server = TacticServerStub.get()
my.login = Environment.get_login()
my.user = my.login.get_login()
my.code = ''
my.types = ['Full_Work_Order']
my.template_files = {'Full_Work_Order': '/var/www/html/source_labels/work_order.html'}
def get_subject(my):
from tactic_client_lib import TacticServerStub
server = TacticServerStub.get()
print "SERVER = %s" % server
movement = my.sobject
movement_code = movement.get_code()
movement_name = movement.get_value('name')
subject = 'New Arrivals: %s' % movement_name
return subject
def execute(my):
base_dir = my.kwargs.get("base_dir")
relative_dir = my.kwargs.get("relative_dir")
file_name = my.kwargs.get("file_name")
to_path = my.kwargs.get("to_path")
from_path = "%s/./%s/%s" % (base_dir, relative_dir, file_name)
tries = 1
success = False
value = ""
start = time.time()
message_key = my.kwargs.get("message_key")
while 1:
try:
value = my.sync_paths(from_path, to_path)
success = True
break
except RSyncConnectionException, e:
time.sleep(60)
from tactic_client_lib import TacticServerStub
server = TacticServerStub.get()
server.log_message(message_key, {"message": str(e)}, "error_retry")
continue
except Exception, e:
print "Failed on try [%s]..." % tries
raise
# ping the server to see
if message_key:
from tactic_client_lib import TacticServerStub
server = TacticServerStub.get()
server.log_message(message_key, {"message": str(e)}, "error_retry")
time.sleep(tries)
if tries == 3:
break
tries += 1
def init(my):
my.server = TacticServerStub.get()
my.order_sk = str(my.kwargs.get('order_sk'))
my.parent_sk = my.kwargs.get('parent_sk')
my.parent_code = my.parent_sk.split('code=')[1]
if 'TITLE' in my.parent_code:
my.title_code = my.parent_code
else:
my.title_code = my.server.eval("@GET(twog/proj['code','%s'].title_code)" % my.parent_code)[0]
def init(my):
my.server = TacticServerStub.get()
my.order_sk = str(my.kwargs.get("order_sk"))
my.parent_sk = my.kwargs.get("parent_sk")
my.parent_code = my.parent_sk.split("code=")[1]
if "TITLE" in my.parent_code:
my.title_code = my.parent_code
else:
my.title_code = my.server.eval("@GET(twog/proj['code','%s'].title_code)" % my.parent_code)[0]
def get_display(self):
class_name = self.kwargs.get("class_name")
server_name = self.kwargs.get("server")
kwargs = self.kwargs.get("kwargs")
server = TacticServerStub.get(protocol='xmlrpc')
server.set_server(server_name)
widget = server.get_widget(class_name, kwargs)
return widget
def get_display(my):
alias = my.kwargs.get("alias")
my.rel_path = my.kwargs.get("rel_path")
if not my.rel_path:
from tactic_client_lib import TacticServerStub
server = TacticServerStub.get(protocol="local")
my.rel_path = server.get_doc_link(alias)
if not my.rel_path or my.rel_path == "none_found":
# raise TacticException("Help alias [%s] does not exist" % alias)
layout = DivWdg()
layout.add(HelpCreateWdg(alias=alias))
layout.add(HelpDocFilterWdg(alias="main"))
return layout
# special condition for plugins path
if my.rel_path.startswith("/plugins/"):
plugin_dir = Environment.get_plugin_dir()
rel_path = my.rel_path.replace("/plugins/", "")
path = "%s/%s" % (plugin_dir, rel_path)
elif my.rel_path.startswith("/builtin_plugins/"):
plugin_dir = Environment.get_builtin_plugin_dir()
rel_path = my.rel_path.replace("/builtin_plugins/", "")
path = "%s/%s" % (plugin_dir, rel_path)
elif my.rel_path.startswith("/assets/"):
asset_dir = Environment.get_asset_dir()
rel_path = my.rel_path.replace("/assets/", "")
path = "%s/%s" % (asset_dir, rel_path)
else:
# see if there is an override
doc_dir = os.environ.get("TACTIC_DOC_DIR")
if not doc_dir:
doc_dir = Config.get_value("install", "doc_dir")
if not doc_dir:
install_dir = Environment.get_install_dir()
doc_dir = "%s/doc" % install_dir
path = "%s/%s" % (doc_dir, my.rel_path)
html = []
try:
f = open(path, "r")
count = 0
for line in f:
line = my.filter_line(line, count)
html.append(line)
count += 1
f.close()
except Exception, e:
print "Error processing: ", e
html.append("Error processing document: %s<br/><br/>" % str(e))
def __init__(self):
self.xml = None
self.doc = None
self.root = None
from tactic_client_lib import TacticServerStub
self.server = TacticServerStub.get()
# TODO: pull this out of here!!!
self.util = TacticNodeUtil()
self.app = Application.get()
def get_display(my):
alias = my.kwargs.get("alias")
my.rel_path = my.kwargs.get("rel_path")
if not my.rel_path:
from tactic_client_lib import TacticServerStub
server = TacticServerStub.get(protocol='local')
my.rel_path = server.get_doc_link(alias)
if not my.rel_path or my.rel_path == 'none_found':
#raise TacticException("Help alias [%s] does not exist" % alias)
layout = DivWdg()
layout.add(HelpCreateWdg(alias=alias))
layout.add(HelpDocFilterWdg(alias='main'))
return layout
# special condition for plugins path
if my.rel_path.startswith("/plugins/"):
plugin_dir = Environment.get_plugin_dir()
rel_path = my.rel_path.replace("/plugins/", "")
path = "%s/%s" % (plugin_dir, rel_path)
elif my.rel_path.startswith("/builtin_plugins/"):
plugin_dir = Environment.get_builtin_plugin_dir()
rel_path = my.rel_path.replace("/builtin_plugins/", "")
path = "%s/%s" % (plugin_dir, rel_path)
elif my.rel_path.startswith("/assets/"):
asset_dir = Environment.get_asset_dir()
rel_path = my.rel_path.replace("/assets/", "")
path = "%s/%s" % (asset_dir, rel_path)
else:
# see if there is an override
doc_dir = os.environ.get("TACTIC_DOC_DIR")
if not doc_dir:
doc_dir = Config.get_value("install", "doc_dir")
if not doc_dir:
install_dir = Environment.get_install_dir()
doc_dir = "%s/doc" % install_dir
path = "%s/%s" % (doc_dir, my.rel_path)
html = []
try:
f = open(path, 'r')
count = 0
for line in f:
line = my.filter_line(line, count)
html.append(line)
count += 1
f.close()
except Exception, e:
print "Error processing: ", e
html.append("Error processing document: %s<br/><br/>" % str(e))
def __init__(my):
my.xml = None
my.doc = None
my.root = None
from tactic_client_lib import TacticServerStub
my.server = TacticServerStub.get()
# TODO: pull this out of here!!!
my.util = TacticNodeUtil()
my.app = Application.get()
def __init__(my, **kwargs):
from client.tactic_client_lib import TacticServerStub
from pyasm.common import Environment
super(WorkOrderPrintExecutePages, my).__init__(**kwargs)
my.server = TacticServerStub.get()
my.login = Environment.get_login()
my.user = my.login.get_login()
my.codes = str(kwargs.get('codes'))
my.types = ['Full_Work_Order']
my.template_files = {'Full_Work_Order': '/var/www/html/source_labels/work_order.html'}
my.transaction = None
def add_task_to_component(self, process, component_code, login):
server = TacticServerStub.get()
component_search = Search('twog/component')
component_search.add_code_filter(component_code)
component = component_search.get_sobject()
server.insert('sthpw/task', {
'process': process,
'login': login
},
parent_key=component.get_search_key())
def get_server(my):
# do a query for the search
from tactic_client_lib import TacticServerStub
if my.protocol == 'xmlrpc':
stub = TacticServerStub(setup=False, protocol=my.protocol)
stub.set_server(my.host)
stub.set_project(my.project_code)
stub.set_ticket(my.ticket)
else:
stub = TacticServerStub.get()
return stub
def on_update(my, path, data):
from tactic_client_lib import TacticServerStub
server = TacticServerStub.get()
data['path'] = path
bytes = data.get("bytes")
my.total_sent += bytes
print "path: ", path
print "total: ", my.total_sent
server.log_message("wow", data)
def set_pipeline_status(self, status, data={}):
input = self.get_input_data()
sobject = input.get("sobject")
search_key = sobject.get("__search_key__")
process = input.get("process")
if not process:
return
server = TacticServerStub.get()
print "set_pipeline_event: ", search_key, process, status
server.call_pipeline_event(search_key, process, status, data)
def execute(self):
# Get the task sobject (in this case, should be attached to twog/department_request)
task_sobject = self.input.get('sobject')
# Do a sanity check on the search_type to make sure we're working with a twog/department_request
search_type = task_sobject.get('search_type')
if search_type != u'twog/department_request?project=twog':
raise TacticException(
"Something went wrong. A trigger was called on a task that it should not have been."
"Trigger Name: {0}".format(self.__class__.__name__))
# Get the twog/department_request sobject
search_code = task_sobject.get('search_code')
department_request_search = Search('twog/department_request')
department_request_search.add_code_filter(search_code)
department_request_sobject = department_request_search.get_sobject()
# Task process should be either 'Request' or 'Approval'
task_process = task_sobject.get('process').lower()
# For this trigger, only 'Complete', 'Rejected', and 'Approved' apply
task_status = task_sobject.get('status').lower()
# Get a server instance to send the data
server = TacticServerStub.get()
if task_process == 'request' and task_status == 'complete':
# Check if the department request has its 'Response' column filled out. If not, raise an error
if not department_request_sobject.get('response'):
raise TacticException(
"Before marking the request as 'Complete', you must fill out the 'Response' "
"column.")
# Mark the twog/department_request status as needing approval
server.update(department_request_sobject.get_search_key(),
data={'status': 'approval'})
elif task_process == 'approval':
if task_status == 'rejected':
# Need to set the twog/department_request status back to 'in_progress' so that it appears on the
# department's list again. Setting the task status to 'Revise' is not handled here (the pipeline
# takes care of that).
server.update(department_request_sobject.get_search_key(),
data={'status': 'in_progress'})
elif task_status == 'approved':
# If the Approval task is marked as 'approved', then the request is finished. Mark the
# twog/department_request status as 'complete' so it disappears from all views.
server.update(department_request_sobject.get_search_key(),
data={'status': 'complete'})
def checkin(my, tactic_node, search_key, context):
'''Standard checkin mechanism. This is a sample checkin mechanism
that is full featured enough to handle many situations.
@params:
tactic_node: the tactic node to be checkedin
search_key: the search key to check into
context: the context to check into
@return
snapshot: a dictionary representing the final snapshot
'''
server = TacticServerStub.get()
# verify that this is not a reference!!!
# create a snapshot
snapshot = server.create_snapshot(search_key, context)
# find all of the dependencies
dependent_nodes = my.get_dependent_nodes(tactic_node)
for node in dependent_nodes:
# find out if there is a node there is a file associated with
# this tactic node
files = my.get_dependent_references(node)
print files
# update the tactic node with the latest snapshot data. Also, update
# the tactic node name as it likely has changed
node_data = my.set_introspect_data(tactic_node, snapshot)
tactic_node = node_data.get_app_node_name()
# add the files to the snapshot
handler = BaseFileExtractionHandler(tactic_node)
paths = handler.execute()
#paths = my.extract_to_files(top_node)
for path in paths:
print "path: ", path
server.add_file(snapshot.get("code"), path, mode='upload')
return snapshot
def commit(self, xml=None):
if not xml:
xml = self.xml
from tactic_client_lib import TacticServerStub
self.server = TacticServerStub.get()
search_type = "prod/session_contents"
# get more info
pid = os.getpid()
login = self.server.get_login()
data = {'pid': pid, 'login': login, 'data': xml}
self.server.insert(search_type, data)
def init(my):
my.server = TacticServerStub.get(protocol='local')
sobjects_expr = my.kwargs.get("sobjects_expr")
if sobjects_expr:
my.sobjects = Search.eval(sobjects_expr)
my.data = {}
# NOTE: this is is for the FilterElement Functionality
my.show_title = True
my.layout_wdg = None
my.config = None
my.def_config = None
my.sobject_dicts = None
my.is_table_element = False
my.sequence_data = []
def load(my,
search_key,
context,
version=-1,
file_type='main',
mode='reference',
namespace=''):
'''Generic loading function used by TACTIC interface by default
@params:
search_key: the search key of the sobject to be loaded
context: the context of the snapshot to be loaded
version: the version of the snapshot to be loaded
file_type: the specific file in the snapshot to be loaded
mode: reference|import|open: the mode in which to bring the file in
'''
server = TacticServerStub.get()
# FIXME: do we really need to make 2 calls?
snapshot = server.get_snapshot(search_key,
context=context,
version=version)
if not snapshot:
raise CGAppException("No snapshot found for [%s]" % search_key)
paths = server.get_paths(search_key, context, version, file_type)
web_paths = paths.get("web_paths")
for path in web_paths:
to_path = my.download(path)
my.load_file(to_path, namespace=namespace, mode=mode)
# FIXME: if the instance already exists, it will be auto renmaed by
# the application ... this gets tricky to discover
snapshot_code = snapshot.get('code')
if namespace:
tactic_node = "%s:tactic_%s" % (namespace, snapshot_code)
else:
tactic_node = "tactic_%s" % snapshot_code
return tactic_node
def execute(my):
from tactic_client_lib import TacticServerStub
server = TacticServerStub.get(protocol='local')
# create a new snapshot
snapshot = server.create_snapshot(my.search_key, my.context)
# get all of the file_types
file_nodes = my.package_xml.get_nodes("package/file_type")
count = 0
for file_node in file_nodes:
name = my.package_xml.get_attribute(file_node, "name")
values = my.package_xml.get_node_values_of_children(file_node)
expression = values.get("expression")
dir_naming = values.get("dir_naming")
file_naming = values.get("file_naming")
files = Search.eval(expression)
for file in files:
file_type = "%s%s" % (name, count)
try:
# FIXME: the assumed action is to checkin
server.add_file(snapshot,
file,
file_type=file_type,
mode='copy',
dir_naming=dir_naming,
file_naming=file_naming)
# What if we just wished to copy? Can we run the files
# through a naming convention filter?
count += 1
except Exception, e:
print "WARNING: ", str(e)
def execute(self, func_name, args=[], kwargs={}):
server = TacticServerStub.get()
if args:
args = jsonloads(args)
if kwargs:
kwargs = jsonloads(kwargs)
if kwargs:
# Quirk ... when there is a kwargs, the last args is the kwargs
if args:
args.pop()
call = "server.%s(*args, **kwargs)" % func_name
else:
call = "server.%s(*args)" % func_name
try:
ret_val = eval(call)
except Exception, e:
print "ERROR: ", e
raise
def test_all(self):
print "Running Client Application API Test"
from tactic_client_lib import TacticServerStub
# set the server to test... assume it is run on the server
server = "localhost"
url = "http://%s/tactic/default/Api/" % server
self.server = TacticServerStub.get()
project_code = "unittest"
self.server.set_project(project_code)
self.server.start("Client API Unittest")
from tactic_client_lib.application.common import TacticNodeUtil
self.util = TacticNodeUtil()
from tactic_client_lib.application.maya import Maya
self.app = Maya()
try:
data = {'code': 'joe'}
self.person = self.server.insert("unittest/person", data)
data = {'code': 'mary'}
self.person2 = self.server.insert("unittest/person", data)
self._test_load_template()
self._test_checkin()
self._test_load()
self._test_introspect()
except Exception:
self.server.abort()
raise
else:
self.server.abort()
def POST(self):
from pyasm.web import WebContainer
web = WebContainer.get_web()
method = web.get_form_value("method")
print "method: ", method
# make sure there are no special characters in there ie: ()
p = re.compile('^\w+$')
if not re.match(p, method):
raise Exception("Mathod [%s] does not exist" % method)
from tactic_client_lib import TacticServerStub
server = TacticServerStub.get()
if not eval("server.%s" % method):
raise Exception("Mathod [%s] does not exist" % method)
keys = web.get_form_keys()
kwargs = {}
for key in keys:
if key in ["method", "login_ticket", "password"]:
continue
if key == 'kwargs':
args = web.get_form_value(key)
args = jsonloads(args)
for name, value in args.items():
kwargs[name] = value
else:
kwargs[key] = web.get_form_value(key)
call = "server.%s(**kwargs)" % method
return eval(call)
