def execute(my):
class_names = my.kwargs.get("class_names")
attrs_list = my.kwargs.get("attrs_list")
kwargs_list = my.kwargs.get("kwargs_list")
xml = Xml()
xml.create_doc("config")
root = xml.get_root_node()
view = xml.create_element("tab")
xml.append_child(root, view)
for class_name, attrs, kwargs in zip(class_names, attrs_list,
kwargs_list):
element = xml.create_element("element")
xml.append_child(view, element)
for key, value in attrs.items():
xml.set_attribute(element, key, value)
display = xml.create_element("display")
xml.append_child(element, display)
xml.set_attribute(display, "class", class_name)
for key, value in kwargs.items():
attr = xml.create_text_element(key, value, node=display)
xml.append_child(display, attr)
xml_string = xml.to_string()
from pyasm.web import WidgetSettings
WidgetSettings.set_value_by_key("tab", xml_string)
def _get_main_config(self, view, process_names):
'''get the main config for this table layout'''
xml = Xml()
xml.create_doc("config")
root = xml.get_root_node()
view_node = xml.create_element(view)
#root.appendChild(view_node)
xml.append_child(root, view_node)
for idx, process_name in enumerate(process_names):
element = xml.create_element('element')
Xml.set_attribute(element, 'name', process_name)
#view_node.appendChild(element)
xml.append_child(view_node, element)
display = xml.create_element('display')
if self.element_class:
Xml.set_attribute(display, 'class',self.element_class)
else:
Xml.set_attribute(display, 'class', "tactic.ui.app.NoteTableElementWdg")
#element.appendChild(display)
xml.append_child(element, display)
op_element = xml.create_data_element('parent_key', self.search_key)
xml.append_child(display, op_element)
config_xml = xml.to_string()
widget_config = WidgetConfig.get(view=view, xml = config_xml)
widget_config_view = WidgetConfigView('sthpw/note', view, [widget_config])
return widget_config_view
def execute(my):
class_names = my.kwargs.get("class_names")
attrs_list = my.kwargs.get("attrs_list")
kwargs_list = my.kwargs.get("kwargs_list")
xml = Xml()
xml.create_doc("config")
root = xml.get_root_node()
view = xml.create_element("tab")
xml.append_child(root, view)
for class_name, attrs, kwargs in zip(class_names, attrs_list, kwargs_list):
element = xml.create_element("element")
xml.append_child(view, element)
for key, value in attrs.items():
xml.set_attribute(element, key, value)
display = xml.create_element("display")
xml.append_child(element, display)
xml.set_attribute(display, "class", class_name)
for key, value in kwargs.items():
attr = xml.create_text_element(key, value, node=display)
xml.append_child(display, attr)
xml_string = xml.to_string()
from pyasm.web import WidgetSettings
WidgetSettings.set_value_by_key("tab", xml_string)
def _get_main_config(my, view, process_names):
'''get the main config for this table layout'''
xml = Xml()
xml.create_doc("config")
root = xml.get_root_node()
view_node = xml.create_element(view)
#root.appendChild(view_node)
xml.append_child(root, view_node)
for idx, process_name in enumerate(process_names):
element = xml.create_element('element')
Xml.set_attribute(element, 'name', process_name)
#view_node.appendChild(element)
xml.append_child(view_node, element)
display = xml.create_element('display')
if my.element_class:
Xml.set_attribute(display, 'class', my.element_class)
else:
Xml.set_attribute(display, 'class',
"tactic.ui.app.NoteTableElementWdg")
#element.appendChild(display)
xml.append_child(element, display)
op_element = xml.create_data_element('parent_key', my.search_key)
xml.append_child(display, op_element)
config_xml = xml.to_string()
widget_config = WidgetConfig.get(view=view, xml=config_xml)
widget_config_view = WidgetConfigView('sthpw/note', view,
[widget_config])
return widget_config_view
def create(name, desc, search_type, xml=None, code=None, color=None):
'''will only create if it does not exist, otherwise it just updates'''
if code:
sobject = Pipeline.get_by_code(code)
else:
sobject = None
if sobject == None:
#sobject = Pipeline( Pipeline.SEARCH_TYPE )
sobject = SearchType.create(Pipeline.SEARCH_TYPE)
else:
return sobject
if not xml:
xml = Xml()
xml.create_doc('pipeline')
if isinstance(xml, basestring):
xml_string = xml
xml = Xml()
xml.read_string(xml_string)
sobject.set_value("pipeline", xml.get_xml())
sobject.set_pipeline(xml.to_string())
sobject.set_value('timestamp',
Sql.get_default_timestamp_now(),
quoted=False)
if code:
sobject.set_value('code', code.strip())
sobject.set_value('name', name.strip())
sobject.set_value('search_type', search_type)
sobject.set_value('description', desc)
if color:
sobject.set_value("color", color)
sobject.commit()
process_names = sobject.get_process_names()
for i, process_name in enumerate(process_names):
process = SearchType.create("config/process")
process.set_value("pipeline_code", sobject.get_code())
process.set_value("process", process_name)
process.set_value("sort_order", i)
process.set_value("subcontext_options", "(main)")
process.commit()
return sobject
def get_by_ticket(ticket):
search = Search(TransactionState)
search.add_filter("ticket", ticket)
state = search.get_sobject()
# create the state data for this ticket
if not state:
state = SObjectFactory.create(TransactionState.SEARCH_TYPE)
state.set_value("ticket", ticket)
data = Xml()
data.create_doc("state")
state.set_value("data", data.to_string() )
state.commit()
return state
def get_by_ticket(ticket):
search = Search(TransactionState)
search.add_filter("ticket", ticket)
state = search.get_sobject()
# create the state data for this ticket
if not state:
state = SObjectFactory.create(TransactionState.SEARCH_TYPE)
state.set_value("ticket", ticket)
data = Xml()
data.create_doc("state")
state.set_value("data", data.to_string())
state.commit()
return state
def dump(my, plugin_code, project_code, search_types):
xml = Xml()
my.xml = xml
xml.create_doc("manifest")
manifest_node = xml.get_root_node()
xml.set_attribute(manifest_node, "code", plugin_code)
# DUMP the data
for search_type in search_types:
data_node = xml.create_element("search_type")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "code", search_type)
# This exports the data
"""
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "search_type", search_type)
# find the currval
st_obj = SearchType.get(search_type)
# have to call nextval() to initiate this sequence in the session in psql since Postgres 8.1
seq_id = st_obj.sequence_nextval()
seq_id = st_obj.sequence_currval()
seq_id -= 1
if seq_id > 0:
st_obj.sequence_setval(seq_id)
xml.set_attribute(data_node, "seq_max", seq_id)
"""
print xml.to_string()
# create a virtual plugin
plugin = SearchType.create("sthpw/plugin")
plugin.set_value("version", "1.0.0")
plugin.set_value("code", "%s_project" % project_code)
base_dir = "./templates"
creator = PluginCreator( base_dir=base_dir, plugin=plugin, manifest=xml.to_string() )
creator.execute()
def dump(self, plugin_code, project_code, search_types):
xml = Xml()
self.xml = xml
xml.create_doc("manifest")
manifest_node = xml.get_root_node()
xml.set_attribute(manifest_node, "code", plugin_code)
# DUMP the data
for search_type in search_types:
data_node = xml.create_element("search_type")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "code", search_type)
# This exports the data
"""
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "search_type", search_type)
# find the currval
st_obj = SearchType.get(search_type)
# have to call nextval() to initiate this sequence in the session in psql since Postgres 8.1
seq_id = st_obj.sequence_nextval()
seq_id = st_obj.sequence_currval()
seq_id -= 1
if seq_id > 0:
st_obj.sequence_setval(seq_id)
xml.set_attribute(data_node, "seq_max", seq_id)
"""
print xml.to_string()
# create a virtual plugin
plugin = SearchType.create("sthpw/plugin")
plugin.set_value("version", "1.0.0")
plugin.set_value("code", "%s_project" % project_code)
base_dir = "./templates"
creator = PluginCreator(base_dir=base_dir,
plugin=plugin,
manifest=xml.to_string())
creator.execute()
def create(pipeline_name, desc, pipe_search_type):
'''will only create if it does not exist, otherwise it just updates'''
sobject = Pipeline.get_by_name(pipeline_name)
if sobject == None:
#sobject = Pipeline( Pipeline.SEARCH_TYPE )
sobject = SearchType.create( Pipeline.SEARCH_TYPE )
else:
return sobject
xml = Xml()
xml.create_doc('pipeline')
root = xml.get_root_node()
#Xml.set_attribute(root, 'type', type)
sobject.set_value("pipeline", xml.get_xml())
sobject.set_value('timestamp', Sql.get_default_timestamp_now(), quoted=False )
sobject.set_value('code', pipeline_name)
sobject.set_value('search_type', pipe_search_type)
sobject.set_value('description', desc)
sobject.commit()
return sobject
def create(pipeline_name, desc, pipe_search_type):
'''will only create if it does not exist, otherwise it just updates'''
sobject = Pipeline.get_by_name(pipeline_name)
if sobject == None:
#sobject = Pipeline( Pipeline.SEARCH_TYPE )
sobject = SearchType.create( Pipeline.SEARCH_TYPE )
else:
return sobject
xml = Xml()
xml.create_doc('pipeline')
root = xml.get_root_node()
#Xml.set_attribute(root, 'type', type)
sobject.set_value("pipeline", xml.get_xml())
sobject.set_value('timestamp', Sql.get_default_timestamp_now(), quoted=False )
sobject.set_value('code', pipeline_name)
sobject.set_value('search_type', pipe_search_type)
sobject.set_value('description', desc)
sobject.commit()
return sobject
def _get_edit_config(self, view, process_names):
xml = Xml()
xml.create_doc("config")
root = xml.get_root_node()
view_node = xml.create_element(view)
#root.appendChild(view_node)
xml.append_child(root, view_node)
for idx, process_name in enumerate(process_names):
element = xml.create_element('element')
Xml.set_attribute(element, 'name', process_name)
#view_node.appendChild(element)
xml.append_child(view_node, element)
display = xml.create_element('display')
Xml.set_attribute(display, 'class', "pyasm.widget.TextAreaWdg")
#element.appendChild(display)
xml.append_child(element, display)
config_xml = xml.to_string()
widget_config = WidgetConfig.get(view=view, xml = config_xml)
widget_config_view = WidgetConfigView('sthpw/note', view, [widget_config])
return widget_config_view
def _get_edit_config(my, view, process_names):
xml = Xml()
xml.create_doc("config")
root = xml.get_root_node()
view_node = xml.create_element(view)
#root.appendChild(view_node)
xml.append_child(root, view_node)
for idx, process_name in enumerate(process_names):
element = xml.create_element('element')
Xml.set_attribute(element, 'name', process_name)
#view_node.appendChild(element)
xml.append_child(view_node, element)
display = xml.create_element('display')
Xml.set_attribute(display, 'class', "pyasm.widget.TextAreaWdg")
#element.appendChild(display)
xml.append_child(element, display)
config_xml = xml.to_string()
widget_config = WidgetConfig.get(view=view, xml=config_xml)
widget_config_view = WidgetConfigView('sthpw/note', view,
[widget_config])
return widget_config_view
def serialize(my):
'''provide the ability for a widget to serialize itself'''
xml = Xml()
xml.create_doc("config")
# create the top element
element = xml.create_element("element")
xml.set_attribute(element, "name", my.name)
# create the display handler
display = xml.create_element("display")
xml.set_attribute(display, "class", Common.get_full_class_name(my))
element.appendChild(display)
# create the options
for name, value in my.kwargs.items():
if value:
option = xml.create_text_element(name, value)
else: # avoid the \n in the textContent of the textNode
option = xml.create_element(name)
display.appendChild(option)
return xml.to_string(element)
def serialize(my):
'''provide the ability for a widget to serialize itself'''
xml = Xml()
xml.create_doc("config")
# create the top element
element = xml.create_element("element")
xml.set_attribute(element, "name", my.name)
# create the display handler
display = xml.create_element("display")
xml.set_attribute(display, "class", Common.get_full_class_name(my) )
element.appendChild(display)
# create the options
for name, value in my.kwargs.items():
if value:
option = xml.create_text_element(name, value)
else: # avoid the \n in the textContent of the textNode
option = xml.create_element(name)
display.appendChild(option)
return xml.to_string(element)
class SObjectDefaultConfig(Base):
'''An artificial config file is made if none are found'''
def __init__(self, search_type, view, config_base=None, mode="columns"):
self.search_type = search_type
if view:
self.view = view
else:
self.view = config_base
if not self.view:
self.view = "table"
# bit of protection ... : have been known to show up in view names
self.view = self.view.replace(":", '_')
#mode = "basic"
self.xml = Xml()
if mode == 'columns':
self.handle_columns_mode()
else:
self.handle_basic_mode()
def get_columns(self, required_only=False):
if self.search_type == 'sthpw/virtual':
return []
search_type_obj = SearchType.get(self.search_type)
table = search_type_obj.get_table()
from pyasm.biz import Project
db_resource = Project.get_db_resource_by_search_type(self.search_type)
database_name = db_resource.get_database()
db = DbContainer.get(db_resource)
# table may not exist
try:
all_columns = db.get_columns(table)
columns = []
if required_only:
nullables = db.get_column_nullables(table)
for column in all_columns:
null_ok = nullables.get(column)
if not null_ok:
columns.append(column)
# if there are no required columns
if not columns:
columns = all_columns
else:
columns = all_columns
except SqlException:
Environment.add_warning('missing table', 'Table [%s] does not exist in database [%s]' %(table, database_name))
return []
return columns
def handle_basic_mode(self):
doc = self.xml.create_doc("config")
root = self.xml.get_root_node()
db_columns = self.get_columns()
if "code" in db_columns:
columns = ["preview", "code"]
elif "name" in db_columns:
columns = ["preview", "name"]
elif "id" in db_columns:
columns = ["preview", "id"]
table = self.xml.create_element("table")
Xml.append_child(root, table)
for column in ["preview", "code"]:
element = self.xml.create_element("element")
Xml.set_attribute(element, "name", column)
Xml.append_child(table, element)
# create the edit
edit = self.xml.create_element("edit")
Xml.append_child(root, edit)
for column in ["preview", "code"]:
element = self.xml.create_element("element")
Xml.set_attribute(element, "name", column)
Xml.append_child(edit, element)
# create the manual publish view
publish = self.xml.create_element("publish")
Xml.append_child(root, publish)
element = self.xml.create_element("element")
Xml.set_attribute(element, "name", "image")
Xml.append_child(publish, element)
dis_element = self.xml.create_element("display")
Xml.set_attribute(dis_element, "class", "ThumbInputWdg")
act_element = self.xml.create_element("action")
Xml.set_attribute(act_element, "class", "NullAction")
Xml.append_child(element, dis_element)
Xml.append_child(element, act_element)
element = self.xml.create_element("element")
Xml.set_attribute(element, "name", "publish_files")
Xml.append_child(publish, element)
dis_element = self.xml.create_element("display")
Xml.set_attribute(dis_element, "class", "UploadWdg")
# add options
option = self.xml.create_text_element('names','publish_icon|publish_main')
Xml.append_child(dis_element, option)
option = self.xml.create_text_element('required','false|true')
Xml.append_child(dis_element, option)
act_element = self.xml.create_element("action")
Xml.set_attribute(act_element, "class", "MultiUploadAction")
# add options
option = self.xml.create_text_element('names','publish_icon|publish_main')
Xml.append_child(act_element, option)
option = self.xml.create_text_element('types','icon_main|main')
Xml.append_child(act_element, option)
Xml.append_child(element, dis_element)
Xml.append_child(element, act_element)
value = self.xml.to_string()
self.xml = Xml()
self.xml.read_string(value)
def handle_columns_mode(self):
doc = self.xml.create_doc("config")
root = self.xml.get_root_node()
columns = self.get_columns()
if len(columns) == 1 and columns[0] == "id":
columns = self.get_columns(required_only=False)
# create the table
# search is a special view for SearchWdg and it should not be created
if self.view not in ['search','publish']:
if self.view.find('@') != -1:
table = self.xml.create_element('view', attrs={'name': self.view})
else:
table = self.xml.create_element(self.view)
self.xml.append_child(root, table)
for column in columns:
if column in ["_id", "id", "oid", "s_status"]:
continue
element = self.xml.create_element("element")
Xml.set_attribute(element, "name", column)
self.xml.append_child(table, element)
# add history, input and output for the load view (designed for app loading)
if self.view == 'load':
element = self.xml.create_element("element")
Xml.set_attribute(element, "name", "checkin")
self.xml.append_child(table, element)
for column in ['input', 'output']:
element = self.xml.create_element("element")
Xml.set_attribute(element, "name", column)
Xml.set_attribute(element, "edit", "false")
display_element = self.xml.create_element("display")
Xml.set_attribute(display_element, "class", "tactic.ui.cgapp.LoaderElementWdg")
self.xml.append_child(element, display_element)
stype, key = SearchType.break_up_key(self.search_type)
op1 = self.xml.create_text_element("search_type", stype)
op2 = self.xml.create_text_element("mode", column)
self.xml.append_child(display_element, op1)
self.xml.append_child(display_element, op2)
self.xml.append_child(table, element)
value = self.xml.to_string()
self.xml = Xml()
self.xml.read_string(value)
def get_type(self, element_name):
xpath = "config/%s/element[@name='%s']/@type" % (self.view,element_name)
type = self.xml.get_value(xpath)
if not type:
xpath = "config/%s/element[@name='%s']/@type" % ("definition",element_name)
type = self.xml.get_value(xpath)
return type
def get_xml(self):
return self.xml
class SObjectDefaultConfig(Base):
'''An artificial config file is made if none are found'''
def __init__(self, search_type, view, config_base=None, mode="columns"):
self.search_type = search_type
if view:
self.view = view
else:
self.view = config_base
if not self.view:
self.view = "table"
# bit of protection ... : have been known to show up in view names
self.view = self.view.replace(":", '_')
#mode = "basic"
self.xml = Xml()
if mode == 'columns':
self.handle_columns_mode()
else:
self.handle_basic_mode()
def get_columns(self, required_only=False):
if self.search_type == 'sthpw/virtual':
return []
search_type_obj = SearchType.get(self.search_type)
table = search_type_obj.get_table()
from pyasm.biz import Project
db_resource = Project.get_db_resource_by_search_type(self.search_type)
database_name = db_resource.get_database()
db = DbContainer.get(db_resource)
# table may not exist
try:
all_columns = db.get_columns(table)
columns = []
if required_only:
nullables = db.get_column_nullables(table)
for column in all_columns:
null_ok = nullables.get(column)
if not null_ok:
columns.append(column)
# if there are no required columns
if not columns:
columns = all_columns
else:
columns = all_columns
except SqlException:
Environment.add_warning(
'missing table', 'Table [%s] does not exist in database [%s]' %
(table, database_name))
return []
return columns
def handle_basic_mode(self):
doc = self.xml.create_doc("config")
root = self.xml.get_root_node()
db_columns = self.get_columns()
if "code" in db_columns:
columns = ["preview", "code"]
elif "name" in db_columns:
columns = ["preview", "name"]
elif "id" in db_columns:
columns = ["preview", "id"]
table = self.xml.create_element("table")
Xml.append_child(root, table)
for column in ["preview", "code"]:
element = self.xml.create_element("element")
Xml.set_attribute(element, "name", column)
Xml.append_child(table, element)
# create the edit
edit = self.xml.create_element("edit")
Xml.append_child(root, edit)
for column in ["preview", "code"]:
element = self.xml.create_element("element")
Xml.set_attribute(element, "name", column)
Xml.append_child(edit, element)
# create the manual publish view
publish = self.xml.create_element("publish")
Xml.append_child(root, publish)
element = self.xml.create_element("element")
Xml.set_attribute(element, "name", "image")
Xml.append_child(publish, element)
dis_element = self.xml.create_element("display")
Xml.set_attribute(dis_element, "class", "ThumbInputWdg")
act_element = self.xml.create_element("action")
Xml.set_attribute(act_element, "class", "NullAction")
Xml.append_child(element, dis_element)
Xml.append_child(element, act_element)
element = self.xml.create_element("element")
Xml.set_attribute(element, "name", "publish_files")
Xml.append_child(publish, element)
dis_element = self.xml.create_element("display")
Xml.set_attribute(dis_element, "class", "UploadWdg")
# add options
option = self.xml.create_text_element('names',
'publish_icon|publish_main')
Xml.append_child(dis_element, option)
option = self.xml.create_text_element('required', 'false|true')
Xml.append_child(dis_element, option)
act_element = self.xml.create_element("action")
Xml.set_attribute(act_element, "class", "MultiUploadAction")
# add options
option = self.xml.create_text_element('names',
'publish_icon|publish_main')
Xml.append_child(act_element, option)
option = self.xml.create_text_element('types', 'icon_main|main')
Xml.append_child(act_element, option)
Xml.append_child(element, dis_element)
Xml.append_child(element, act_element)
value = self.xml.to_string()
self.xml = Xml()
self.xml.read_string(value)
def handle_columns_mode(self):
doc = self.xml.create_doc("config")
root = self.xml.get_root_node()
columns = self.get_columns()
if len(columns) == 1 and columns[0] == "id":
columns = self.get_columns(required_only=False)
# create the table
# search is a special view for SearchWdg and it should not be created
if self.view not in ['search', 'publish']:
if self.view.find('@') != -1:
table = self.xml.create_element('view',
attrs={'name': self.view})
else:
table = self.xml.create_element(self.view)
self.xml.append_child(root, table)
for column in columns:
if column in ["_id", "id", "oid", "s_status"]:
continue
element = self.xml.create_element("element")
Xml.set_attribute(element, "name", column)
self.xml.append_child(table, element)
# add history, input and output for the load view (designed for app loading)
if self.view == 'load':
element = self.xml.create_element("element")
Xml.set_attribute(element, "name", "checkin")
self.xml.append_child(table, element)
for column in ['input', 'output']:
element = self.xml.create_element("element")
Xml.set_attribute(element, "name", column)
Xml.set_attribute(element, "edit", "false")
display_element = self.xml.create_element("display")
Xml.set_attribute(display_element, "class",
"tactic.ui.cgapp.LoaderElementWdg")
self.xml.append_child(element, display_element)
stype, key = SearchType.break_up_key(self.search_type)
op1 = self.xml.create_text_element("search_type", stype)
op2 = self.xml.create_text_element("mode", column)
self.xml.append_child(display_element, op1)
self.xml.append_child(display_element, op2)
self.xml.append_child(table, element)
value = self.xml.to_string()
self.xml = Xml()
self.xml.read_string(value)
def get_type(self, element_name):
xpath = "config/%s/element[@name='%s']/@type" % (self.view,
element_name)
type = self.xml.get_value(xpath)
if not type:
xpath = "config/%s/element[@name='%s']/@type" % ("definition",
element_name)
type = self.xml.get_value(xpath)
return type
def get_xml(self):
return self.xml
def reset_state(my):
data = Xml()
data.create_doc("state")
my.set_value("data", data.to_string() )
def reset_state(my):
data = Xml()
data.create_doc("state")
my.set_value("data", data.to_string())
def execute(my):
import datetime
now = datetime.datetime.now()
version = now.strftime("%Y%m%d_%H%M%S")
project_code = my.kwargs.get("project_code")
if project_code:
project = Project.get_by_code(project_code)
else:
project = Project.get()
project_code = project.get_code()
server_code = my.kwargs.get("server")
assert server_code
if not isinstance(server_code, basestring):
server_code = server_code.get_value("code")
base_dir = my.kwargs.get('base_dir')
ticket = Environment.get_ticket()
tmp_dir = "%s/sync_%s" % (Environment.get_tmp_dir(), ticket)
if not os.path.exists(tmp_dir):
os.makedirs(tmp_dir)
server = Search.get_by_code("sthpw/sync_server", server_code)
if server.get_value("sync_mode") == "file":
if not base_dir:
base_dir = server.get_value("base_dir")
else:
raise Exception("sync mode [%s] not support" % sync_mode)
# FIXME: not sure if this is valid anymore
asset_dir = Environment.get_asset_dir()
base_dir = "%s/_temp" % asset_dir
# create the project template
from tactic.command import ProjectTemplateCreatorCmd
cmd = ProjectTemplateCreatorCmd(project_code=project_code,
version=version,
base_dir=tmp_dir)
cmd.execute()
project_path = cmd.get_zip_path()
# create zip of the project files
from pyasm.common import ZipUtil
zip_util = ZipUtil()
asset_dir = Environment.get_asset_dir()
project_dir = "%s/%s" % (asset_dir, project_code)
zip_dir = "%s/%s" % (tmp_dir, project_code)
file_path = "%s-files-%s.zip" % (zip_dir, version)
if os.path.exists(file_path):
os.unlink(file_path)
zip_util.zip_dir2(project_dir, zip_path=file_path)
# create a manifest for all the data in the project.
xml = Xml()
my.xml = xml
xml.create_doc("manifest")
manifest_node = xml.get_root_node()
xml.set_attribute(manifest_node, "code", "%s-data" % project_code)
search_types = project.get_search_types()
# just dump the data
for search_type in search_types:
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "search_type",
search_type.get_value("search_type"))
# dump the note entries
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(
data_node, "expression",
"@SOBJECT(sthpw/note['project_code','%s'])" % project_code)
xml.set_attribute(data_node, "search_type", "sthpw/note")
# dump the task entries
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(
data_node, "expression",
"@SOBJECT(sthpw/task['project_code','%s'])" % project_code)
xml.set_attribute(data_node, "search_type", "sthpw/task")
# dump the snapshot entries
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(
data_node, "expression",
"@SOBJECT(sthpw/snapshot['project_code','%s'])" % project_code)
xml.set_attribute(data_node, "search_type", "sthpw/snapshot")
# dump the file entries
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(
data_node, "expression",
"@SOBJECT(sthpw/file['project_code','%s'])" % project_code)
xml.set_attribute(data_node, "search_type", "sthpw/file")
manifest = xml.to_string()
# create a virtual plugin sobject
from tactic.command import PluginCreator
plugin = SearchType.create("config/plugin")
plugin.set_value("version", version)
plugin.set_value("code", "%s_project" % project_code)
creator = PluginCreator(base_dir=tmp_dir,
plugin=plugin,
manifest=manifest,
version=version)
creator.execute()
data_path = creator.get_zip_path()
# move the files to the appropriate base_dir
import shutil
if not os.path.exists(base_dir):
os.makedirs(base_dir)
if os.path.exists(project_path):
basename = os.path.basename(project_path)
if os.path.exists("%s/%s" % (base_dir, basename)):
os.unlink("%s/%s" % (base_dir, basename))
shutil.move(project_path, base_dir)
if os.path.exists(data_path):
basename = os.path.basename(data_path)
if os.path.exists("%s/%s" % (base_dir, basename)):
os.unlink("%s/%s" % (base_dir, basename))
shutil.move(data_path, base_dir)
if os.path.exists(file_path):
basename = os.path.basename(file_path)
if os.path.exists("%s/%s" % (base_dir, basename)):
os.unlink("%s/%s" % (base_dir, basename))
shutil.move(file_path, base_dir)
shutil.rmtree(tmp_dir)
my.handle_manifest(base_dir, project_code, version)
def export_template(my):
xml = Xml()
my.xml = xml
xml.create_doc("manifest")
manifest_node = xml.get_root_node()
# Old implementation. Code is now on the data node
xml.set_attribute(manifest_node, "code", my.template_project_code)
# dump the notification entries
data_node = xml.create_element("data")
xml.append_child(manifest_node, data_node)
code_node = xml.create_element("code")
xml.append_child(data_node, code_node)
xml.set_node_value(code_node, my.template_project_code)
version = my.kwargs.get("version") or ""
version_node = xml.create_element("version")
xml.append_child(data_node, version_node)
xml.set_node_value(version_node, version)
# dump the project entry
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(
data_node, "expression",
"@SOBJECT(sthpw/project['code','%s'])" % my.project_code)
xml.set_attribute(data_node, "search_type", "sthpw/project")
xml.set_attribute(data_node, "unique", "true")
# dump the project_type entry
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(
data_node, "expression",
"@SOBJECT(sthpw/project['code','%s'].sthpw/project_type)" %
my.project_code)
xml.set_attribute(data_node, "search_type", "sthpw/project_type")
xml.set_attribute(data_node, "unique", "true")
# dump the schema entry
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(
data_node, "expression",
"@SOBJECT(sthpw/schema['code','%s'])" % my.project_code)
xml.set_attribute(data_node, "search_type", "sthpw/schema")
xml.set_attribute(data_node, "unique", "true")
# find the project template search types
namespace = my.project_type
if not namespace or namespace == "default":
namespace = my.project_code
project_search_types = Search.eval(
"@GET(sthpw/search_object['namespace','%s'].search_type)" %
namespace)
#project_types = Search.eval("@GET(sthpw/search_object['namespace','%s'].search_type)" % my.project_code)
# just dump the definition for data
for search_type in project_search_types:
data_node = xml.create_element("search_type")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "code", search_type)
search_types = [
"config/custom_script",
"config/widget_config",
"config/naming",
"config/client_trigger",
"config/process",
"config/trigger",
"config/url",
#"config/ingest_rule",
#"config/ingest_session",
]
for search_type in search_types:
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "search_type", search_type)
# find the currval
st_obj = SearchType.get(search_type)
# have to call nextval() to initiate this sequence in the session in psql since Postgres 8.1
seq_id = SearchType.sequence_nextval(search_type)
seq_id = SearchType.sequence_currval(search_type)
seq_id -= 1
if seq_id > 0:
SearchType.sequence_setval(search_type, seq_id)
xml.set_attribute(data_node, "seq_max", seq_id)
#xml.set_attribute(data_node, "path", "data.spt")
# dump the login_groups entries
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(
data_node, "expression",
"@SOBJECT(sthpw/login_group['project_code','%s'])" %
my.project_code)
xml.set_attribute(data_node, "search_type", "sthpw/login_group")
xml.set_attribute(data_node, "unique", "true")
# dump the pipelines entries
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(
data_node, "expression",
"@SOBJECT(sthpw/pipeline['project_code','%s'])" % my.project_code)
xml.set_attribute(data_node, "search_type", "sthpw/pipeline")
xml.set_attribute(data_node, "unique", "true")
# dump the notification entries
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(
data_node, "expression",
"@SOBJECT(sthpw/notification['project_code','%s'])" %
my.project_code)
xml.set_attribute(data_node, "search_type", "sthpw/notification")
from plugin import PluginCreator
creator = PluginCreator(base_dir=my.base_dir,
manifest=xml.to_string(),
force=True,
version=version)
creator.execute()
my.zip_path = creator.get_zip_path()
class SyncFilter(object):
def __init__(self, **kwargs):
self.kwargs = kwargs
self.log = self.kwargs.get("transaction")
self.rules = self.kwargs.get("rules")
self.message = ""
def execute(self):
log = self.log
rules = self.rules
# Give rules. Only notes will get through
# we need heirarchical rules. This will ensure that only notes
# for project/assets will pass
# Here, the second one is much more difficult to do.
rulesXXX = '''
<rule group='heirarchy' key='project/asset.sthpw/note' access='allow'/>
<rule group='heirarchy' key="project/asset.sthpw/note['assigned','beth']" access='allow'/>"
'''
access_manager = AccessManager()
access_manager.add_xml_rules(rules)
# filter out project
namespace = log.get_value("namespace")
key1 = { 'code': namespace }
key2 = { 'code': '*' }
keys = [key1, key2]
if not access_manager.check_access("project", keys, "allow", default="deny"):
self.filtered_xml = Xml()
self.filtered_xml.read_string("<transaction/>")
self.message = "Transaction prevented due to project restriction"
return
# filter the transaction against the security model
xml = log.get_xml_value("transaction")
self.filtered_xml = Xml()
self.filtered_xml.create_doc("transaction")
root2 = self.filtered_xml.get_root_node()
nodes = xml.get_nodes("transaction/*")
num_nodes = len(nodes)
count = 0
for node in nodes:
if Xml.get_node_name(node) == "sobject":
search_type = xml.get_attribute(node, "search_type")
parts = search_type.split("?")
search_type = parts[0]
# filter search types
key1 = { 'code': search_type }
key2 = { 'code': "*" }
keys = [ key1, key2 ]
if not access_manager.check_access("search_type", keys, "allow", default="deny"):
continue
# check hierachical rule
parent_type = xml.get_attribute(node, "parent_type")
key = "%s.%s" % (parent_type, search_type)
self.filtered_xml.append_child(root2, node)
count += 1
else:
self.filtered_xml.append_child(root2, node)
count += 1
if len(nodes) != 0 and len(self.filtered_xml.get_nodes("transaction/*")) == 0:
self.message = "All actions filtered due to security restrictions (%s actions)" % num_nodes
def get_filtered_xml(self):
return self.filtered_xml
def get_message(self):
return self.message
def execute(self):
import datetime
now = datetime.datetime.now()
version = now.strftime("%Y%m%d_%H%M%S")
project_code = self.kwargs.get("project_code")
if project_code:
project = Project.get_by_code(project_code)
else:
project = Project.get()
project_code = project.get_code()
server_code = self.kwargs.get("server")
assert server_code
if not isinstance(server_code, basestring):
server_code = server_code.get_value("code")
base_dir = self.kwargs.get('base_dir')
ticket = Environment.get_ticket()
tmp_dir = "%s/sync_%s" % (Environment.get_tmp_dir(), ticket)
if not os.path.exists(tmp_dir):
os.makedirs(tmp_dir)
server = Search.get_by_code("sthpw/sync_server", server_code)
if server.get_value("sync_mode") == "file":
if not base_dir:
base_dir = server.get_value("base_dir")
else:
raise Exception("sync mode [%s] not support" % sync_mode)
# FIXME: not sure if this is valid anymore
asset_dir = Environment.get_asset_dir()
base_dir = "%s/_temp" % asset_dir
# create the project template
from tactic.command import ProjectTemplateCreatorCmd
cmd = ProjectTemplateCreatorCmd(project_code=project_code, version=version, base_dir=tmp_dir)
cmd.execute()
project_path = cmd.get_zip_path()
# create zip of the project files
from pyasm.common import ZipUtil
zip_util = ZipUtil()
asset_dir = Environment.get_asset_dir()
project_dir = "%s/%s" % (asset_dir, project_code)
zip_dir = "%s/%s" % (tmp_dir, project_code)
file_path = "%s-files-%s.zip" % (zip_dir, version)
if os.path.exists(file_path):
os.unlink(file_path)
zip_util.zip_dir2(project_dir, zip_path=file_path)
# create a manifest for all the data in the project.
xml = Xml()
self.xml = xml
xml.create_doc("manifest")
manifest_node = xml.get_root_node()
xml.set_attribute(manifest_node, "code", "%s-data" % project_code)
search_types = project.get_search_types()
# just dump the data
for search_type in search_types:
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "search_type", search_type.get_value("search_type"))
# dump the note entries
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "expression", "@SOBJECT(sthpw/note['project_code','%s'])" % project_code)
xml.set_attribute(data_node, "search_type", "sthpw/note")
# dump the task entries
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "expression", "@SOBJECT(sthpw/task['project_code','%s'])" % project_code)
xml.set_attribute(data_node, "search_type", "sthpw/task")
# dump the snapshot entries
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "expression", "@SOBJECT(sthpw/snapshot['project_code','%s'])" % project_code)
xml.set_attribute(data_node, "search_type", "sthpw/snapshot")
# dump the file entries
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "expression", "@SOBJECT(sthpw/file['project_code','%s'])" % project_code)
xml.set_attribute(data_node, "search_type", "sthpw/file")
manifest = xml.to_string()
# create a virtual plugin sobject
from tactic.command import PluginCreator
plugin = SearchType.create("config/plugin")
plugin.set_value("version", version)
plugin.set_value("code", "%s_project" % project_code)
creator = PluginCreator( base_dir=tmp_dir, plugin=plugin, manifest=manifest, version=version )
creator.execute()
data_path = creator.get_zip_path()
# move the files to the appropriate base_dir
import shutil
if not os.path.exists(base_dir):
os.makedirs(base_dir)
if os.path.exists(project_path):
basename = os.path.basename(project_path)
if os.path.exists("%s/%s" % (base_dir, basename)):
os.unlink("%s/%s" % (base_dir, basename))
shutil.move(project_path, base_dir)
if os.path.exists(data_path):
basename = os.path.basename(data_path)
if os.path.exists("%s/%s" % (base_dir, basename)):
os.unlink("%s/%s" % (base_dir, basename))
shutil.move(data_path, base_dir)
if os.path.exists(file_path):
basename = os.path.basename(file_path)
if os.path.exists("%s/%s" % (base_dir, basename)):
os.unlink("%s/%s" % (base_dir, basename))
shutil.move(file_path, base_dir)
shutil.rmtree(tmp_dir)
self.handle_manifest(base_dir, project_code, version)
def export_template(my):
xml = Xml()
my.xml = xml
xml.create_doc("manifest")
manifest_node = xml.get_root_node()
# Old implementation. Code is now on the data node
xml.set_attribute(manifest_node, "code", my.template_project_code)
# dump the notification entries
data_node = xml.create_element("data")
xml.append_child(manifest_node, data_node)
code_node = xml.create_element("code")
xml.append_child(data_node, code_node)
xml.set_node_value(code_node, my.template_project_code)
version = my.kwargs.get("version") or ""
version_node = xml.create_element("version")
xml.append_child(data_node, version_node)
xml.set_node_value(version_node, version)
# dump the project entry
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "expression", "@SOBJECT(sthpw/project['code','%s'])" % my.project_code)
xml.set_attribute(data_node, "search_type", "sthpw/project")
xml.set_attribute(data_node, "unique", "true")
# dump the project_type entry
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "expression", "@SOBJECT(sthpw/project['code','%s'].sthpw/project_type)" % my.project_code)
xml.set_attribute(data_node, "search_type", "sthpw/project_type")
xml.set_attribute(data_node, "unique", "true")
# dump the schema entry
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "expression", "@SOBJECT(sthpw/schema['code','%s'])" % my.project_code)
xml.set_attribute(data_node, "search_type", "sthpw/schema")
xml.set_attribute(data_node, "unique", "true")
# find the project template search types
namespace = my.project_type
if not namespace or namespace == "default":
namespace = my.project_code
project_search_types = Search.eval("@GET(sthpw/search_object['namespace','%s'].search_type)" % namespace)
#project_types = Search.eval("@GET(sthpw/search_object['namespace','%s'].search_type)" % my.project_code)
# just dump the definition for data
for search_type in project_search_types:
data_node = xml.create_element("search_type")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "code", search_type)
search_types = [
"config/custom_script",
"config/widget_config",
"config/naming",
"config/client_trigger",
"config/process",
"config/trigger",
"config/url",
#"config/ingest_rule",
#"config/ingest_session",
]
for search_type in search_types:
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "search_type", search_type)
# find the currval
st_obj = SearchType.get(search_type)
# have to call nextval() to initiate this sequence in the session in psql since Postgres 8.1
seq_id = SearchType.sequence_nextval(search_type)
seq_id = SearchType.sequence_currval(search_type)
seq_id -= 1
if seq_id > 0:
SearchType.sequence_setval(search_type, seq_id)
xml.set_attribute(data_node, "seq_max", seq_id)
#xml.set_attribute(data_node, "path", "data.spt")
# dump the login_groups entries
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "expression", "@SOBJECT(sthpw/login_group['project_code','%s'])" % my.project_code)
xml.set_attribute(data_node, "search_type", "sthpw/login_group")
xml.set_attribute(data_node, "unique", "true")
# dump the pipelines entries
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "expression", "@SOBJECT(sthpw/pipeline['project_code','%s'])" % my.project_code)
xml.set_attribute(data_node, "search_type", "sthpw/pipeline")
xml.set_attribute(data_node, "unique", "true")
# dump the notification entries
data_node = xml.create_element("sobject")
xml.append_child(manifest_node, data_node)
xml.set_attribute(data_node, "expression", "@SOBJECT(sthpw/notification['project_code','%s'])" % my.project_code)
xml.set_attribute(data_node, "search_type", "sthpw/notification")
from plugin import PluginCreator
creator = PluginCreator( base_dir=my.base_dir, manifest=xml.to_string(), force=True, version=version )
creator.execute()
my.zip_path = creator.get_zip_path()
def reset_state(self):
data = Xml()
data.create_doc("state")
self.set_value("data", data.to_string() )
