def merge_workspaces(self, from_ws, to_ws, user):
meta = from_ws._meta
table_name = meta.object_name
# Registering mapping between tuple and cloning tuple!
self.mapping.add_mapping(table_name, from_ws.id, to_ws.id)
self.final_tables = list(self.final_tables)
self.extra_models['Variable'] += (
('workspace', 'variablevalue', 'variable', {'user': from_ws.creator}),
)
self.fields_to_overwrite['VariableValue'] = {
'user': user,
}
# Continue iterating over data-model structure
extra_models = self.extra_models.get(table_name, [])
for model in extra_models:
related_tuples = get_related_tuples(model[0], # app_label
model[1], # module_name
model[2], # field.name
from_ws.id)
for related_tuple in related_tuples:
self.clone_tuple(related_tuple)
from commons.get_data import _invalidate_cached_variable_values
_invalidate_cached_variable_values(to_ws)
return to_ws
def set_variable_value(var_id, user, value):
variables_to_notify = []
variable_value = VariableValue.objects.select_related('variable__vardef').get(user=user, variable__id=var_id)
new_value = unicode(value)
if variable_value.variable.vardef.secure:
new_value = encrypt_value(new_value)
variable_value.value = new_value
variable_value.save()
from commons.get_data import _invalidate_cached_variable_values
_invalidate_cached_variable_values(variable_value.variable.igadget.tab.workspace, user)
return variables_to_notify
def SaveIGadget(igadget, user, tab, initial_variable_values):
gadget_uri = igadget.get('gadget')
igadget_name = igadget.get('name')
width = igadget.get('width')
height = igadget.get('height')
top = igadget.get('top')
left = igadget.get('left')
icon_top = igadget.get('icon_top')
icon_left = igadget.get('icon_left')
zIndex = igadget.get('zIndex')
layout = igadget.get('layout')
menu_color = igadget.get('menu_color')
# Creates IGadget position
position = Position(posX=left, posY=top, posZ=zIndex, height=height, width=width, minimized=False, fulldragboard=False)
position.save()
# Creates IGadget icon position
icon_position = Position(posX=icon_left, posY=icon_top)
icon_position.save()
# Gadget uri does not contain the prefix "/user" yet
if gadget_uri.startswith("/user") or gadget_uri.startswith("user"):
gadget_uri_parts = gadget_uri.split("/")
gadget_uri = "/" + "/".join(gadget_uri_parts[gadget_uri_parts.index("gadgets"):])
gadget = Gadget.objects.get(uri=gadget_uri, users=user)
new_igadget = IGadget(name=igadget_name, gadget=gadget, tab=tab, layout=layout, position=position, icon_position=icon_position, transparency=False, menu_color=menu_color)
new_igadget.save()
variableDefs = VariableDef.objects.filter(gadget=gadget)
for varDef in variableDefs:
if initial_variable_values and varDef.name in initial_variable_values:
initial_value = initial_variable_values[varDef.name]
else:
initial_value = None
addIGadgetVariable(new_igadget, varDef, initial_value)
from commons.get_data import _invalidate_cached_variable_values
_invalidate_cached_variable_values(new_igadget.tab.workspace)
return new_igadget
def fillWorkspaceUsingTemplate(workspace, template, xml=None):
if xml is None:
if isinstance(template, unicode):
# Work around: ValueError: Unicode strings with encoding
# declaration are not supported.
template = template.encode('utf-8')
xml = etree.fromstring(template)
user = workspace.creator
concept_values = get_concept_values(user)
processor = TemplateValueProcessor({'user': user, 'context': concept_values})
workspace_structure = INCLUDED_RESOURCES_XPATH(xml)[0]
read_only_workspace = workspace_structure.get('readonly') == 'true'
preferences = PREFERENCE_XPATH(workspace_structure)
new_values = {}
igadget_id_mapping = {}
for preference in preferences:
new_values[preference.get('name')] = {
'inherit': False,
'value': preference.get('value'),
}
if len(new_values) > 0:
update_workspace_preferences(workspace, new_values)
forced_values = {
'extra_prefs': {},
'igadget': {},
}
params = PARAM_XPATH(workspace_structure)
for param in params:
forced_values['extra_prefs'][param.get('name')] = {
'inheritable': False,
'label': param.get('label'),
'type': param.get('type')
}
tabs = TAB_XPATH(workspace_structure)
tab_id_mapping = {}
for tabElement in tabs:
tab = createTab(tabElement.get('name'), user, workspace, allow_renaming=True)
tab_id_mapping[tabElement.get('id')] = tab
preferences = PREFERENCE_XPATH(tabElement)
new_values = {}
for preference in preferences:
new_values[preference.get('name')] = {
'inherit': False,
'value': preference.get('value'),
}
if len(new_values) > 0:
update_tab_preferences(tab, new_values)
resources = RESOURCE_XPATH(tabElement)
for resource in resources:
igadget_uri = "/workspace/" + str(workspace.id) + "/tab/" + str(tab.id) + "/igadgets"
position = POSITION_XPATH(resource)[0]
rendering = RENDERING_XPATH(resource)[0]
initial_variable_values = {}
igadget_forced_values = {}
properties = PROPERTIES_XPATH(resource)
for prop in properties:
read_only = prop.get('readonly')
if read_only and read_only == 'true':
igadget_forced_values[prop.get('name')] = {'value': prop.get('value')}
else:
initial_variable_values[prop.get('name')] = processor.process(prop.get('value'))
preferences = PREFERENCE_XPATH(resource)
for pref in preferences:
read_only = pref.get('readonly')
if read_only and read_only == 'true':
hidden = pref.get('hidden') == 'true'
igadget_forced_values[pref.get('name')] = {'value': pref.get('value'), 'hidden': hidden}
else:
initial_variable_values[pref.get('name')] = processor.process(pref.get('value'))
gadget = get_or_add_gadget_from_catalogue(resource.get('vendor'), resource.get('name'), resource.get('version'), user, None)
igadget_data = {
"left": int(position.get('x')),
"top": int(position.get('y')),
"icon_left": -1,
"icon_top": -1,
"zIndex": int(position.get('z')),
"width": int(rendering.get('width')),
"height": int(rendering.get('height')),
"name": resource.get('title'),
"menu_color": "FFFFFF",
"layout": int(rendering.get('layout')),
"uri": igadget_uri,
"gadget": gadget.uri}
igadget = SaveIGadget(igadget_data, user, tab, initial_variable_values)
if read_only_workspace or resource.get('readonly') == 'true':
igadget.readOnly = True
igadget.save()
forced_values['igadget'][str(igadget.id)] = igadget_forced_values
igadget_id_mapping[resource.get('id')] = igadget
if workspace.forcedValues != None and workspace.forcedValues != '':
old_forced_values = simplejson.loads(workspace.forcedValues)
else:
old_forced_values = {
'extra_preferences': {},
'igadget': {},
}
forced_values['igadget'].update(old_forced_values['igadget'])
workspace.forcedValues = simplejson.dumps(forced_values, ensure_ascii=False)
workspace.save()
# wiring
wiring = WIRING_XPATH(xml)[0]
channels = CHANNEL_XPATH(wiring)
channel_connectables = {}
for channel in channels:
connectable = createChannel(workspace, channel.get('name'))
save = False
if read_only_workspace or channel.get('readonly') == 'true':
connectable.readOnly = True
save = True
filter_name = channel.get('filter')
if filter_name:
save = True
connectable.filter = Filter.objects.get(name=filter_name)
connectable.filter_param_values = channel.get('filter_params')
if save:
connectable.save()
channel_connectables[channel.get('id')] = {
'connectable': connectable,
'element': channel,
}
for key in channel_connectables:
channel = channel_connectables[key]
ins = IN_XPATH(channel['element'])
for in_ in ins:
igadget_id = in_.get('igadget')
igadget = igadget_id_mapping[igadget_id]
name = in_.get('name')
connectable = In.objects.get(variable__vardef__name=name, variable__igadget=igadget)
connectable.inouts.add(channel['connectable'])
connectable.save()
outs = OUT_XPATH(channel['element'])
for out in outs:
if 'igadget' in out.attrib:
igadget_id = out.get('igadget')
igadget = igadget_id_mapping[igadget_id]
name = out.get('name')
variable = Variable.objects.get(igadget=igadget, vardef__name=name)
connectable = Out.objects.get(variable=variable)
else:
pass
connectable.inouts.add(channel['connectable'])
connectable.save()
out_channels = CHANNEL_XPATH(channel['element'])
for out_channel_element in out_channels:
out_channel = channel_connectables[out_channel_element.get('id')]['connectable']
relation = RelatedInOut(in_inout=channel['connectable'], out_inout=out_channel)
relation.save()
from commons.get_data import _invalidate_cached_variable_values
_invalidate_cached_variable_values(workspace)
