def get_config(cls, search_type, view, default=None, personal=False):
# personal doesn't mean much here since this is only for Project view definition
"""
if view == "__column__":
xml == '''
<config>
<element name="tttt" type="__database__"/>
<element name="uuuu" type="__database__"/>
<element name="vvvv" type="__database__"/>
</config>
'''
"""
widget_config = None
config_view = None
widget_config_list = []
# get all the configs relevant to this search_type
configs = []
from pyasm.widget import WidgetConfigView
if view == "definition":
if default:
try:
default_config_view = WidgetConfigView.get_by_search_type(
search_type, view, use_cache=False, local_search=True)
user_config_view = WidgetConfigView.get_by_search_type(
search_type, view)
#merge the user config view from db into the default config view in xml file
default_config = default_config_view.get_definition_config(
)
user_config = user_config_view.get_definition_config()
if user_config:
user_element_names = user_config.get_element_names()
# make sure it's unique, there is a new validate function for
# WidgetDbConfig to ensure that also
user_element_names = Common.get_unique_list(
user_element_names)
for elem in user_element_names:
user_node = user_config.get_element_node(elem)
default_config.append_xml_element(elem,
node=user_node)
except SqlException, e:
print "Search ERROR: ", e.__str__()
default_config = None
if default_config:
default_config.get_xml().clear_xpath_cache()
widget_config_list = [default_config]
else:
config_view = WidgetConfigView.get_by_search_type(
search_type, view, use_cache=True)
def get_config(cls, search_type, view, default=None, personal=False):
# personal doesn't mean much here since this is only for Project view definition
"""
if view == "__column__":
xml == '''
<config>
<element name="tttt" type="__database__"/>
<element name="uuuu" type="__database__"/>
<element name="vvvv" type="__database__"/>
</config>
'''
"""
widget_config = None
config_view = None
widget_config_list = []
# get all the configs relevant to this search_type
configs = []
from pyasm.widget import WidgetConfigView
if view == "definition":
if default:
try:
default_config_view = WidgetConfigView.get_by_search_type(
search_type, view, use_cache=False, local_search=True
)
user_config_view = WidgetConfigView.get_by_search_type(search_type, view)
# merge the user config view from db into the default config view in xml file
default_config = default_config_view.get_definition_config()
user_config = user_config_view.get_definition_config()
if user_config:
user_element_names = user_config.get_element_names()
# make sure it's unique, there is a new validate function for
# WidgetDbConfig to ensure that also
user_element_names = Common.get_unique_list(user_element_names)
for elem in user_element_names:
user_node = user_config.get_element_node(elem)
default_config.append_xml_element(elem, node=user_node)
except SqlException, e:
print "Search ERROR: ", e.__str__()
default_config = None
if default_config:
default_config.get_xml().clear_xpath_cache()
widget_config_list = [default_config]
else:
config_view = WidgetConfigView.get_by_search_type(search_type, view, use_cache=True)
def execute(self):
search_keys = self.kwargs.get("search_keys")
if not search_keys:
return
element_name = self.kwargs.get("element_name")
# get all of the sobjects
sobjects = Search.get_by_search_keys(search_keys)
if not sobjects:
return
from pyasm.widget import WidgetConfigView
search_type = sobjects[0].get_base_search_type()
view = "definition"
config = WidgetConfigView.get_by_search_type(search_type, view)
# TEST
widget = config.get_display_widget(element_name)
for sobject in sobjects:
widget.set_sobject(sobject)
value = widget.get_text_value()
sobject.set_value(element_name, value)
sobject.commit()
def execute(my):
search_keys = my.kwargs.get("search_keys")
if not search_keys:
return
element_name = my.kwargs.get("element_name")
# get all of the sobjects
sobjects = Search.get_by_search_keys(search_keys)
if not sobjects:
return
from pyasm.widget import WidgetConfigView
search_type = sobjects[0].get_base_search_type()
view = "definition"
config = WidgetConfigView.get_by_search_type(search_type, view)
# TEST
widget = config.get_display_widget(element_name)
for sobject in sobjects:
widget.set_sobject(sobject)
value = widget.get_text_value()
sobject.set_value(element_name, value)
sobject.commit()
def execute(my):
my.search_type = my.kwargs.get('search_type')
my.element_name = my.kwargs.get('element_name')
#print "Calculating aggregate: ", my.search_type, my.element_name
my.view = my.kwargs.get('view')
if not my.view:
my.view = 'definition'
config = WidgetConfigView.get_by_search_type(search_type=my.search_type, view=my.view)
widget = config.get_display_widget(my.element_name)
# calculate all of the values
search = Search(my.search_type)
sobjects = search.get_sobjects()
widget.set_sobjects(sobjects)
widget.kwargs['use_cache'] = "false"
for i, sobject in enumerate(sobjects):
widget.set_current_index(i)
value = widget.get_text_value()
print sobject.get_code(), "value [%s]: " %value
# all cache columns need are named with a c_ preceeding it
# s_status
# c_element_name
#
# this_month -> c_this_month
#column = "c_%s" % my.element_name
#sobject.set_value(column, value)
sobject.set_value(my.element_name, value)
sobject.commit()
def execute(self):
sobject = self.sobject
search_type = sobject.get_search_type_obj()
config = WidgetConfigView.get_by_search_type(search_type, "custom")
if not config:
return
self.element_names = config.get_element_names()
# create all of the handlers
action_handlers = []
for element_name in (self.element_names):
action_handler_class = \
config.get_action_handler(element_name)
if action_handler_class == "":
action_handler_class = "DatabaseAction"
action_handler = WidgetConfig.create_widget(action_handler_class)
action_handler.set_name(element_name)
action_handler.set_input_prefix("edit")
action_options = config.get_action_options(element_name)
for key, value in action_options.items():
action_handler.set_option(key, value)
action_handlers.append(action_handler)
# set the sobject for each action handler
for action_handler in action_handlers:
action_handler.set_sobject(sobject)
if action_handler.check():
action_handler.execute()
def execute(self):
self.search_type = self.kwargs.get('search_type')
self.element_name = self.kwargs.get('element_name')
#print "Calculating aggregate: ", self.search_type, self.element_name
self.view = self.kwargs.get('view')
if not self.view:
self.view = 'definition'
config = WidgetConfigView.get_by_search_type(
search_type=self.search_type, view=self.view)
widget = config.get_display_widget(self.element_name)
# calculate all of the values
search = Search(self.search_type)
sobjects = search.get_sobjects()
widget.set_sobjects(sobjects)
widget.kwargs['use_cache'] = "false"
for i, sobject in enumerate(sobjects):
widget.set_current_index(i)
value = widget.get_text_value()
print sobject.get_code(), "value [%s]: " % value
# all cache columns need are named with a c_ preceeding it
# s_status
# c_element_name
#
# this_month -> c_this_month
#column = "c_%s" % self.element_name
#sobject.set_value(column, value)
sobject.set_value(self.element_name, value)
sobject.commit()
def get_config(cls,
config_search_type,
view,
default=False,
personal=False):
config = WidgetConfigView.get_by_search_type(config_search_type, view)
return config
def append(cls, search_type, view, name, class_name=None, display_options={}, element_attrs={}, config_xml=None, login=None):
'''append an element with display class and options to the specified widget config'''
assert view
config_search_type = "config/widget_config"
search = Search(config_search_type)
search.add_filter("search_type", search_type)
search.add_filter("view", view)
search.add_filter("login", login)
db_config = search.get_sobject()
config_exists = True
view_node = None
if not db_config:
db_config = SearchType.create(config_search_type)
db_config.set_value("search_type", search_type )
db_config.set_value("view", view )
if login:
db_config.set_value("login", login)
config_exists = False
# maintain the config variable here to mean WidgetConfig
from pyasm.widget import WidgetConfigView
if not config_exists and search_type not in ["SideBarWdg"]:
config_view = WidgetConfigView.get_by_search_type(search_type, view)
#xml = config.get_xml()
configs = config_view.get_configs()
if configs:
config = configs[0]
view_node = config.get_view_node()
config_exists = True
if not config_exists:
xml = db_config.get_xml_value("config", "config")
db_config._init()
root = xml.get_root_node()
# build a new config
view_node = xml.create_element(view)
#root.appendChild(view_node)
xml.append_child(root, view_node)
else:
xml = db_config.get_xml_value("config", "config")
root = xml.get_root_node()
# it could be passed in thru a widget_config already
if view_node is None:
view_node = db_config.get_view_node()
#root.appendChild(view_node)
xml.append_child(root, view_node)
db_config._init()
if config_xml:
db_config.append_xml_element( name, config_xml)
else:
db_config.append_display_element(name, class_name, options=display_options, element_attrs=element_attrs)
db_config.commit_config()
return db_config
def append(cls, search_type, view, name, class_name=None, display_options={}, element_attrs={}, config_xml=None, login=None):
'''append an element with display class and options to the specified widget config'''
assert view
config_search_type = "config/widget_config"
search = Search(config_search_type)
search.add_filter("search_type", search_type)
search.add_filter("view", view)
search.add_filter("login", login)
db_config = search.get_sobject()
config_exists = True
view_node = None
if not db_config:
db_config = SearchType.create(config_search_type)
db_config.set_value("search_type", search_type )
db_config.set_value("view", view )
if login:
db_config.set_value("login", login)
config_exists = False
# maintain the config variable here to mean WidgetConfig
from pyasm.widget import WidgetConfigView
if not config_exists and search_type not in ["SideBarWdg"]:
config_view = WidgetConfigView.get_by_search_type(search_type, view)
#xml = config.get_xml()
configs = config_view.get_configs()
if configs:
config = configs[0]
view_node = config.get_view_node()
config_exists = True
if not config_exists:
xml = db_config.get_xml_value("config", "config")
db_config._init()
root = xml.get_root_node()
# build a new config
view_node = xml.create_element(view)
#root.appendChild(view_node)
xml.append_child(root, view_node)
else:
xml = db_config.get_xml_value("config", "config")
root = xml.get_root_node()
# it could be passed in thru a widget_config already
if view_node is None:
view_node = db_config.get_view_node()
#root.appendChild(view_node)
xml.append_child(root, view_node)
db_config._init()
if config_xml:
db_config.append_xml_element( name, config_xml)
else:
db_config.append_display_element(name, class_name, options=display_options, element_attrs=element_attrs)
db_config.commit_config()
return db_config
def get_info_wdg(my, sobject):
div = DivWdg()
div.add_style("margin: 10px 20px 20px 20px")
div.add_style("padding: 20px")
div.add_color("background", "background", -3)
div.add_border()
div.add_color("color", "color3")
div.set_round_corners(5)
div.add_style("height", "100%")
div.add_style("position: relative")
element_names = my.kwargs.get("element_names")
if not element_names:
element_names = [
"code",
"name",
"description",
]
else:
element_names = element_names.split(",")
view = "table"
from pyasm.widget import WidgetConfigView
search_type = sobject.get_search_type()
config = WidgetConfigView.get_by_search_type(search_type, view)
table = Table()
table.add_style("height", "100%")
div.add(table)
for element_name in element_names:
table.add_row()
title = Common.get_display_title(element_name)
td = table.add_cell("%s: " % title)
td.add_style("width: 200px")
td.add_style("padding: 5px")
element = config.get_display_widget(element_name)
element.set_sobject(sobject)
element.preprocess()
td = table.add_cell(element)
td.add_style("padding: 5px")
#value = sobject.get_value(element_name, no_exception=True) or "N/A"
#table.add_cell(value)
div.add("<br/>")
from tactic.ui.widget import DiscussionWdg
search_key = sobject.get_search_key()
notes_wdg = DiscussionWdg(search_key=search_key)
notes_wdg.set_sobject(sobject)
div.add(notes_wdg)
return div
def preprocess(self):
sobject = self.get_current_sobject()
if not sobject:
self.columns = []
return
search_type = sobject.get_search_type_obj()
config = WidgetConfigView.get_by_search_type(search_type, "custom")
if not config:
self.columns = []
else:
self.columns = config.get_element_names()
def init_color_map(self):
''' initialize the color map for bg color and text color'''
search_type = self.kwargs.get('search_type')
if not search_type:
search_type = 'sthpw/task'
# get the color map
from pyasm.widget import WidgetConfigView
color_config = WidgetConfigView.get_by_search_type(
search_type, "color")
color_xml = color_config.configs[0].xml
self.color_map = {}
name = 'status'
xpath = "config/color/element[@name='%s']/colors" % name
text_xpath = "config/color/element[@name='%s']/text_colors" % name
bg_color_node = color_xml.get_node(xpath)
bg_color_map = color_xml.get_node_values_of_children(bg_color_node)
text_color_node = color_xml.get_node(text_xpath)
text_color_map = color_xml.get_node_values_of_children(text_color_node)
# use old weird query language
query = bg_color_map.get("query")
query2 = bg_color_map.get("query2")
if query:
bg_color_map = {}
search_type, match_col, color_col = query.split("|")
search = Search(search_type)
sobjects = search.get_sobjects()
# match to a second table
if query2:
search_type2, match_col2, color_col2 = query2.split("|")
search2 = Search(search_type2)
sobjects2 = search2.get_sobjects()
else:
sobjects2 = []
for sobject in sobjects:
match = sobject.get_value(match_col)
color_id = sobject.get_value(color_col)
for sobject2 in sobjects2:
if sobject2.get_value(match_col2) == color_id:
color = sobject2.get_value(color_col2)
break
else:
color = color_id
bg_color_map[match] = color
self.color_map[name] = bg_color_map, text_color_map
def init_color_map(my):
''' initialize the color map for bg color and text color'''
search_type = my.kwargs.get('search_type')
if not search_type:
search_type = 'sthpw/task'
# get the color map
from pyasm.widget import WidgetConfigView
color_config = WidgetConfigView.get_by_search_type(search_type, "color")
color_xml = color_config.configs[0].xml
my.color_map = {}
name = 'status'
xpath = "config/color/element[@name='%s']/colors" % name
text_xpath = "config/color/element[@name='%s']/text_colors" % name
bg_color_node = color_xml.get_node(xpath)
bg_color_map = color_xml.get_node_values_of_children(bg_color_node)
text_color_node = color_xml.get_node(text_xpath)
text_color_map = color_xml.get_node_values_of_children(text_color_node)
# use old weird query language
query = bg_color_map.get("query")
query2 = bg_color_map.get("query2")
if query:
bg_color_map = {}
search_type, match_col, color_col = query.split("|")
search = Search(search_type)
sobjects = search.get_sobjects()
# match to a second table
if query2:
search_type2, match_col2, color_col2 = query2.split("|")
search2 = Search(search_type2)
sobjects2 = search2.get_sobjects()
else:
sobjects2 = []
for sobject in sobjects:
match = sobject.get_value(match_col)
color_id = sobject.get_value(color_col)
for sobject2 in sobjects2:
if sobject2.get_value(match_col2) == color_id:
color = sobject2.get_value(color_col2)
break
else:
color = color_id
bg_color_map[match] = color
my.color_map[name] = bg_color_map, text_color_map
def preprocess(my):
sobject = my.get_current_sobject()
if not sobject:
my.columns = []
return
search_type = sobject.get_search_type_obj()
config = WidgetConfigView.get_by_search_type(search_type, "custom")
if not config:
my.columns = []
else:
my.columns = config.get_element_names()
def get_info_wdg(my, sobject):
div = DivWdg()
div.add_style("margin: 10px 20px 20px 20px")
div.add_style("padding: 20px")
div.add_color("background", "background", -3)
div.add_border()
div.add_color("color", "color3")
div.set_round_corners(5)
div.add_style("height", "100%")
div.add_style("position: relative")
element_names = my.kwargs.get("element_names")
if not element_names:
element_names = ["code","name","description",]
else:
element_names = element_names.split(",")
view = "table"
from pyasm.widget import WidgetConfigView
search_type = sobject.get_search_type()
config = WidgetConfigView.get_by_search_type(search_type, view)
table = Table()
table.add_style("height", "100%")
div.add(table)
for element_name in element_names:
table.add_row()
title = Common.get_display_title(element_name)
td = table.add_cell("%s: " % title)
td.add_style("width: 200px")
td.add_style("padding: 5px")
element = config.get_display_widget(element_name)
element.set_sobject(sobject)
element.preprocess()
td = table.add_cell(element)
td.add_style("padding: 5px")
#value = sobject.get_value(element_name, no_exception=True) or "N/A"
#table.add_cell(value)
div.add("<br/>")
from tactic.ui.widget import DiscussionWdg
search_key = sobject.get_search_key()
notes_wdg = DiscussionWdg(search_key=search_key)
notes_wdg.set_sobject(sobject)
div.add(notes_wdg)
return div
def get_hint_text(cls, search_type, simple_search_view=''):
'''Get the hint text for keyword search col defined from widget_config'''
if simple_search_view:
from pyasm.widget import WidgetConfigView
config = WidgetConfigView.get_by_search_type(search_type, simple_search_view)
# assume the keyword filter is named "keyword"
options = config.get_display_options('keyword')
hint_text = options.get('hint_text')
if hint_text:
return hint_text
return ""
def get_hint_text(cls, search_type, simple_search_view=''):
'''Get the hint text for keyword search col defined from widget_config'''
if simple_search_view:
from pyasm.widget import WidgetConfigView
config = WidgetConfigView.get_by_search_type(
search_type, simple_search_view)
# assume the keyword filter is named "keyword"
options = config.get_display_options('keyword')
hint_text = options.get('hint_text')
if hint_text:
return hint_text
return ""
def get_search_col(cls, search_type, simple_search_view=''):
'''Get the appropriate keyword search col based on column existence in this sType'''
if simple_search_view:
from pyasm.widget import WidgetConfigView
config = WidgetConfigView.get_by_search_type(search_type, simple_search_view)
# assume the keyword filter is named "keyword"
options = config.get_display_options('keyword')
column = options.get('column')
if column:
return column
for col in cls.SEARCH_COLS:
if SearchType.column_exists(search_type, col):
return col
return cls.SEARCH_COLS[-1]
def get_search_col(cls, search_type, simple_search_view=''):
'''Get the appropriate keyword search col based on column existence in this sType'''
if simple_search_view:
from pyasm.widget import WidgetConfigView
config = WidgetConfigView.get_by_search_type(search_type, simple_search_view)
# assume the keyword filter is named "keyword"
options = config.get_display_options('keyword')
column = options.get('column')
if column:
return column
for col in cls.SEARCH_COLS:
if SearchType.column_exists(search_type, col):
return col
return cls.SEARCH_COLS[-1]
def get_definitions(self, element_name):
'''get all the definitions for this element'''
search_type = self.kwargs.get("search_type")
view = self.kwargs.get("view")
config_view = WidgetConfigView.get_by_search_type(search_type, view)
display_class = config_view.get_display_handler(element_name)
element_attr = config_view.get_element_attributes(element_name)
for config in config_view.get_configs():
#print config
view = config.get_view()
file_path = config.get_file_path()
if not file_path:
file_path = "from Database"
#print view, file_path
xml = config.get_element_xml(element_name)
def preprocess(my):
my.elements = my.kwargs.get("elements")
if my.elements:
my.elements = my.elements.split('|')
else:
my.elements = []
# get the definition
sobjects = my.sobjects
if sobjects:
sobject = sobjects[0]
search_type = sobject.get_search_type()
view = 'definition'
from pyasm.widget import WidgetConfigView
my.config = WidgetConfigView.get_by_search_type(search_type, view)
else:
my.config = None
def preprocess(my):
my.elements = my.kwargs.get("elements")
if my.elements:
my.elements = my.elements.split('|')
else:
my.elements = []
# get the definition
sobjects = my.sobjects
if sobjects:
sobject = sobjects[0]
search_type = sobject.get_search_type()
view = 'definition'
from pyasm.widget import WidgetConfigView
my.config = WidgetConfigView.get_by_search_type(search_type, view)
else:
my.config = None
def get_definitions(my, element_name):
'''get all the definitions for this element'''
search_type = my.kwargs.get("search_type")
view = my.kwargs.get("view")
config_view = WidgetConfigView.get_by_search_type(search_type, view)
display_class = config_view.get_display_handler(element_name)
element_attr = config_view.get_element_attributes(element_name)
for config in config_view.get_configs():
#print config
view = config.get_view()
file_path = config.get_file_path()
if not file_path:
file_path = "from Database"
#print view, file_path
xml = config.get_element_xml(element_name)
def check(my):
my.web = WebContainer.get_web()
search_type = my.sobject.get_search_type_obj()
config = WidgetConfigView.get_by_search_type(search_type, "insert", local_search=True)
columns = config.get_element_names()
if len(columns) != 3:
raise TacticException('The command is expecting 3 fields only.')
my.date = my.web.get_form_value('edit|%s' % columns[0])
my.desc = my.web.get_form_value('edit|%s'% columns[1])
date = Date(db_date=my.date)
my.year = date.get_year()
my.week = date.get_week()
my.project_code = my.web.get_form_value('edit|%s'% columns[2])
if not my.desc or not my.date or not my.project_code:
raise UserException('One or more fields are empty.')
Project.set_project(my.project_code)
return True
def check(my):
my.web = WebContainer.get_web()
search_type = my.sobject.get_search_type_obj()
config = WidgetConfigView.get_by_search_type(search_type,
"insert",
local_search=True)
columns = config.get_element_names()
if len(columns) != 3:
raise TacticException('The command is expecting 3 fields only.')
my.date = my.web.get_form_value('edit|%s' % columns[0])
my.desc = my.web.get_form_value('edit|%s' % columns[1])
date = Date(db_date=my.date)
my.year = date.get_year()
my.week = date.get_week()
my.project_code = my.web.get_form_value('edit|%s' % columns[2])
if not my.desc or not my.date or not my.project_code:
raise UserException('One or more fields are empty.')
Project.set_project(my.project_code)
return True
def get_display(my):
web = WebContainer.get_web()
if web.get_form_value("Insert/Exit"):
widget = Widget()
iframe = WebContainer.get_iframe()
widget.add( HtmlElement.script(iframe.get_off_script()) )
widget.add( HtmlElement.script("window.parent.document.form.submit()") )
return widget
database = Project.get_project_code()
search_type = web.get_form_value("search_type")
assert search_type
view = web.get_form_value("view")
if not view:
view = get_template_view()
widget = DivWdg()
WebContainer.register_cmd("pyasm.widget.CustomAddElementCbk")
# remember some parameters
widget.add( HiddenWdg("search_type", search_type) )
widget.add( HiddenWdg("view", view) )
# Get the definition widget and list all of the custom elements
config = WidgetConfigView.get_by_search_type(search_type,DEFAULT_VIEW)
element_names = config.get_element_names()
# show current custom
widget.add("<h3>Add Element for [%s]</h3>" % search_type)
widget.add( my.get_new_custom_widget(view) )
return widget
def get_display(my):
web = WebContainer.get_web()
if web.get_form_value("Insert/Exit"):
widget = Widget()
iframe = WebContainer.get_iframe()
widget.add( HtmlElement.script(iframe.get_off_script()) )
widget.add( HtmlElement.script("window.parent.document.form.submit()") )
return widget
database = Project.get_project_code()
search_type = web.get_form_value("search_type")
assert search_type
view = web.get_form_value("view")
if not view:
view = get_template_view()
widget = DivWdg()
WebContainer.register_cmd("pyasm.widget.CustomAddElementCbk")
# remember some parameters
widget.add( HiddenWdg("search_type", search_type) )
widget.add( HiddenWdg("view", view) )
# Get the definition widget and list all of the custom elements
config = WidgetConfigView.get_by_search_type(search_type,DEFAULT_VIEW)
element_names = config.get_element_names()
# show current custom
widget.add("<h3>Add Element for [%s]</h3>" % search_type)
widget.add( my.get_new_custom_widget(view) )
return widget
def execute(my):
sobject = my.sobject
search_type = sobject.get_search_type_obj()
config = WidgetConfigView.get_by_search_type(search_type, "custom")
if not config:
return
my.element_names = config.get_element_names()
# create all of the handlers
action_handlers = []
for element_name in (my.element_names):
action_handler_class = \
config.get_action_handler(element_name)
if action_handler_class == "":
action_handler_class = "DatabaseAction"
action_handler = WidgetConfig.create_widget( action_handler_class )
action_handler.set_name(element_name)
action_handler.set_input_prefix("edit")
action_options = config.get_action_options(element_name)
for key, value in action_options.items():
action_handler.set_option(key, value)
action_handlers.append(action_handler)
# set the sobject for each action handler
for action_handler in action_handlers:
action_handler.set_sobject(sobject)
if action_handler.check():
action_handler.execute()
def get_display(self):
self.preprocess()
sobject = self.get_current_sobject()
view = self.get_option("view")
if not view:
view = "custom_view"
search_type = sobject.get_search_type_obj()
config = WidgetConfigView.get_by_search_type(search_type, view)
widget_config_view = WidgetConfigView(search_type, view, [config])
if not config:
span = SpanWdg("None")
span.add_style("color: #ccc")
return span
try:
base = CustomConfigWdg(search_type, view, \
config=widget_config_view, input_prefix="edit")
except TacticException, e:
span = SpanWdg("None")
span.add_style("color: #ccc")
return span
def get_display(my):
my.preprocess()
sobject = my.get_current_sobject()
view = my.get_option("view")
if not view:
view = "custom_view"
search_type = sobject.get_search_type_obj()
config = WidgetConfigView.get_by_search_type(search_type, view)
widget_config_view = WidgetConfigView(search_type, view, [config])
if not config:
span = SpanWdg("None")
span.add_style("color: #ccc")
return span
try:
base = CustomConfigWdg(search_type, view, \
config=widget_config_view, input_prefix="edit")
except TacticException, e:
span = SpanWdg("None")
span.add_style("color: #ccc")
return span
def execute(my):
assert my.search_type
assert my.view
assert my.file_path
search = Search(my.search_type)
if my.search_ids:
search.add_enum_order_by("id", my.search_ids)
search.add_filters("id", my.search_ids)
sobjects = search.get_sobjects()
elif my.search_keys:
sobjects = Search.get_by_search_keys(my.search_keys, keep_order=True)
"""
search_codes = [SearchKey.extract_code(i) for i in my.search_keys if SearchKey.extract_code(i) ]
if search_codes:
search.add_filters("code", search_codes)
else:
search_ids = [SearchKey.extract_id(i) for i in my.search_keys if SearchKey.extract_id(i) ]
search.add_filters("id", search_ids)
"""
else:
sobjects = search.get_sobjects()
from pyasm.widget import WidgetConfigView
from pyasm.web import Widget
config = WidgetConfigView.get_by_search_type(my.search_type, my.view)
columns = []
if my.column_names:
columns = my.column_names
# should allow exporting ids only
"""
else:
if not config:
columns = search.get_columns()
else:
columns = config.get_element_names()
"""
if my.include_id:
columns.insert(0, "id")
# create the csv file
org_file = file(my.file_path, 'w')
csvwriter = csv.writer(org_file, quoting=csv.QUOTE_NONNUMERIC)
# write the titles
csvwriter.writerow(columns)
elements = my.get_elements(config, columns)
display_option_dict = {}
# this is for widgets that do preprocessing on all sobjects
for idx, element in enumerate(elements):
element.set_sobjects(sobjects)
element.preprocess()
display_options = config.get_display_options(columns[idx])
display_option_dict[element] = display_options
for idx, sobject in enumerate(sobjects):
values = []
for element in elements:
element.set_current_index(idx)
value = element.get_text_value()
if isinstance(value, Widget):
value = value.get_buffer_display()
elif isinstance(value, basestring):
if isinstance(value, unicode):
value = value.encode('UTF-8', 'ignore')
else:
value = str(value)
options = display_option_dict.get(element)
if options.get('csv_force_string')=='true' and value:
value= '#FORCESTRING#%s'%value
values.append( value )
# write the values as list
csvwriter.writerow(values)
org_file.close()
file2 = open(my.file_path, 'r')
mod_file_path = '%s_mod' %my.file_path
mod_file = open(mod_file_path, 'w')
for line in file2:
mod_line = re.sub(r'(\'|\"|)(#FORCESTRING#)', '=\\1', line)
mod_file.write(mod_line)
# new file
file2.close()
mod_file.close()
#os.unlink(my.file_path)
shutil.move(mod_file_path, my.file_path)
def init(my):
my.is_refresh = my.kwargs.get("refresh")
my.search_key = my.kwargs.get("search_key")
my.ticket_key = my.kwargs.get("ticket")
my.parent_key = my.kwargs.get("parent_key")
my.expression = my.kwargs.get("expression")
# This assumed parent can cause errors as it tries to find a
# relationship between to stypes that don't exist ... or worse,
# try to bind them when one stype does not have the sufficent columns
# ie: pipeline_code
#if not my.parent_key:
# project = Project.get()
# my.parent_key = project.get_search_key()
my.code = my.kwargs.get("code")
sobject = None
if my.search_key:
sobject = Search.get_by_search_key(my.search_key)
my.search_id = sobject.get_id()
my.search_type = sobject.get_base_search_type()
if sobject.is_insert():
my.mode = 'insert'
else:
my.mode = 'edit'
elif my.expression:
sobject = Search.eval(my.expression, single=True)
my.search_id = sobject.get_id()
my.search_type = sobject.get_base_search_type()
my.mode = 'edit'
elif my.ticket_key:
from pyasm.security import Ticket, Login
ticket = Ticket.get_by_valid_key(my.ticket_key)
if not ticket:
raise TacticException("No valid ticket")
login_code = ticket.get_value("login")
login = Login.get_by_code(login_code)
my.search_type = "sthpw/login"
my.search_id = login.get_id()
my.mode = 'edit'
elif my.code:
my.search_type = my.kwargs.get("search_type")
search = Search(my.search_type)
search.add_filter("code", my.code)
sobject = search.get_sobject()
my.search_id = sobject.get_id()
my.search_type = sobject.get_base_search_type()
my.mode = 'edit'
else:
my.search_type = my.kwargs.get("search_type")
my.search_id = my.kwargs.get("search_id")
if not my.search_id:
my.search_id = -1
my.search_id = int(my.search_id)
if my.search_id != -1:
my.mode = "edit"
else:
my.mode = "insert"
# explicit override
if my.kwargs.get("mode"):
my.mode = my.kwargs.get("mode")
my.view = my.kwargs.get("view")
if not my.view:
my.view = my.kwargs.get("config_base")
if not my.view:
my.view = "edit"
default_data = my.kwargs.get('default')
if not default_data:
default_data = {}
elif isinstance(default_data, basestring):
try:
default_data = jsonloads(default_data)
except:
#may be it's regular dictionary
try:
default_data = eval(default_data)
except:
print "Warning: Cannot evaluate [%s]" %default_data
default_data = {}
if sobject:
my.set_sobjects([sobject], None)
else:
my.do_search()
# TODO: get_config() is going the right direction (less features) but the more complicated method is biased
# towards edit and insert view.. and so it needs improvement as well
if my.view not in ["insert", "edit"]:
# try a new smaller way to get config only when an explicit view
# is set
my.config = my.get_config()
else:
my.config = WidgetConfigView.get_by_search_type(my.search_type, my.view, use_cache=False)
# for inline config definitions
config_xml = my.kwargs.get("config_xml")
if config_xml:
#from pyasm.common import Xml
#xml = Xml()
#xml.read_string(config_xml)
#node = xml.get_node("config/%s" % my.view)
#xml.set_attribute(node, "class", "tactic.ui.panel.EditWdg")
#config = WidgetConfig.get(view=my.view, xml=xml)
config_xml = config_xml.replace("&", "&")
config = WidgetConfig.get(view="tab", xml=config_xml)
my.config.insert_config(0, config)
my.skipped_element_names = []
# if there is a layout view, then find the element names using that
layout_view = my.kwargs.get("layout_view")
if layout_view:
layout_view = layout_view.replace("/", ".")
search = Search("config/widget_config")
search.add_filter("view", layout_view)
layout_config = search.get_sobject()
xml = layout_config.get_xml_value("config")
my.element_names = xml.get_values("config//html//element/@name")
else:
my.element_names = my.config.get_element_names()
ignore = my.kwargs.get("ignore")
if isinstance(ignore, basestring):
ignore = ignore.split("|")
if not ignore:
ignore = []
my.element_titles = []
my.element_descriptions = []
for element_name in my.element_names:
my.element_titles.append( my.config.get_element_title(element_name) )
my.element_descriptions.append( my.config.get_element_description(element_name) )
#my.element_titles = my.config.get_element_titles()
#my.element_descriptions = my.config.get_element_descriptions()
# MongoDb
# Default columns
if not my.element_names:
impl = SearchType.get_database_impl_by_search_type(my.search_type)
if impl.get_database_type() == "MongoDb":
my.element_names = impl.get_default_columns()
my.element_titles = ['Code', 'Name', 'Description']
my.element_descriptions = ['Code', 'Name', 'Description']
my.input_prefix = my.kwargs.get('input_prefix')
if not my.input_prefix:
my.input_prefix = 'edit'
security = Environment.get_security()
default_access = "edit"
project_code = Project.get_project_code()
for i, element_name in enumerate(my.element_names):
if element_name in ignore:
my.skipped_element_names.append(element_name)
continue
# check security access
access_key2 = {
'search_type': my.search_type,
'project': project_code
}
access_key1 = {
'search_type': my.search_type,
'key': element_name,
'project': project_code
}
access_keys = [access_key1, access_key2]
is_editable = security.check_access('element', access_keys, "edit", default=default_access)
if not is_editable:
my.skipped_element_names.append(element_name)
continue
widget = my.config.get_display_widget(element_name, kbd_handler=False)
# some element could be disabled due to its data_type e.g. sql_timestamp
if not widget:
my.skipped_element_names.append(element_name)
continue
widget.set_sobject(my.sobjects[0])
default_value = default_data.get(element_name)
if default_value:
widget.set_value(default_value)
attrs = my.config.get_element_attributes(element_name)
editable = widget.is_editable()
if editable:
editable = attrs.get("edit")
editable = editable != "false"
if not editable:
my.skipped_element_names.append(element_name)
continue
# set parent
widget.set_parent_wdg(my)
# set parent_key in insert mode for now
if my.mode =='insert' and my.parent_key:
widget.set_option('parent_key', my.parent_key)
title = my.element_titles[i]
if title:
widget.set_title(title)
my.widgets.append(widget)
description = my.element_descriptions[i]
widget.add_attr("title", description)
def get_sobject_detail_wdg(my):
div = DivWdg()
#div.add_style("float: right")
div.add_style("width: 100%")
div.add_style("height: 100%")
div.add_style("padding-top: 5px")
info_div = DivWdg()
div.add(info_div)
#info_div.add_style("display: none")
info_div.add_class("spt_sobject_detail")
#info_div.add_style("width: 300px")
info_div.add_style("padding: 30px 0px 20px 0px")
info_table = Table()
info_table.add_color("color", "color")
info_div.add(info_table)
edit_div = DivWdg()
#edit_div.add_border(color="#EEE")
info_div.add(edit_div)
edit_div.add_style("margin-top: -36px")
edit_div.add_style("margin-left: 1px")
edit_div.add_style("margin-right: -2px")
#edit_div.add_style("overflow: scroll")
#edit_div.add_style("height: 100%")
edit_div.add_style("max-height: 300px")
edit_div.add_style("overflow-y: auto")
ignore = ["preview", "notes", "files"]
from tactic.ui.panel.edit_layout_wdg import EditLayoutWdg
if my.parent:
sobject = my.get_sobject()
search_type = sobject.get_search_type()
search_key = sobject.get_search_key()
# get the element names from the edit view
config = WidgetConfigView.get_by_search_type(
search_type=search_type, view="edit")
element_names = config.get_element_names()
edit = EditLayoutWdg(search_type=search_type,
mode='view',
view="detail",
search_key=search_key,
width=400,
title=' ',
ignore=ignore,
element_names=element_names)
edit_div.add(edit)
else:
view = my.kwargs.get("detail_view")
if not view:
view = "edit"
element_names = ['code', 'name', 'description']
config = WidgetConfigView.get_by_search_type(
search_type=my.full_search_type, view=view)
config_element_names = config.get_element_names()
for x in config_element_names:
if x in ignore:
continue
if x not in element_names:
element_names.append(x)
edit = EditLayoutWdg(search_type=my.full_search_type,
mode='view',
view="detail",
search_key=my.search_key,
width=400,
title=' ',
ignore=ignore,
element_names=element_names)
edit_div.add(edit)
# TEST extra data from a related sobject
"""
related_search_type = "jobs/photo"
element_names = ['photographer']
related = Search.eval("@SOBJECT(%s)" % related_search_type, my.sobject, single=True)
if related:
related_key = related.get_search_key()
from tactic.ui.panel.edit_layout_wdg import EditLayoutWdg
edit = EditLayoutWdg(search_type=search_type, mode='view', view="detail", search_key=related_key, width=400, title=' ', element_names=element_names)
edit_div.add(edit)
"""
return div
def get_sobject_detail_wdg(my):
div = DivWdg()
#div.add_style("float: right")
div.add_style("width: 100%")
div.add_style("height: 100%")
div.add_style("padding-top: 5px")
info_div = DivWdg()
div.add(info_div)
#info_div.add_style("display: none")
info_div.add_class("spt_sobject_detail")
#info_div.add_style("width: 300px")
info_div.add_style("padding: 30px 0px 30px 0px")
info_table = Table()
info_table.add_color("color", "color")
info_div.add(info_table)
edit_div = DivWdg()
info_div.add(edit_div)
edit_div.add_style("margin-top: -35px")
edit_div.add_style("margin-left: 1px")
edit_div.add_style("margin-right: -2px")
#edit_div.add_style("overflow: scroll")
edit_div.add_style("height: 100%")
view = my.kwargs.get("detail_view")
if not view:
view = "edit"
ignore = ["preview", "notes"]
element_names = ['name', 'description', 'tasks']
config = WidgetConfigView.get_by_search_type(
search_type=my.full_search_type, view=view)
config_element_names = config.get_element_names()
for x in config_element_names:
if x in ignore:
continue
if x not in element_names:
element_names.append(x)
# add the tile
title = DivWdg()
edit_div.add(title)
title.add_gradient("background", "background3", 0, -10)
title.add_style("height: 20px")
title.add_style("padding: 4px")
title.add_style("font-weight: bold")
title.add(" ")
title.add_border()
from tactic.ui.panel.edit_layout_wdg import EditLayoutWdg
edit = EditLayoutWdg(search_type=my.full_search_type,
mode='view',
view="detail",
search_key=my.search_key,
width=400,
title=' ',
ignore=ignore,
element_names=element_names)
edit_div.add(edit)
# TEST extra data from a related sobject
"""
related_search_type = "jobs/photo"
element_names = ['photographer']
related = Search.eval("@SOBJECT(%s)" % related_search_type, my.sobject, single=True)
if related:
related_key = related.get_search_key()
from tactic.ui.panel.edit_layout_wdg import EditLayoutWdg
edit = EditLayoutWdg(search_type=search_type, mode='view', view="detail", search_key=related_key, width=400, title=' ', element_names=element_names)
edit_div.add(edit)
"""
return div
def preprocess(my):
my.max_value = 0
my.min_value = 0
my.steps = 0
web = WebContainer.get_web()
my.width = web.get_form_value("width")
if not my.width:
my.width = my.kwargs.get("width")
my.chart_type = web.get_form_value("chart_type")
if not my.chart_type:
my.chart_type = my.kwargs.get("chart_type")
if not my.chart_type:
my.chart_type = 'bar'
my.x_axis = web.get_form_value("x_axis")
if not my.x_axis:
my.x_axis = my.kwargs.get("x_axis")
if not my.x_axis:
my.x_axis = 'code'
# FIXME: which should override???
my.y_axis = web.get_form_values("y_axis")
if not my.y_axis:
my.y_axis = my.kwargs.get("y_axis")
if my.y_axis:
my.elements = my.y_axis
else:
my.elements = my.kwargs.get("elements")
if not my.elements:
my.elements = web.get_form_value("elements")
if isinstance(my.elements, basestring):
if my.elements:
my.elements = my.elements.split('|')
else:
my.elements = []
my.search_type = web.get_form_value("search_type")
if not my.search_type:
my.search_type = my.kwargs.get("search_type")
my.search_keys = my.kwargs.get("search_keys")
if my.search_type and my.search_type.startswith("@SOBJECT("):
my.sobjects = Search.eval(my.search_type)
elif my.search_keys:
if isinstance(my.search_keys, basestring):
my.search_keys = eval(my.search_keys)
my.sobjects = Search.get_by_search_keys(my.search_keys)
else:
search = Search(my.search_type)
search.add_limit(100)
my.sobjects = search.get_sobjects()
# get the definition
sobjects = my.sobjects
if sobjects:
sobject = sobjects[0]
search_type = sobject.get_search_type()
view = 'definition'
from pyasm.widget import WidgetConfigView
my.config = WidgetConfigView.get_by_search_type(search_type, view)
else:
my.config = None
my.widgets = {}
def get_filter_wdg(my):
div = DivWdg()
div.add_style("padding: 10px")
div.add_style("margin: -10 -10 10 -10")
div.add_style("min-width: 600px")
div.add_class("spt_view_manager_filter")
from tactic.ui.app import HelpButtonWdg
help_wdg = HelpButtonWdg(alias="view-manager|what-are-views")
div.add(help_wdg)
help_wdg.add_style("float: right")
div.add('<b>Search Type:</b> ')
div.add_gradient("background", "background", -10)
security = Environment.get_security()
project = Project.get()
if security.check_access("builtin", "view_site_admin", "allow"):
search_type_objs = project.get_search_types(include_sthpw=True, include_config=True)
else:
search_type_objs = project.get_search_types()
search_types = [x.get_value("search_type") for x in search_type_objs]
titles = ["%s (%s)" % (x.get_value("search_type"), x.get_value("title")) for x in search_type_objs]
select = SelectWdg(name='search_type')
select.set_option('values', search_types)
select.set_option('labels', titles)
select.add_empty_option('-- Select --')
select.set_persistence()
#select.set_persist_on_submit()
#security = Environment.get_security()
#if security.check_access("builtin", "view_site_admin", "allow"):
# select_mode = SearchTypeSelectWdg.ALL
#else:
# select_mode = SearchTypeSelectWdg.ALL_BUT_STHPW
#select = SearchTypeSelectWdg(name='search_type', \
# mode=select_mode)
behavior = {'type': 'change', 'cbjs_action': '''
var manager_top = bvr.src_el.getParent(".spt_view_manager_top");
var input = spt.api.Utility.get_input(manager_top, 'search_type');
var view_input = spt.api.Utility.get_input(manager_top, 'view');
var view_input_value = '';
if (view_input != null) {
view_input_value = view_input.value;
}
var values = {'search_type': input.value, 'view': view_input_value, 'is_refresh': 'true'};
spt.panel.refresh(manager_top, values);'''
#//spt.panel.refresh(manager_top, values);'''
}
select.add_behavior(behavior)
select.set_value(my.search_type)
div.add(select)
if not my.search_type:
content = DivWdg()
content.add_style("width: 400px")
content.add_style("height: 400px")
div.add(content)
content.add_style("padding: 20px")
content.add( IconWdg("WARNING", IconWdg.WARNING) )
content.add("No Search Type Selected")
content.add_border()
content.add_style("margin-top: 20px")
content.add_color("background", "background")
content.add_style("font-weight: bold")
return div
div.add(' ')
div.add('<b>View: </b>')
view_wdg = SelectWdg("view")
view_wdg.set_value(my.view)
view_wdg.add_empty_option("-- Select --")
view_wdg.add_behavior(behavior)
div.add(view_wdg)
search = Search("config/widget_config")
search.add_filter("search_type", my.search_type)
db_configs = search.get_sobjects()
views = set()
for db_config in db_configs:
view = db_config.get_value("view")
if view.startswith('link_search:'):
continue
views.update([view])
#print "search_type: ", my.search_type
#print "view: ", views, my.view
if my.search_type and my.view:
config_view = WidgetConfigView.get_by_search_type(my.search_type, my.view)
configs = config_view.get_configs()
for x in configs:
view = x.get_view()
file_path = x.get_file_path()
if view != my.view:
continue
if file_path and file_path.endswith("DEFAULT-conf.xml"):
continue
config_views = x.get_all_views()
views.update(config_views)
views_list = list(views)
views_list.sort()
view_wdg.set_option("values", views_list)
return div
def init(self):
# create all of the display elements
if not self.config:
# it shouldn't use the self.search_type_obj here as it would absorb the project info
self.config = WidgetConfigView.get_by_search_type(self.search_type, self.config_base)
self.element_names = self.config.get_element_names()
self.element_titles = self.config.get_element_titles()
# TODO: should probably be all the attrs
self.element_widths = self.config.get_element_widths()
simple_view = self.kwargs.get("show_simple_view")
if simple_view == "true":
simple_view = True
else:
simple_view = False
self.extra_data = self.kwargs.get("extra_data")
if self.extra_data and isinstance(self.extra_data, basestring):
try:
self.extra_data = jsonloads(self.extra_data)
except:
self.extra_data = self.extra_data.replace("'", '"')
self.extra_data = jsonloads(self.extra_data)
# go through each element name and construct the handlers
for idx, element_name in enumerate(self.element_names):
# check to see if these are removed for this production
#if element_name in invisible_elements:
# continue
simple_element = None
display_handler = self.config.get_display_handler(element_name)
new_display_handler = self.remap_display_handler(display_handler)
if new_display_handler:
display_handler = new_display_handler
if not display_handler:
# else get it from default of this type
display_handler = self.get_default_display_handler(element_name)
# get the display options
display_options = self.config.get_display_options(element_name)
# add in extra_data
if self.extra_data:
for key, value in self.extra_data.items():
display_options[key] = value
try:
if not display_handler:
element = self.config.get_display_widget(element_name)
else:
display_options['element_name'] = element_name
element = WidgetConfig.create_widget( display_handler, display_options=display_options )
except Exception as e:
from tactic.ui.common import WidgetTableElementWdg
element = WidgetTableElementWdg()
# FIXME: not sure why this doesn't work
#from pyasm.widget import ExceptionWdg
#log = ExceptionWdg(e)
#element.add(log)
# FIXME: not sure why this doesn't work
from pyasm.widget import IconWdg
icon = IconWdg("Error", IconWdg.ERROR)
element.add(icon)
element.add(e)
# skip the empty elements like ThumbWdg
if simple_element and not element.is_simple_viewable():
continue
# make simple_element the element if it exists
if simple_element:
element = simple_element
# if the element failed to create, then continue
if element == None:
continue
element.set_name(element_name)
title = self.element_titles[idx]
element.set_title(title)
# FIXME: this causes a circular reference which means the
# Garbage collector can't clean it up
# make sure the element knows about its layout engine
element.set_layout_wdg(self)
# TODO: should convert this to ATTRS or someting like that. Not
# just width
if idx >= len(self.element_widths):
element.width = 150
else:
element.width = self.element_widths[idx]
if self.input_prefix:
element.set_input_prefix(self.input_prefix)
# get the display options
#display_options = self.config.get_display_options(element_name)
#for key in display_options.keys():
element.set_options(display_options)
self.add_widget(element,element_name)
# layout widgets also categorize their widgets based on type
if element_name == "Filter":
section_name = 'filter'
else:
section_name = 'default'
section = self.sections.get(section_name)
if not section:
section = []
self.sections[section_name] = section
section.append(element)
# go through each widget and pass them the filter_data object
from tactic.ui.filter import FilterData
filter_data = FilterData.get()
if not filter_data:
filter_data = {}
for widget in self.widgets:
widget.set_filter_data(filter_data)
# initialize all of the child widgets
super(BaseConfigWdg,self).init()
def execute(my):
web = WebContainer.get_web()
# get command line options
search_type = my.kwargs.get("search_type")
assert search_type
view = my.kwargs.get("view")
if not view:
view = get_template_view()
# check if this is advanced mode
mode = web.get_form_value("custom_mode")
if not mode:
mode = 'simple'
if mode == 'xml':
config_string = web.get_form_value("config_xml")
# handle the "default" view
view = DEFAULT_VIEW
config = WidgetDbConfig.get_by_search_type(search_type, view)
if not config:
config = WidgetDbConfig.create(search_type, view)
xml = Xml()
xml.read_string(config_string)
element_name = xml.get_value("element/@name")
element_name = element_name.strip()
assert element_name
type = xml.get_value("element/@type")
if not type:
class_name = xml.get_value("element/display/@class")
if not class_name:
raise TacticException("Either a type or class name needs to be defined in config xml.")
config.append_xml_element(element_name,config_string)
config.commit_config()
# create the required columns
widget = config.get_display_widget(element_name)
columns = widget.get_required_columns()
if columns:
print "WARNING: need to create columns: ", columns
my.info['element_name'] = element_name
return
type = web.get_form_value("custom_type")
description = web.get_form_value("custom_description")
if not description:
description = "No descripton"
title = web.get_form_value("custom_title")
name = web.get_form_value("custom_name")
name = name.strip()
if not name:
raise TacticException("No name specified")
add_to_current_view = web.get_form_value("add_to_current_view")
add_to_edit_view = web.get_form_value("add_to_edit_view")
is_searchable = web.get_form_value("is_searchable")
# create the column
if type not in ['button', 'empty']:
cmd = ColumnAddCmd(search_type, name, type)
cmd.execute()
# create the type
class_name = None
options = {}
# this is actually element attrs
element_options = {}
edit_class_name = None
edit_options = {}
edit_attrs = {}
element_type = type
# Date Range is not used any more in the UI"
if type == "Date Range":
class_name = "GanttWdg"
options["start_date_column"] = "%s_start_date" % name
options["end_deate_column"] = "%s_end_date" % name
elif type == "date":
class_name = "DateWdg"
#edit_class_name = "CalendarWdg"
element_type = 'timestamp'
edit_attrs['type'] = 'timestamp'
edit_class_name = ""
add_to_edit_view = True
elif type == "foreign_key":
class_name = ""
edit_class_name = "SelectWdg"
foreign_search_type = web.get_form_value("foreign_key_search_select")
edit_options["query"] = '%s|code|code' % foreign_search_type
# turn on add to edit view
add_to_edit_view = True
elif type == "button":
class_name = "tactic.ui.table.ButtonElementWdg"
script = web.get_form_value("option_script_select")
if script:
options['script'] = script
icon = web.get_form_value("option_icon_select")
if icon:
options['icon'] = icon
edit_class_name = ""
# This does not have a type
element_type = None
elif type == "empty":
element_type = None
pass
elif type == "list":
class_name = ""
edit_class_name = "SelectWdg"
list_values = web.get_form_value("list_values")
edit_options['values'] = list_values
add_to_edit_view = True
element_options['type'] = element_type
element_options['title'] = title
# handle the "default" view
view = DEFAULT_VIEW
config = WidgetDbConfig.get_by_search_type(search_type, view)
if not config:
config = WidgetDbConfig.create(search_type, view)
config.append_display_element(name, class_name, options=options, \
element_attrs=element_options)
config.commit_config()
# get the config file
if add_to_current_view:
config = WidgetDbConfig.get_by_search_type(search_type, view)
if not config:
# if it doesn't exist, the check to see, if there is a hard
# coded view out there
predefined_config = WidgetConfigView.get_by_search_type(search_type, view)
xml = predefined_config.get_xml()
# create a new db one
config = WidgetDbConfig.create(search_type, view)
if xml:
config.set_value("config", xml.to_string())
config._init()
config.append_display_element(name)
config.commit_config()
# TODO: Need to make this searchable using simple search ?????
if is_searchable:
element_options['searchable'] = 'true'
# handle the "edit"
if add_to_edit_view and view != "edit":
config = WidgetDbConfig.get_by_search_type(search_type, "edit")
if not config:
config = WidgetDbConfig.create(search_type, "edit")
config.append_display_element(name, edit_class_name, edit_options,element_attrs=edit_attrs)
config.commit_config()
"""
# this sType has been deprecated
sobject = SearchType.create("prod/custom_property")
sobject.set_value("search_type", search_type)
sobject.set_value("name", name)
sobject.set_value("description", description)
sobject.commit()
"""
# set some information
my.description = "Added Property [%s] of type [%s] to [%s]" % \
(name, type, search_type)
my.info['element_name'] = name
def init(my):
my.is_refresh = my.kwargs.get("refresh")
my.search_key = my.kwargs.get("search_key")
my.ticket_key = my.kwargs.get("ticket")
my.parent_key = my.kwargs.get("parent_key")
my.expression = my.kwargs.get("expression")
# This assumed parent can cause errors as it tries to find a
# relationship between to stypes that don't exist ... or worse,
# try to bind them when one stype does not have the sufficent columns
# ie: pipeline_code
#if not my.parent_key:
# project = Project.get()
# my.parent_key = project.get_search_key()
my.code = my.kwargs.get("code")
sobject = None
if my.search_key:
sobject = Search.get_by_search_key(my.search_key)
my.search_id = sobject.get_id()
my.search_type = sobject.get_base_search_type()
if sobject.is_insert():
my.mode = 'insert'
else:
my.mode = 'edit'
elif my.expression:
sobject = Search.eval(my.expression, single=True)
my.search_id = sobject.get_id()
my.search_type = sobject.get_base_search_type()
my.mode = 'edit'
elif my.ticket_key:
from pyasm.security import Ticket, Login
ticket = Ticket.get_by_valid_key(my.ticket_key)
if not ticket:
raise TacticException("No valid ticket")
login_code = ticket.get_value("login")
login = Login.get_by_code(login_code)
my.search_type = "sthpw/login"
my.search_id = login.get_id()
my.mode = 'edit'
elif my.code:
my.search_type = my.kwargs.get("search_type")
search = Search(my.search_type)
search.add_filter("code", my.code)
sobject = search.get_sobject()
my.search_id = sobject.get_id()
my.search_type = sobject.get_base_search_type()
my.mode = 'edit'
else:
my.search_type = my.kwargs.get("search_type")
my.search_id = my.kwargs.get("search_id")
if not my.search_id:
my.search_id = -1
my.search_id = int(my.search_id)
if my.search_id != -1:
my.mode = "edit"
else:
my.mode = "insert"
# explicit override
if my.kwargs.get("mode"):
my.mode = my.kwargs.get("mode")
my.view = my.kwargs.get("view")
if not my.view:
my.view = my.kwargs.get("config_base")
if not my.view:
my.view = "edit"
default_data = my.kwargs.get('default')
if not default_data:
default_data = {}
elif isinstance(default_data, basestring):
try:
default_data = jsonloads(default_data)
except:
#may be it's regular dictionary
try:
default_data = eval(default_data)
except:
print "Warning: Cannot evaluate [%s]" %default_data
default_data = {}
if sobject:
my.set_sobjects([sobject], None)
else:
my.do_search()
# TODO: get_config() is going the right direction (less features) but the more complicated method is biased
# towards edit and insert view.. and so it needs improvement as well
if my.view not in ["insert", "edit"]:
# try a new smaller way to get config only when an explicit view
# is set
my.config = my.get_config()
else:
my.config = WidgetConfigView.get_by_search_type(my.search_type, my.view, use_cache=False)
# for inline config definitions
config_xml = my.kwargs.get("config_xml")
if config_xml:
#from pyasm.common import Xml
#xml = Xml()
#xml.read_string(config_xml)
#node = xml.get_node("config/%s" % my.view)
#xml.set_attribute(node, "class", "tactic.ui.panel.EditWdg")
#config = WidgetConfig.get(view=my.view, xml=xml)
config_xml = config_xml.replace("&", "&")
config = WidgetConfig.get(view="tab", xml=config_xml)
my.config.insert_config(0, config)
my.skipped_element_names = []
# if there is a layout view, then find the element names using that
layout_view = my.kwargs.get("layout_view")
if layout_view:
layout_view = layout_view.replace("/", ".")
search = Search("config/widget_config")
search.add_filter("view", layout_view)
layout_config = search.get_sobject()
xml = layout_config.get_xml_value("config")
my.element_names = xml.get_values("config//html//element/@name")
else:
my.element_names = my.config.get_element_names()
ignore = my.kwargs.get("ignore")
if isinstance(ignore, basestring):
ignore = ignore.split("|")
if not ignore:
ignore = []
my.element_titles = []
my.element_descriptions = []
for element_name in my.element_names:
my.element_titles.append( my.config.get_element_title(element_name) )
my.element_descriptions.append( my.config.get_element_description(element_name) )
#my.element_titles = my.config.get_element_titles()
#my.element_descriptions = my.config.get_element_descriptions()
# MongoDb
# Default columns
if not my.element_names:
impl = SearchType.get_database_impl_by_search_type(my.search_type)
if impl.get_database_type() == "MongoDb":
my.element_names = impl.get_default_columns()
my.element_titles = ['Code', 'Name', 'Description']
my.element_descriptions = ['Code', 'Name', 'Description']
my.input_prefix = my.kwargs.get('input_prefix')
if not my.input_prefix:
my.input_prefix = 'edit'
security = Environment.get_security()
default_access = "edit"
project_code = Project.get_project_code()
for i, element_name in enumerate(my.element_names):
if element_name in ignore:
my.skipped_element_names.append(element_name)
continue
# check security access
access_key2 = {
'search_type': my.search_type,
'project': project_code
}
access_key1 = {
'search_type': my.search_type,
'key': element_name,
'project': project_code
}
access_keys = [access_key1, access_key2]
is_editable = security.check_access('element', access_keys, "edit", default=default_access)
if not is_editable:
my.skipped_element_names.append(element_name)
continue
widget = my.config.get_display_widget(element_name, kbd_handler=False)
# some element could be disabled due to its data_type e.g. sql_timestamp
if not widget:
my.skipped_element_names.append(element_name)
continue
widget.set_sobject(my.sobjects[0])
default_value = default_data.get(element_name)
if default_value:
widget.set_value(default_value)
attrs = my.config.get_element_attributes(element_name)
editable = widget.is_editable()
if editable:
editable = attrs.get("edit")
editable = editable != "false"
if not editable:
my.skipped_element_names.append(element_name)
continue
# set parent
widget.set_parent_wdg(my)
# set parent_key in insert mode for now
if my.mode =='insert' and my.parent_key:
widget.set_option('parent_key', my.parent_key)
title = my.element_titles[i]
if title:
widget.set_title(title)
my.widgets.append(widget)
description = my.element_descriptions[i]
widget.add_attr("title", description)
def get_display(my):
if not my.search_type:
return "No search type found"
web = WebContainer.get_web()
my.view = web.get_form_value("view")
if not my.view:
my.view = web.get_form_value("filter|view")
if not my.view:
my.view = get_template_view()
widget = Widget()
widget.add( HiddenWdg("search_type", my.search_type) )
element_names = []
# see if there is an override
search_type_obj = SearchType.get(my.search_type)
config = WidgetConfigView.get_by_search_type(my.search_type,"browser_list")
if config:
element_names = config.get_element_names()
search = Search("sthpw/widget_config")
search.add_filter("search_type", my.search_type)
search.add_filter("view", my.view)
widget_config = search.get_sobject()
if widget_config:
edit_link_wdg = EditLinkWdg("sthpw/widget_config", widget_config.get_id(), text="Edit XML", long=True)
edit_link_wdg.set_iframe_width(95)
widget.add(edit_link_wdg)
custom_config = WidgetConfigView.get_by_search_type(my.search_type,my.view)
custom_element_names = custom_config.get_element_names()
# get the custom properties
search = Search("prod/custom_property")
search.add_filter("search_type", my.search_type)
custom_properties = search.get_sobjects()
# action popup
action_popup = PopupMenuWdg("table_action", multi=True, width='12em')
action_popup.set_auto_hide(False)
action_popup.set_submit(False)
action_popup.add( HtmlElement.href("Add ...", "javascript:document.form.submit()") )
for custom_property in custom_properties:
element_name = custom_property.get_name()
if element_name not in custom_element_names:
action_popup.add( " %s" % element_name, "add|%s" % element_name )
# if there is an override
if element_names:
for element_name in element_names:
if element_name not in custom_element_names:
action_popup.add( " %s" % element_name, "add|%s" % element_name )
# get all of the columns
else:
search_type_obj = SearchType.get(my.search_type)
element_names = search_type_obj.get_columns()
for element_name in element_names:
if element_name not in custom_element_names:
action_popup.add( " %s" % element_name, "add|%s" % element_name )
# add some standard properties
if my.view in ["edit", "insert"]:
for element_name in PREDEFINED_EDIT_ELEMENTS:
if element_name not in custom_element_names:
action_popup.add( " %s" % element_name, "add|%s" % element_name )
else:
for element_name in PREDEFINED_ELEMENTS:
if element_name not in custom_element_names:
action_popup.add( " %s" % element_name, "add|%s" % element_name )
action_popup.add_separator()
action_popup.add( HtmlElement.href("Remove ...", "javascript:document.form.submit()") )
for element_name in custom_element_names:
action_popup.add( " %s" % element_name, "remove|%s" % element_name )
action_popup.add_separator()
span = SpanWdg("New Custom ...", css="hand")
iframe = WebContainer.get_iframe()
url = WebContainer.get_web().get_widget_url()
url.set_option("widget", "pyasm.widget.CustomAddPropertyWdg")
url.set_option("search_type", my.search_type)
url.set_option("view", my.view)
action = iframe.get_on_script(url.to_string() )
span.add_event("onclick", action)
action_popup.add( span )
# add the edit button
edit = IconButtonWdg("Edit View", IconWdg.EDIT, True)
edit.add_event("oncontextmenu", "%s;return false" % action_popup.get_on_script() )
edit.add_event("onclick", "%s" % action_popup.get_on_script() )
# lay it all out
widget.add(SpanWdg(action_popup))
widget.add(edit)
# add the edit button
#save = IconButtonWdg("Save", IconWdg.SAVE, True)
#widget.add(save)
# add the add property button
if my.mode == "admin":
add = CustomAddPropertyLinkWdg(my.search_type, my.view)
widget.add(add)
#add_element = CustomAddElementLinkWdg(my.search_type, my.view)
#widget.add(add_element)
# add the clear button
if my.mode == "admin" or my.view.startswith("custom_"):
clear = IconSubmitWdg("Clear", IconWdg.DELETE, True)
widget.add(clear)
widget.add(SpanWdg(css="small"))
WebContainer.register_cmd("pyasm.widget.CustomViewAction")
return widget
def get_sobject_detail_wdg(my):
div = DivWdg()
#div.add_style("float: right")
div.add_style("width: 100%")
div.add_style("height: 100%")
div.add_style("padding-top: 5px")
"""
button_div.add_class("spt_left")
div.add(button_div)
button = IconButtonWdg(title="Show More Details", icon=IconWdg.RIGHT)
button_div.add(button)
button_div.add_style("position: absolute")
button_div.add_style("margin-left: -30px")
button_div.add_style("margin-top: -2px")
button_div.add_style("display: none")
button.add_behavior( {
'type': 'click_up',
'cbjs_action': '''
var top = bvr.src_el.getParent(".spt_detail_top");
var detail = top.getElement(".spt_sobject_detail");
spt.toggle_show_hide(detail);
var left = top.getElement(".spt_left");
spt.hide(left);
var right = top.getElement(".spt_right");
spt.show(right);
'''
} )
button_div = DivWdg()
button_div.add_class("spt_right")
div.add(button_div)
button = IconButtonWdg(title="Show More Details", icon=IconWdg.LEFT)
button_div.add(button)
button_div.add_style("position: absolute")
button_div.add_style("margin-left: -30px")
button_div.add_style("margin-top: -2px")
#button_div.add_style("display: none")
button.add_behavior( {
'type': 'click_up',
'cbjs_action': '''
var top = bvr.src_el.getParent(".spt_detail_top");
var detail = top.getElement(".spt_sobject_detail");
spt.toggle_show_hide(detail);
var left = top.getElement(".spt_left");
spt.show(left);
var right = top.getElement(".spt_right");
spt.hide(right);
'''
} )
"""
info_div = DivWdg()
div.add( info_div )
#info_div.add_style("display: none")
info_div.add_class("spt_sobject_detail")
#info_div.add_style("width: 300px")
info_div.add_style("padding: 30px 0px 30px 0px")
info_table = Table()
info_table.add_color("color", "color")
info_div.add(info_table)
edit_div = DivWdg()
info_div.add(edit_div)
edit_div.add_style("margin-top: -35px")
edit_div.add_style("margin-left: 1px")
edit_div.add_style("margin-right: -2px")
#edit_div.add_style("overflow: scroll")
edit_div.add_style("height: 100%")
view = my.kwargs.get("detail_view")
if not view:
view = "edit"
ignore = ["preview", "notes"]
element_names = ['name','description','tasks']
config = WidgetConfigView.get_by_search_type(search_type=my.full_search_type, view=view)
config_element_names = config.get_element_names()
for x in config_element_names:
if x in ignore:
continue
if x not in element_names:
element_names.append(x)
# add the tile
title = DivWdg()
edit_div.add(title)
title.add_gradient("background", "background3", 0, -10)
title.add_style("height: 20px")
title.add_style("padding: 4px")
title.add_style("font-weight: bold")
title.add(" ")
title.add_border()
from tactic.ui.panel.edit_layout_wdg import EditLayoutWdg
edit = EditLayoutWdg(search_type=my.full_search_type, mode='view', view="detail", search_key=my.search_key, width=400, title=' ', ignore=ignore, element_names=element_names)
edit_div.add(edit)
return div
def get_element_wdg(my, xml, def_config):
element_node = xml.get_node("config/tmp/element")
attrs = Xml.get_attributes(element_node)
element_name = attrs.get("name")
widget = my.get_widget(element_name)
if widget:
return widget
if not element_name:
import random
num = random.randint(0, 100000)
element_name = "element%s" % num
xml.set_attribute(element_node, "name", element_name)
# enable an ability to have a widget only loaded once in a request
if attrs.get('load_once') in ['true', True]:
widgets = Container.get("CustomLayoutWdg:widgets")
if widgets == None:
widgets = {}
Container.put("CustomLayoutWdg:widgets", widgets)
else:
if widgets[element_name] == True:
return None
widgets[element_name] = True
# provide the ability to have shorthand format
# ie: <element display_class="tactic.ui..." />
display_node = xml.get_node("config/tmp/element/display")
if display_node is None:
view = attrs.get("view")
type = attrs.get("type")
if type == "reference":
search_type = attrs.get("search_type")
my.config = WidgetConfigView.get_by_search_type(search_type, view)
# check if definition has no name. Don't use element_name
if not attrs.get("name"):
return
element_wdg = my.config.get_display_widget(element_name, extra_options=attrs)
container = DivWdg()
container.add(element_wdg)
return container
class_name = attrs.get("display_class")
# if no class name is defined and not view is defined look
# at predefined elements
if not view and not class_name:
element_wdg = my.config.get_display_widget(element_name, extra_options=attrs)
container = DivWdg()
container.add(element_wdg)
return container
# look at the attributes
if not class_name:
class_name = "tactic.ui.panel.CustomLayoutWdg"
display_node = xml.create_element("display")
xml.set_attribute(display_node, "class", class_name)
xml.append_child(element_node, display_node)
for name, value in attrs.items():
# replace the spt_ in the name.
# NOTE: should this be restricted to only spt_ attributes?
name = name.replace("spt_", "")
attr_node = xml.create_element(name)
xml.set_node_value(attr_node, value)
xml.append_child(display_node, attr_node)
load = attrs.get("load")
if load in ["async", "sequence"]:
return my.get_async_element_wdg(xml, element_name, load)
use_container = attrs.get('use_container') == 'true'
if use_container:
# DEPRECATED
container = my.get_container(xml)
else:
container = DivWdg()
# add in attribute from the element definition
# DEPRECATED: does this make any sense to have this here?
for name, value in attrs.items():
if name == 'name':
continue
container.add_style(name, value)
# add the content
try:
view_node = xml.get_node("config/tmp/element/display/view")
if view_node is not None:
view = xml.get_node_value(view_node)
if view.startswith("."):
if my.view_folder:
xml.set_node_value(view_node, "%s%s" %(my.view_folder,view))
tmp_config = WidgetConfig.get('tmp', xml=xml)
configs = []
configs.append(tmp_config)
# add the def_config if it exists
if def_config:
configs.append(def_config)
config = WidgetConfigView('CustomLayoutWdg', 'tmp', configs, state=my.state)
# NOTE: this doesn't work too well when we go to an abasolute
# view.
parent_view = my.kwargs.get("parent_view")
if parent_view:
parent_view = parent_view.replace(".", "/")
parent_view = "%s/%s" % (parent_view, my.view)
else:
parent_view = my.view
# NOTE: need some protection code for infinite loops
includes = my.kwargs.get("include")
element_wdg = config.get_display_widget(element_name, extra_options={"include":includes, "parent_view":parent_view})
element_top = element_wdg.get_top()
for name, value in attrs.items():
if name == 'class':
for item in value.split(" "):
element_top.add_class(item)
elif name == 'style':
for item in re.split(";\ ?", value):
element_top.add_style(item)
else:
element_top.set_attr(name, value)
# make a provision if this custom widget is in a table
if my.layout:
sobject = my.get_current_sobject()
element_wdg.set_sobject(sobject)
except Exception, e:
from pyasm.widget import ExceptionWdg
log = ExceptionWdg(e)
element_wdg = log
def get_filter_wdg(my):
div = DivWdg()
div.add_style("padding: 10px")
div.add_style("margin: -10 -10 10 -10")
div.add_style("min-width: 600px")
div.add_class("spt_view_manager_filter")
from tactic.ui.app import HelpButtonWdg
help_wdg = HelpButtonWdg(alias="view-manager|what-are-views")
div.add(help_wdg)
help_wdg.add_style("float: right")
div.add("<b>Search Type:</b> ")
div.add_gradient("background", "background", -10)
security = Environment.get_security()
project = Project.get()
if security.check_access("builtin", "view_site_admin", "allow"):
search_type_objs = project.get_search_types(include_sthpw=True, include_config=True)
else:
search_type_objs = project.get_search_types()
search_types = [x.get_value("search_type") for x in search_type_objs]
titles = ["%s (%s)" % (x.get_value("search_type"), x.get_value("title")) for x in search_type_objs]
select = SelectWdg(name="search_type")
select.set_option("values", search_types)
select.set_option("labels", titles)
select.add_empty_option("-- Select --")
select.set_persistence()
# select.set_persist_on_submit()
# security = Environment.get_security()
# if security.check_access("builtin", "view_site_admin", "allow"):
# select_mode = SearchTypeSelectWdg.ALL
# else:
# select_mode = SearchTypeSelectWdg.ALL_BUT_STHPW
# select = SearchTypeSelectWdg(name='search_type', \
# mode=select_mode)
behavior = {
"type": "change",
"cbjs_action": """
var manager_top = bvr.src_el.getParent(".spt_view_manager_top");
var input = spt.api.Utility.get_input(manager_top, 'search_type');
var view_input = spt.api.Utility.get_input(manager_top, 'view');
var view_input_value = '';
if (view_input != null) {
view_input_value = view_input.value;
}
var values = {'search_type': input.value, 'view': view_input_value, 'is_refresh': 'true'};
spt.panel.refresh(manager_top, values);"""
# //spt.panel.refresh(manager_top, values);'''
}
select.add_behavior(behavior)
select.set_value(my.search_type)
div.add(select)
if not my.search_type:
content = DivWdg()
content.add_style("width: 400px")
content.add_style("height: 400px")
div.add(content)
content.add_style("padding: 20px")
content.add(IconWdg("WARNING", IconWdg.WARNING))
content.add("No Search Type Selected")
content.add_border()
content.add_style("margin-top: 20px")
content.add_color("background", "background")
content.add_style("font-weight: bold")
return div
div.add(" ")
div.add("<b>View: </b>")
view_wdg = SelectWdg("view")
view_wdg.set_value(my.view)
view_wdg.add_empty_option("-- Select --")
view_wdg.add_behavior(behavior)
div.add(view_wdg)
search = Search("config/widget_config")
search.add_filter("search_type", my.search_type)
db_configs = search.get_sobjects()
views = set()
for db_config in db_configs:
view = db_config.get_value("view")
if view.startswith("link_search:"):
continue
views.update([view])
# print "search_type: ", my.search_type
# print "view: ", views, my.view
if my.search_type and my.view:
config_view = WidgetConfigView.get_by_search_type(my.search_type, my.view)
configs = config_view.get_configs()
for x in configs:
view = x.get_view()
file_path = x.get_file_path()
if view != my.view:
continue
if file_path and file_path.endswith("DEFAULT-conf.xml"):
continue
config_views = x.get_all_views()
views.update(config_views)
views_list = list(views)
views_list.sort()
view_wdg.set_option("values", views_list)
return div
class SearchWdg(BaseRefreshWdg):
def get_args_keys(my):
'''External settings which populate the widget. There are 3 ways to
define which searches exist.
1) specify the filters,
2) specify the view,
3) specify whether to use the last saved search
'''
return {
'search_type': 'The search_type that this search is operating on',
'display':
'Boolean. The initial display mode of the search. it is none by default',
'view': 'The stored view for the data. Saved Search',
'parent_key': 'Provides ability to search by a single parent key',
#'popup_embedded': 'Boolean, if True then this widget is generated for a Popup window (so now open close)',
'filter': 'manaual data structure for filter',
'use_last_search':
'Boolean to determine if the last search is read or not',
'state': 'the surrounding state of the search',
'user_override':
'if True, current search data overrides what is in the search_view',
'limit': 'an overriding search limit. < 0 means no limit',
'run_search_bvr': 'Run Search behavior',
'custom_filter_view': 'Provide a custom filter area',
'custom_search_view': 'Provide a custom search view'
}
def get_default_filter_config(my):
custom_filter_view = my.kwargs.get('custom_filter_view')
if not custom_filter_view:
custom_filter_view = ''
config = []
config.append("<config>\n")
config.append("<filter>\n")
config.append('''
<element name='Combination'>
<display class='tactic.ui.filter.SObjectSearchFilterWdg'>
<search_type>%s</search_type>
<prefix>quick</prefix>
</display>
</element>
''' % my.search_type)
config.append('''
<element name='Custom'>
<display class='tactic.ui.filter.GeneralFilterWdg'>
<prefix>custom</prefix>
<search_type>%s</search_type>
<mode>custom</mode>
<custom_filter_view>%s</custom_filter_view>
</display>
</element>
''' % (my.search_type, custom_filter_view))
config.append('''
<element name='Filter'>
<display class='tactic.ui.filter.GeneralFilterWdg'>
<prefix>main_body</prefix>
<search_type>%s</search_type>
<mode>sobject</mode>
</display>
</element>
''' % my.search_type)
"""
config.append('''
<element name='Filter2'>
<display class='tactic.ui.filter.GeneralFilterWdg'>
<prefix>filter2</prefix>
<search_type>%s</search_type>
<mode>sobject</mode>
</display>
</element>
''' % my.search_type)
"""
config.append('''
<element name='Parent'>
<display class='tactic.ui.filter.GeneralFilterWdg'>
<prefix>parent</prefix>
<search_type>%s</search_type>
<mode>parent</mode>
</display>
</element>
''' % my.search_type)
config.append('''
<element name='Children'>
<display class='tactic.ui.filter.GeneralFilterWdg'>
<prefix>children</prefix>
<search_type>%s</search_type>
<mode>child</mode>
</display>
</element>
''' % my.search_type)
"""
config.append('''
<element name='Related'>
<display class='tactic.ui.filter.GeneralFilterWdg'>
<prefix>related</prefix>
<search_type>%s</search_type>
<mode>child</mode>
</display>
</element>
''' % my.search_type)
"""
config.append("</filter>\n")
config.append("</config>\n")
config = ''.join(config)
config_xml = Xml()
config_xml.read_string(config)
config = WidgetConfig.get(xml=config_xml, view='filter')
return config
def get_num_filters_enabled(my):
return my.num_filters_enabled
def init(my):
my.user_override = my.kwargs.get('user_override') in ['true', True]
custom_search_view = my.kwargs.get('custom_search_view')
if not custom_search_view or not custom_search_view.strip():
custom_search_view = 'search'
# create a search for this search widget
my.search_type = my.kwargs.get('search_type')
my.search = Search(my.search_type)
my.config = None
# determine whether or not to use the last search. If any kind of
# state has been set, then ignore the last_search
my.use_last_search = True
parent_key = my.kwargs.get('parent_key')
state = my.kwargs.get('state')
if parent_key or state or my.kwargs.get('use_last_search') == False:
my.use_last_search = False
my.prefix_namespace = my.kwargs.get('prefix_namespace')
# NOTE: this is still hard coded
my.prefix = 'main_body'
# if we are asking for a specific saved search
save = my.kwargs.get('save')
my.view = my.kwargs.get('view')
# get the config from a specific location
# if the view is specified, use this view with the values
# specified explicitly in this view
my.config = None
# see if a filter is explicitly passed in
filter = my.kwargs.get('filter')
my.limit = my.kwargs.get('limit')
my.run_search_bvr = my.kwargs.get('run_search_bvr')
# get from search view
# filter can be either dict(data) or a list or
# xml(filter wdg definition)
if filter:
if type(filter) == types.DictType:
my.config = my.get_default_filter_config()
filter_data = FilterData([filter])
filter_data.set_to_cgi()
elif type(filter) == types.ListType:
my.config = my.get_default_filter_config()
filter_data = FilterData(filter)
filter_data.set_to_cgi()
else:
try:
filter_data = None
# TODO: remove this. This is for backward compatibilty
my.config = WidgetConfig.get(xml=filter, view='filter')
filter_data = FilterData.get()
if not filter_data.get_data():
# use widget settings
key = SearchWdg._get_key(my.search_type, my.view)
data = WidgetSettings.get_value_by_key(key)
if data:
filter_data = FilterData(data)
filter_data.set_to_cgi()
except XmlException, e:
print "WARNING: non-xml filter detected!! %s" % filter
# NOTE: this is only used to maintain backwards compatibility
# plus it is needed for link_search: which contains the filter_config (old way of doing it)
if not my.config: # and my.view:
"""
if ':' in my.view: # avoid view of a SearchWdg like link_search:<search_type>:<view>
search_view = custom_search_view
else:
search_view = my.view
"""
search_view = custom_search_view
config_view = WidgetConfigView.get_by_search_type(my.search_type,
view=search_view)
# get the my.config first for the display of SearchWdg
# then get the filter data below if there is any
if config_view.get_config().has_view(search_view):
my.config = config_view.get_config()
try:
search = Search('config/widget_config')
search.add_filter("view", my.view)
search.add_filter("search_type", my.search_type)
config_sobj = search.get_sobject()
except SearchException, e:
print "WARNING: ", e
config_sobj = None
if config_sobj:
config_xml = config_sobj.get_xml_value("config")
if not config_view.get_config().has_view(my.view):
# make sure it does have the old way of storing filter
# elements instead of just filter data
if config_xml.get_nodes("config/filter/element"):
my.config = WidgetConfig.get(xml=config_xml,
view='filter')
#my.config = my.get_default_filter_config()
# set the form variables for the filters
data = config_xml.get_value("config/filter/values")
# link_search with specific search params takes precesdence
# TODO: make a distinction between search definition and alter
# search data provided by user
if data and not my.user_override:
filter_data = FilterData(data)
filter_data.set_to_cgi()
else:
my.set_filter_data(my.search_type, my.view)
else:
if my.use_last_search:
my.set_filter_data(my.search_type, my.view)
def get_display(my):
web = WebContainer.get_web()
if not my.view:
my.view = web.get_form_value("view")
if not my.view:
my.view = get_template_view()
widget = Widget()
widget.add( HiddenWdg("search_type", my.search_type) )
# get a list of all of the element names possible
search_type_obj = SearchType.get(my.search_type)
config = WidgetConfigView.get_by_search_type(my.search_type,DEFAULT_VIEW)
if config:
element_names = config.get_element_names()
# FIXME: also get those from the default (not sure about this)
config = WidgetConfigView.get_by_search_type(my.search_type,"default")
if config:
element_names.extend( config.get_element_names() )
if not element_names:
element_names = []
# get the custom element names from config
custom_config = WidgetConfigView.get_by_search_type(my.search_type,my.view)
custom_element_names = custom_config.get_element_names()
# get the custom properties
search = Search("prod/custom_property")
search.add_filter("search_type", my.search_type)
custom_properties = search.get_sobjects()
# action popup
action_popup = my.action_popup
action_popup.set_auto_hide(False)
action_popup.set_submit(False)
action_popup.add( HtmlElement.href("Add ...", "javascript:document.form.submit()") )
for custom_property in custom_properties:
element_name = custom_property.get_name()
if element_name not in custom_element_names:
action_popup.add( " %s" % element_name, "add|%s" % element_name )
for element_name in element_names:
if element_name not in custom_element_names:
action_popup.add( " %s" % element_name, "add|%s" % element_name )
# add some standard properties
if my.view in ["edit", "insert"]:
for element_name in PREDEFINED_EDIT_ELEMENTS:
if element_name not in custom_element_names:
action_popup.add( " %s" % element_name, "add|%s" % element_name )
else:
for element_name in PREDEFINED_ELEMENTS:
if element_name not in custom_element_names:
action_popup.add( " %s" % element_name, "add|%s" % element_name )
action_popup.add_separator()
action_popup.add( HtmlElement.href("Remove ...", "javascript:document.form.submit()") )
for element_name in custom_element_names:
action_popup.add( " %s" % element_name, "remove|%s" % element_name )
action_popup.add_separator()
span = SpanWdg("New Custom ...", css="hand")
iframe = WebContainer.get_iframe()
url = WebContainer.get_web().get_widget_url()
url.set_option("widget", "pyasm.widget.CustomAddPropertyWdg")
url.set_option("search_type", my.search_type)
url.set_option("view", my.view)
action = iframe.get_on_script(url.to_string() )
span.add_event("onclick", action)
action_popup.add( span )
WebContainer.register_cmd("pyasm.widget.CustomViewAction")
widget.add(action_popup)
return widget
def execute(self):
web = WebContainer.get_web()
# get command line options
search_type = self.kwargs.get("search_type")
assert search_type
view = self.kwargs.get("view")
if not view:
view = get_template_view()
# check if this is advanced mode
mode = web.get_form_value("custom_mode")
if not mode:
mode = 'simple'
if mode == 'xml':
config_string = web.get_form_value("config_xml")
# handle the "default" view
view = DEFAULT_VIEW
config = WidgetDbConfig.get_by_search_type(search_type, view)
if not config:
config = WidgetDbConfig.create(search_type, view)
xml = Xml()
xml.read_string(config_string)
element_name = xml.get_value("element/@name")
element_name = element_name.strip()
assert element_name
type = xml.get_value("element/@type")
if not type:
class_name = xml.get_value("element/display/@class")
if not class_name:
raise TacticException(
"Either a type or class name needs to be defined in config xml."
)
config.append_xml_element(element_name, config_string)
config.commit_config()
# create the required columns
widget = config.get_display_widget(element_name)
columns = widget.get_required_columns()
if columns:
print("WARNING: need to create columns: ", columns)
self.info['element_name'] = element_name
return
type = web.get_form_value("custom_type")
description = web.get_form_value("custom_description")
if not description:
description = "No descripton"
title = web.get_form_value("custom_title")
name = web.get_form_value("custom_name")
name = name.strip()
if not name:
raise TacticException("No name specified")
add_to_current_view = web.get_form_value("add_to_current_view")
add_to_edit_view = web.get_form_value("add_to_edit_view")
is_searchable = web.get_form_value("is_searchable")
# create the column
if type not in ['button', 'empty']:
cmd = ColumnAddCmd(search_type, name, type)
cmd.execute()
# create the type
class_name = None
options = {}
# this is actually element attrs
element_options = {}
edit_class_name = None
edit_options = {}
edit_attrs = {}
element_type = type
# Date Range is not used any more in the UI"
if type == "Date Range":
class_name = "GanttWdg"
options["start_date_column"] = "%s_start_date" % name
options["end_deate_column"] = "%s_end_date" % name
elif type == "date":
class_name = "DateWdg"
#edit_class_name = "CalendarWdg"
element_type = 'timestamp'
edit_attrs['type'] = 'timestamp'
edit_class_name = ""
add_to_edit_view = True
elif type == "foreign_key":
class_name = ""
edit_class_name = "SelectWdg"
foreign_search_type = web.get_form_value(
"foreign_key_search_select")
edit_options["query"] = '%s|code|code' % foreign_search_type
# turn on add to edit view
add_to_edit_view = True
elif type == "button":
class_name = "tactic.ui.table.ButtonElementWdg"
script = web.get_form_value("option_script_select")
if script:
options['script'] = script
icon = web.get_form_value("option_icon_select")
if icon:
options['icon'] = icon
edit_class_name = ""
# This does not have a type
element_type = None
elif type == "empty":
element_type = None
pass
elif type == "list":
class_name = ""
edit_class_name = "SelectWdg"
list_values = web.get_form_value("list_values")
edit_options['values'] = list_values
add_to_edit_view = True
element_options['type'] = element_type
element_options['title'] = title
# handle the "default" view
view = DEFAULT_VIEW
config = WidgetDbConfig.get_by_search_type(search_type, view)
if not config:
config = WidgetDbConfig.create(search_type, view)
config.append_display_element(name, class_name, options=options, \
element_attrs=element_options)
config.commit_config()
# get the config file
if add_to_current_view:
config = WidgetDbConfig.get_by_search_type(search_type, view)
if not config:
# if it doesn't exist, the check to see, if there is a hard
# coded view out there
predefined_config = WidgetConfigView.get_by_search_type(
search_type, view)
xml = predefined_config.get_xml()
# create a new db one
config = WidgetDbConfig.create(search_type, view)
if xml:
config.set_value("config", xml.to_string())
config._init()
config.append_display_element(name)
config.commit_config()
# TODO: Need to make this searchable using simple search ?????
if is_searchable:
element_options['searchable'] = 'true'
# handle the "edit"
if add_to_edit_view and view != "edit":
config = WidgetDbConfig.get_by_search_type(search_type, "edit")
if not config:
config = WidgetDbConfig.create(search_type, "edit")
config.append_display_element(name,
edit_class_name,
edit_options,
element_attrs=edit_attrs)
config.commit_config()
"""
# this sType has been deprecated
sobject = SearchType.create("prod/custom_property")
sobject.set_value("search_type", search_type)
sobject.set_value("name", name)
sobject.set_value("description", description)
sobject.commit()
"""
# set some information
self.description = "Added Property [%s] of type [%s] to [%s]" % \
(name, type, search_type)
self.info['element_name'] = name
def get_config(cls, config_search_type, view, default=False, personal=False):
config = WidgetConfigView.get_by_search_type(config_search_type, view)
return config
def preprocess(my):
my.max_value = 0
my.min_value = 0
my.steps = 0
web = WebContainer.get_web()
my.width = web.get_form_value("width")
if not my.width:
my.width = my.kwargs.get("width")
my.chart_type = web.get_form_value("chart_type")
if not my.chart_type:
my.chart_type = my.kwargs.get("chart_type")
if not my.chart_type:
my.chart_type = 'bar'
my.x_axis = web.get_form_value("x_axis")
if not my.x_axis:
my.x_axis = my.kwargs.get("x_axis")
if not my.x_axis:
my.x_axis = 'code'
# FIXME: which should override???
my.y_axis = web.get_form_values("y_axis")
if not my.y_axis:
my.y_axis = my.kwargs.get("y_axis")
if my.y_axis:
my.elements = my.y_axis
else:
my.elements = my.kwargs.get("elements")
if not my.elements:
my.elements = web.get_form_value("elements")
if isinstance(my.elements, basestring):
if my.elements:
my.elements = my.elements.split('|')
else:
my.elements = []
my.colors = my.kwargs.get("colors")
if not my.colors:
if isinstance(my.colors, basestring):
my.colors = my.colors.split("|")
my.colors = [
'#000099', '#009900', '#999900', '#009999', '#990099',
'#990000', '#009900', '#000099', '#999900', '#990000'
]
my.colors = [
'rgba(0,255,0,0.5)',
'rgba(0,0,255,0.5)',
'rgba(255,0,0,0.5)',
'rgba(255,255,0,0.5)',
'rgba(0,255,255,0.5)',
'rgba(255,0,255,0.5)',
]
while len(my.elements) >= len(my.colors):
my.colors.extend(my.colors)
chart_type = my.kwargs.get("chart_type")
if chart_type:
my.chart_types = [chart_type for x in my.elements]
else:
my.chart_types = my.kwargs.get("chart_types")
if not my.chart_types:
my.chart_types = ['bar' for x in my.elements]
expression = web.get_form_value("expression")
if not expression:
expression = my.kwargs.get("expression")
my.search_type = web.get_form_value("search_type")
if not my.search_type:
my.search_type = my.kwargs.get("search_type")
my.search_keys = my.kwargs.get("search_keys")
if expression:
my.sobjects = Search.eval(expression)
elif my.search_type and my.search_type.startswith("@SOBJECT("):
my.sobjects = Search.eval(my.search_type)
elif my.search_keys:
if isinstance(my.search_keys, basestring):
my.search_keys = eval(my.search_keys)
my.sobjects = Search.get_by_search_keys(my.search_keys)
else:
search = Search(my.search_type)
search.add_limit(100)
my.sobjects = search.get_sobjects()
if not my.sobjects:
return
# get the definition
sobjects = my.sobjects
if sobjects:
sobject = sobjects[0]
search_type = sobject.get_search_type()
view = 'definition'
from pyasm.widget import WidgetConfigView
my.config = WidgetConfigView.get_by_search_type(search_type, view)
else:
my.config = None
my.widgets = {}
def preprocess(my):
my.max_value = 0
my.min_value = 0
my.steps = 0
web = WebContainer.get_web()
my.width = web.get_form_value("width")
if not my.width:
my.width = my.kwargs.get("width")
my.chart_type = web.get_form_value("chart_type")
if not my.chart_type:
my.chart_type = my.kwargs.get("chart_type")
if not my.chart_type:
my.chart_type = 'bar'
my.x_axis = web.get_form_value("x_axis")
if not my.x_axis:
my.x_axis = my.kwargs.get("x_axis")
if not my.x_axis:
my.x_axis = 'code'
# FIXME: which should override???
my.y_axis = web.get_form_values("y_axis")
if not my.y_axis:
my.y_axis = my.kwargs.get("y_axis")
if my.y_axis:
my.elements = my.y_axis
else:
my.elements = my.kwargs.get("elements")
if not my.elements:
my.elements = web.get_form_value("elements")
if isinstance(my.elements,basestring):
if my.elements:
my.elements = my.elements.split('|')
else:
my.elements = []
my.search_type = web.get_form_value("search_type")
if not my.search_type:
my.search_type = my.kwargs.get("search_type")
my.search_keys = my.kwargs.get("search_keys")
if my.search_type and my.search_type.startswith("@SOBJECT("):
my.sobjects = Search.eval(my.search_type)
elif my.search_keys:
if isinstance(my.search_keys, basestring):
my.search_keys = eval(my.search_keys)
my.sobjects = Search.get_by_search_keys(my.search_keys)
else:
search = Search(my.search_type)
search.add_limit(100)
my.sobjects = search.get_sobjects()
# get the definition
sobjects = my.sobjects
if sobjects:
sobject = sobjects[0]
search_type = sobject.get_search_type()
view = 'definition'
from pyasm.widget import WidgetConfigView
my.config = WidgetConfigView.get_by_search_type(search_type, view)
else:
my.config = None
my.widgets = {}
def get_config(cls, search_type, view, default=None, personal=False):
# personal doesn't mean much here since this is only for Project view definition
"""
if view == "__column__":
xml == '''
<config>
<element name="tttt" type="__database__"/>
<element name="uuuu" type="__database__"/>
<element name="vvvv" type="__database__"/>
</config>
'''
"""
widget_config = None
config_view = None
widget_config_list = []
# get all the configs relevant to this search_type
configs = []
from pyasm.widget import WidgetConfigView
if view == "definition":
if default:
try:
default_config_view = WidgetConfigView.get_by_search_type(search_type, view, use_cache=False, local_search=True)
user_config_view = WidgetConfigView.get_by_search_type(search_type, view)
#merge the user config view from db into the default config view in xml file
default_config = default_config_view.get_definition_config()
user_config = user_config_view.get_definition_config()
if user_config:
user_element_names = user_config.get_element_names()
# make sure it's unique, there is a new validate function for
# WidgetDbConfig to ensure that also
user_element_names = Common.get_unique_list(user_element_names)
for elem in user_element_names:
user_node = user_config.get_element_node(elem)
default_config.append_xml_element(elem, node=user_node)
except SqlException as e:
print "Search ERROR: ", e.__str__()
default_config = None
if default_config:
default_config.get_xml().clear_xpath_cache()
widget_config_list = [default_config]
else:
config_view = WidgetConfigView.get_by_search_type(search_type, view, use_cache=True)
elif view == "database_definition":
schema_config = SearchType.get_schema_config(search_type)
widget_config_list = [schema_config]
elif view == 'template':
base_dir = Environment.get_install_dir()
file_path="%s/src/config2/search_type/search/DEFAULT-conf.xml" % base_dir
if os.path.exists(file_path):
widget_config = WidgetConfig.get(file_path=file_path, view=view)
widget_config_list = [widget_config]
'''
elif default == True :
base_dir = Environment.get_install_dir()
file_path="%s/src/config2/search_type/search/DEFAULT-conf.xml" % base_dir
if os.path.exists(file_path):
widget_config = WidgetConfig.get(file_path=file_path, view="default_definition")
widget_config_list = [widget_config]
'''
elif view == "custom_definition":
# look for a definition in the database
search = Search("config/widget_config")
search.add_filter("search_type", 'SearchTypeSchema')
search.add_filter("view", view)
config = search.get_sobject()
# this is really just a custom made definition
#view = "definition"
if config:
widget_config_list = [config]
else:
widget_config_list = []
elif view == "db_column":
# look for a definition in the database
"""
view = "definition"
from pyasm.search import SObjectDefaultConfig
default = SObjectDefaultConfig(search_type=search_type,view=view)
xml = default.get_xml()
config = WidgetConfig.get(view=view, xml=xml)
widget_config_list = [config]
"""
try:
# add the schema config definiiton
schema_config = SearchType.get_schema_config(search_type)
widget_config_list = [schema_config]
except SqlException as e:
widget_config_list = []
if not config_view:
config_view = WidgetConfigView(search_type, view, widget_config_list)
return config_view
def get_config(cls, config_search_type, view, default=False):
# method to get the config view for this widget to display
return WidgetConfigView.get_by_search_type(config_search_type, view)
def init(my):
# create all of the display elements
if not my.config:
# it shouldn't use the my.search_type_obj here as it would absorb the project info
my.config = WidgetConfigView.get_by_search_type(
my.search_type, my.config_base)
my.element_names = my.config.get_element_names()
my.element_titles = my.config.get_element_titles()
# TODO: should probably be all the attrs
my.element_widths = my.config.get_element_widths()
simple_view = my.kwargs.get("show_simple_view")
if simple_view == "true":
simple_view = True
else:
simple_view = False
# go through each element name and construct the handlers
for idx, element_name in enumerate(my.element_names):
# check to see if these are removed for this production
#if element_name in invisible_elements:
# continue
simple_element = None
display_handler = my.config.get_display_handler(element_name)
new_display_handler = my.remap_display_handler(display_handler)
if new_display_handler:
display_handler = new_display_handler
if not display_handler:
# else get it from default of this type
display_handler = my.get_default_display_handler(element_name)
# get the display options
display_options = my.config.get_display_options(element_name)
try:
if not display_handler:
element = my.config.get_display_widget(element_name)
else:
element = WidgetConfig.create_widget(
display_handler, display_options=display_options)
except Exception, e:
from tactic.ui.common import WidgetTableElementWdg
element = WidgetTableElementWdg()
# FIXME: not sure why this doesn't work
#from pyasm.widget import ExceptionWdg
#log = ExceptionWdg(e)
#element.add(log)
# FIXME: not sure why this doesn't work
from pyasm.widget import IconWdg
icon = IconWdg("Error", IconWdg.ERROR)
element.add(icon)
element.add(e)
# skip the empty elements like ThumbWdg
if simple_element and not element.is_simple_viewable():
continue
# make simple_element the element if it exists
if simple_element:
element = simple_element
# if the element failed to create, then continue
if element == None:
continue
element.set_name(element_name)
title = my.element_titles[idx]
element.set_title(title)
# FIXME: this causes a circular reference which means the
# Garbage collector can't clean it up
# make sure the element knows about its layout engine
element.set_layout_wdg(my)
# TODO: should convert this to ATTRS or someting like that. Not
# just width
element.width = my.element_widths[idx]
if my.input_prefix:
element.set_input_prefix(my.input_prefix)
# get the display options
#display_options = my.config.get_display_options(element_name)
#for key in display_options.keys():
element.set_options(display_options)
my.add_widget(element, element_name)
# layout widgets also categorize their widgets based on type
if element_name == "Filter":
section_name = 'filter'
else:
section_name = 'default'
section = my.sections.get(section_name)
if not section:
section = []
my.sections[section_name] = section
section.append(element)
def get_element_wdg(my, xml, def_config):
element_node = xml.get_node("config/tmp/element")
attrs = Xml.get_attributes(element_node)
element_name = attrs.get("name")
widget = my.get_widget(element_name)
if widget:
return widget
if not element_name:
import random
num = random.randint(0, 100000)
element_name = "element%s" % num
xml.set_attribute(element_node, "name", element_name)
# enable an ability to have a widget only loaded once in a request
if attrs.get('load_once') in ['true', True]:
widgets = Container.get("CustomLayoutWdg:widgets")
if widgets == None:
widgets = {}
Container.put("CustomLayoutWdg:widgets", widgets)
else:
if widgets[element_name] == True:
return None
widgets[element_name] = True
# provide the ability to have shorthand format
# ie: <element display_class="tactic.ui..." />
display_node = xml.get_node("config/tmp/element/display")
if display_node is None:
view = attrs.get("view")
type = attrs.get("type")
if type == "reference":
search_type = attrs.get("search_type")
my.config = WidgetConfigView.get_by_search_type(search_type, view)
# check if definition has no name. Don't use element_name
if not attrs.get("name"):
return
element_wdg = my.config.get_display_widget(element_name, extra_options=attrs)
container = DivWdg()
container.add(element_wdg)
return container
if not view:
element_wdg = my.config.get_display_widget(element_name, extra_options=attrs)
container = DivWdg()
container.add(element_wdg)
return container
# look at the attributes
class_name = attrs.get("display_class")
if not class_name:
class_name = "tactic.ui.panel.CustomLayoutWdg"
display_node = xml.create_element("display")
xml.set_attribute(display_node, "class", class_name)
xml.append_child(element_node, display_node)
for name, value in attrs.items():
# replace the spt_ in the name.
# NOTE: should this be restricted to only spt_ attributes?
name = name.replace("spt_", "")
attr_node = xml.create_element(name)
xml.set_node_value(attr_node, value)
xml.append_child(display_node, attr_node)
load = attrs.get("load")
if load in ["async", "sequence"]:
return my.get_async_element_wdg(xml, element_name, load)
use_container = attrs.get('use_container') == 'true'
if use_container:
# DEPRECATED
container = my.get_container(xml)
else:
container = DivWdg()
# add in attribute from the element definition
# DEPRECATED: does this make any sense to have this here?
for name, value in attrs.items():
if name == 'name':
continue
container.add_style(name, value)
# add the content
try:
view_node = xml.get_node("config/tmp/element/display/view")
if view_node is not None:
view = xml.get_node_value(view_node)
if view.startswith("."):
if my.view_folder:
xml.set_node_value(view_node, "%s%s" %(my.view_folder,view))
tmp_config = WidgetConfig.get('tmp', xml=xml)
configs = []
configs.append(tmp_config)
# add the def_config if it exists
if def_config:
configs.append(def_config)
config = WidgetConfigView('CustomLayoutWdg', 'tmp', configs, state=my.state)
# NOTE: this doesn't work too well when we go to an abasolute
# view.
parent_view = my.kwargs.get("parent_view")
if parent_view:
parent_view = parent_view.replace(".", "/")
parent_view = "%s/%s" % (parent_view, my.view)
else:
parent_view = my.view
# NOTE: need some protection code for infinite loops
includes = my.kwargs.get("include")
element_wdg = config.get_display_widget(element_name, extra_options={"include":includes, "parent_view":parent_view})
element_top = element_wdg.get_top()
for name, value in attrs.items():
if name == 'class':
for item in value.split(" "):
element_top.add_class(item)
elif name == 'style':
for item in value.split(";"):
element_top.add_style(item)
else:
element_top.set_attr(name, value)
# make a provision if this custom widget is in a table
if my.layout:
sobject = my.get_current_sobject()
element_wdg.set_sobject(sobject)
except Exception, e:
from pyasm.widget import ExceptionWdg
log = ExceptionWdg(e)
element_wdg = log
def init(my):
# create all of the display elements
if not my.config:
# it shouldn't use the my.search_type_obj here as it would absorb the project info
my.config = WidgetConfigView.get_by_search_type(my.search_type, my.config_base)
my.element_names = my.config.get_element_names()
my.element_titles = my.config.get_element_titles()
# TODO: should probably be all the attrs
my.element_widths = my.config.get_element_widths()
simple_view = my.kwargs.get("show_simple_view")
if simple_view == "true":
simple_view = True
else:
simple_view = False
# go through each element name and construct the handlers
for idx, element_name in enumerate(my.element_names):
# check to see if these are removed for this production
#if element_name in invisible_elements:
# continue
simple_element = None
display_handler = my.config.get_display_handler(element_name)
new_display_handler = my.remap_display_handler(display_handler)
if new_display_handler:
display_handler = new_display_handler
if not display_handler:
# else get it from default of this type
display_handler = my.get_default_display_handler(element_name)
# get the display options
display_options = my.config.get_display_options(element_name)
try:
if not display_handler:
element = my.config.get_display_widget(element_name)
else:
element = WidgetConfig.create_widget( display_handler, display_options=display_options )
except Exception, e:
from tactic.ui.common import WidgetTableElementWdg
element = WidgetTableElementWdg()
# FIXME: not sure why this doesn't work
#from pyasm.widget import ExceptionWdg
#log = ExceptionWdg(e)
#element.add(log)
# FIXME: not sure why this doesn't work
from pyasm.widget import IconWdg
icon = IconWdg("Error", IconWdg.ERROR)
element.add(icon)
element.add(e)
# skip the empty elements like ThumbWdg
if simple_element and not element.is_simple_viewable():
continue
# make simple_element the element if it exists
if simple_element:
element = simple_element
# if the element failed to create, then continue
if element == None:
continue
element.set_name(element_name)
title = my.element_titles[idx]
element.set_title(title)
# FIXME: this causes a circular reference which means the
# Garbage collector can't clean it up
# make sure the element knows about its layout engine
element.set_layout_wdg(my)
# TODO: should convert this to ATTRS or someting like that. Not
# just width
if idx >= len(my.element_widths):
element.width = 150
else:
element.width = my.element_widths[idx]
if my.input_prefix:
element.set_input_prefix(my.input_prefix)
# get the display options
#display_options = my.config.get_display_options(element_name)
#for key in display_options.keys():
element.set_options(display_options)
my.add_widget(element,element_name)
# layout widgets also categorize their widgets based on type
if element_name == "Filter":
section_name = 'filter'
else:
section_name = 'default'
section = my.sections.get(section_name)
if not section:
section = []
my.sections[section_name] = section
section.append(element)
def execute(my):
assert my.search_type
assert my.view
assert my.file_path
search = Search(my.search_type)
if my.search_ids:
search.add_enum_order_by("id", my.search_ids)
search.add_filters("id", my.search_ids)
sobjects = search.get_sobjects()
elif my.search_keys:
sobjects = Search.get_by_search_keys(my.search_keys,
keep_order=True)
"""
search_codes = [SearchKey.extract_code(i) for i in my.search_keys if SearchKey.extract_code(i) ]
if search_codes:
search.add_filters("code", search_codes)
else:
search_ids = [SearchKey.extract_id(i) for i in my.search_keys if SearchKey.extract_id(i) ]
search.add_filters("id", search_ids)
"""
else:
sobjects = search.get_sobjects()
from pyasm.widget import WidgetConfigView
from pyasm.web import Widget
config = WidgetConfigView.get_by_search_type(my.search_type, my.view)
columns = []
if my.column_names:
columns = my.column_names
# should allow exporting ids only
"""
else:
if not config:
columns = search.get_columns()
else:
columns = config.get_element_names()
"""
if my.include_id:
columns.insert(0, "id")
# create the csv file
org_file = file(my.file_path, 'w')
csvwriter = csv.writer(org_file, quoting=csv.QUOTE_NONNUMERIC)
# write the titles
csvwriter.writerow(columns)
elements = my.get_elements(config, columns)
display_option_dict = {}
# this is for widgets that do preprocessing on all sobjects
for idx, element in enumerate(elements):
element.set_sobjects(sobjects)
element.preprocess()
display_options = config.get_display_options(columns[idx])
display_option_dict[element] = display_options
for idx, sobject in enumerate(sobjects):
values = []
for element in elements:
element.set_current_index(idx)
value = element.get_text_value()
if isinstance(value, Widget):
value = value.get_buffer_display()
elif isinstance(value, basestring):
if isinstance(value, unicode):
value = value.encode('UTF-8', 'ignore')
else:
value = str(value)
options = display_option_dict.get(element)
if options.get('csv_force_string') == 'true' and value:
value = '#FORCESTRING#%s' % value
values.append(value)
# write the values as list
csvwriter.writerow(values)
org_file.close()
file2 = open(my.file_path, 'r')
mod_file_path = '%s_mod' % my.file_path
mod_file = open(mod_file_path, 'w')
for line in file2:
mod_line = re.sub(r'(\'|\"|)(#FORCESTRING#)', '=\\1', line)
mod_file.write(mod_line)
# new file
file2.close()
mod_file.close()
#os.unlink(my.file_path)
shutil.move(mod_file_path, my.file_path)
def get_display(my):
top = my.top
top.add_color("background", "background")
top.add_color("color", "color")
top.add_style("padding: 10px")
top.add_style("min-width: 400px")
from tactic.ui.app import HelpButtonWdg
help_wdg = HelpButtonWdg(alias="exporting-csv-data")
top.add(help_wdg)
help_wdg.add_style("float: right")
help_wdg.add_style("margin-top: -3px")
if not my.check():
top.add(DivWdg('Error: %s' %my.error_msg))
top.add(HtmlElement.br(2))
return super(CsvExportWdg, my).get_display()
if my.search_type_list and my.search_type_list[0] != my.search_type:
st = SearchType.get(my.search_type_list[0])
title_div =DivWdg('Exporting related items [%s]' % st.get_title())
top.add(title_div)
top.add(HtmlElement.br())
my.search_type = my.search_type_list[0]
my.view = my.related_view
if my.mode != 'export_all':
num = len(my.selected_search_keys)
else:
search = Search(my.search_type)
num = search.get_count()
msg_div = DivWdg('Total: %s items to export'% num)
msg_div.add_style("font-size: 12px")
msg_div.add_style("font-weight: bold")
msg_div.add_style('margin-left: 4px')
top.add(msg_div)
if num > 300:
msg_div.add_behavior({'type':'load',
'cbjs_action': "spt.alert('%s items are about to be exported. It may take a while.')" %num})
top.add(HtmlElement.br())
div = DivWdg(css='spt_csv_export', id='csv_export_action')
div.add_color("background", "background", -10)
div.add_style("padding: 10px")
div.add_style("margin: 5px")
div.add_styles('max-height: 350px; overflow: auto')
table = Table( css='minimal')
table.add_color("color", "color")
div.add(table)
table.set_id('csv_export_table')
table.center()
cb_name = 'csv_column_name'
master_cb = CheckboxWdg('master_control')
master_cb.set_checked()
master_cb.add_behavior({'type': 'click_up',
'propagate_evt': True,
'cbjs_action': '''
var inputs = spt.api.Utility.get_inputs(bvr.src_el.getParent('.spt_csv_export'),'%s');
for (var i = 0; i < inputs.length; i++)
inputs[i].checked = !inputs[i].checked;
''' %cb_name})
span = SpanWdg('Select Columns To Export')
span.add_style('font-weight','600')
table.add_row_cell(span)
table.add_row_cell(HtmlElement.br())
tr = table.add_row()
tr.add_style('border-bottom: 1px groove #777')
td = table.add_cell(master_cb)
label = HtmlElement.i('toggle all')
label.add_style('color: #888')
table.add_cell(label)
col1 = table.add_col()
col1.add_style('width: 35px')
col2 = table.add_col()
if not my.search_type or not my.view:
return table
# use overriding element names and derived titles if available
config = WidgetConfigView.get_by_search_type(my.search_type, my.view)
if my.element_names and config:
filtered_columns = my.element_names
titles = []
for name in my.element_names:
title = config.get_element_title(name)
titles.append(title)
else:
# excluding FunctionalTableElement
filtered_columns = []
titles = []
if not config:
columns = search.get_columns()
filtered_columns = columns
titles = ['n/a'] * len(filtered_columns)
else:
columns = config.get_element_names()
filtered_columns = columns
titles = config.get_element_titles()
"""
# commented out until it is decided 2.5 widgets will
# use this class to differentiate between reg and functional element
from pyasm.widget import FunctionalTableElement
for column in columns:
widget = config.get_display_widget(column)
if isinstance(widget, FunctionalTableElement):
continue
filtered_columns.append(column)
"""
for idx, column in enumerate(filtered_columns):
table.add_row()
cb = CheckboxWdg(cb_name)
cb.set_option('value', column)
cb.set_checked()
table.add_cell(cb)
title = titles[idx]
table.add_cell('<b>%s</b> (%s) '%(title, column))
action_div = DivWdg()
widget = DivWdg()
table.add_row_cell(widget)
widget.add_style("margin: 20px 0 10px 0px")
cb = CheckboxWdg('include_id', label=" Include ID")
cb.set_default_checked()
widget.add(cb)
hint = HintWdg('To update entries with specific ID later, please check this option. For new inserts in this or other table later on, uncheck this option.')
widget.add(hint)
label = string.capwords(my.mode.replace('_', ' '))
button = ActionButtonWdg(title=label)
is_export_all = my.mode == 'export_all'
button.add_behavior({
'type': "click_up",
'cbfn_action': 'spt.dg_table_action.csv_export',
'element': 'csv_export',
'column_names': 'csv_column_name',
'search_type': my.search_type,
'view': my.view,
'search_keys' : my.selected_search_keys,
'is_export_all' : is_export_all
})
my.close_action = "var popup = bvr.src_el.getParent('.spt_popup');spt.popup.close(popup)"
if my.close_action:
close_button = ActionButtonWdg(title='Close')
close_button.add_behavior({
'type': "click",
'cbjs_action': my.close_action
})
table = Table()
action_div.add(table)
table.center()
table.add_row()
td = table.add_cell(button)
td.add_style("width: 130px")
table.add_cell(close_button)
action_div.add("<br clear='all'/>")
top.add(div)
top.add(HtmlElement.br())
top.add(action_div)
return top
def get_item_wdg(self, sobject):
self.element_names = self.kwargs.get("element_names")
if not self.element_names:
self.element_names = ["preview","code","name","description",]
else:
self.element_names = self.element_names.split(",")
if self.element_names[0] == "preview":
has_preview = True
self.element_names = self.element_names[1:]
else:
has_preview = False
view = self.kwargs.get("view")
if not view:
view = "table"
from pyasm.widget import WidgetConfigView
search_type = sobject.get_search_type()
self.config = WidgetConfigView.get_by_search_type(search_type, view)
div = DivWdg()
div.add_class("spt_item_top")
div.add_style("padding: 10px")
SmartMenu.assign_as_local_activator( div, 'DG_DROW_SMENU_CTX' )
#div.add_class("spt_table_row")
#div.add_class("spt_table_row_%s" % self.table_id)
div.add_attr("spt_search_key", sobject.get_search_key(use_id=True))
div.add_attr("spt_search_code", sobject.get_code())
name = sobject.get_value("name", no_exception=True)
if not name:
name = sobject.get_code()
div.add_attr("spt_name", name)
table = Table()
div.add(table)
table.set_max_width()
tr = table.add_row()
width = self.kwargs.get("preview_width")
if not width:
width = "240px"
if has_preview:
td = table.add_cell()
td.add_style("width: %s" % width);
td.add_style("vertical-align: top")
options = self.config.get_display_options("preview")
redirect_expr = options.get("redirect_expr")
if redirect_expr:
parent = Search.eval(redirect_expr, sobject, single=True)
#parent = sobject.get_parent()
tile_wdg = self.tile_layout.get_tile_wdg(parent)
else:
tile_wdg = self.tile_layout.get_tile_wdg(sobject)
td.add(tile_wdg)
info_div = self.get_info_wdg(sobject)
td = table.add_cell(info_div)
td.add_style("vertical-align: top")
return div
def init(self):
self.user_override = self.kwargs.get('user_override') in ['true', True]
custom_search_view = self.kwargs.get('custom_search_view')
if not custom_search_view or not custom_search_view.strip():
custom_search_view = 'search'
# create a search for this search widget
self.search_type = self.kwargs.get('search_type')
self.search = self.kwargs.get("search")
if not self.search:
self.search = Search(self.search_type)
self.config = None
# determine whether or not to use the last search. If any kind of
# state has been set, then ignore the last_search
self.use_last_search = True
parent_key = self.kwargs.get('parent_key')
state = self.kwargs.get('state')
if parent_key or state or self.kwargs.get('use_last_search') in [False, 'false']:
self.use_last_search = False
self.prefix_namespace = self.kwargs.get('prefix_namespace')
# NOTE: this is still hard coded
self.prefix = 'main_body'
# if we are asking for a specific saved search
save = self.kwargs.get('save')
self.view = self.kwargs.get('view')
# get the config from a specific location
# if the view is specified, use this view with the values
# specified explicitly in this view
self.config = None
# see if a filter is explicitly passed in
filter = self.kwargs.get('filter')
self.limit = self.kwargs.get('limit')
self.run_search_bvr = self.kwargs.get('run_search_bvr')
# get from search view
# filter can be either dict(data) or a list or
# xml(filter wdg definition)
if filter:
if type(filter) == types.DictType:
self.config = self.get_default_filter_config()
filter_data = FilterData([filter])
filter_data.set_to_cgi()
elif type(filter) == types.ListType:
self.config = self.get_default_filter_config()
filter_data = FilterData(filter)
filter_data.set_to_cgi()
else:
try:
filter_data = None
# TODO: remove this. This is for backward compatibilty
self.config = WidgetConfig.get(xml=filter, view='filter')
filter_data = FilterData.get()
if not filter_data.get_data():
# use widget settings
key = SearchWdg._get_key(self.search_type, self.view)
data = WidgetSettings.get_value_by_key(key)
if data:
filter_data = FilterData(data)
filter_data.set_to_cgi()
except XmlException as e:
print("WARNING: non-xml filter detected!!")
# NOTE: this is only used to maintain backwards compatibility
# plus it is needed for link_search: which contains the filter_config (old way of doing it)
if not self.config:# and self.view:
"""
if ':' in self.view: # avoid view of a SearchWdg like link_search:<search_type>:<view>
search_view = custom_search_view
else:
search_view = self.view
"""
search_view = custom_search_view
config_view = WidgetConfigView.get_by_search_type(self.search_type, view=search_view)
# get the self.config first for the display of SearchWdg
# then get the filter data below if there is any
if config_view.get_config().has_view(search_view):
self.config = config_view.get_config()
try:
search = Search('config/widget_config')
search.add_filter("view", self.view)
search.add_filter("search_type", self.search_type)
config_sobjs = search.get_sobjects()
from pyasm.search import WidgetDbConfig
config_sobj = WidgetDbConfig.merge_configs(config_sobjs)
#config_sobj = config_sobjs[0]
except SearchException as e:
print("WARNING: ", e)
config_sobj = None
if config_sobj:
config_xml = config_sobj.get_xml_value("config")
if not config_view.get_config().has_view(self.view):
# make sure it does have the old way of storing filter
# elements instead of just filter data
if config_xml.get_nodes("config/filter/element"):
self.config = WidgetConfig.get(xml=config_xml, view='filter')
#self.config = self.get_default_filter_config()
# set the form variables for the filters
data = config_xml.get_value("config/filter/values")
# link_search with specific search params takes precesdence
# TODO: make a distinction between search definition and alter
# search data provided by user
if data and not self.user_override:
filter_data = FilterData(data)
filter_data.set_to_cgi()
else:
self.set_filter_data(self.search_type, self.view)
else:
if self.use_last_search:
self.set_filter_data(self.search_type, self.view)
if not self.config:
# get the approprate filter definition
self.config = self.get_default_filter_config()
if self.use_last_search:
self.set_filter_data(self.search_type, self.view)
if not self.config:
return
self.num_filters_enabled = 0
# create the filters
self.filters = []
security = Environment.get_security()
element_names = self.config.get_element_names()
#element_names = ["Keywords", "Related"]
for element_name in element_names:
filter = self.config.get_display_widget(element_name)
if filter and filter.is_visible():
self.filters.append(filter)
# make sure there is at least one filter defined
#assert self.filters
# just for drawing purpose
if self.kwargs.get('skip_search') == True:
return
try:
self.alter_search()
self.set_persistent_value()
except SearchInputException as e:
self.clear_search_data(self.search_type)
raise SearchInputException("%s If this problem persists, this view may contain invalid data in < values >. Clean up the data in Widget Config for the view [%s]."%( e.__str__(), self.view))
except:
self.clear_search_data(self.search_type)
raise
