def _populate_variables_values_cache(workspace, user, key, forced_values=None):
""" populates VariableValue cached values for that user """
values_by_varid = {}
values_by_varname = {}
if forced_values is None:
context_values = get_context_values(workspace, user)
preferences = get_workspace_preference_values(workspace)
forced_values = process_forced_values(workspace, user, context_values, preferences)
for iwidget in IWidget.objects.filter(tab__workspace=workspace):
# forced_values uses string keys
svariwidget = str(iwidget.id)
values_by_varname[iwidget.id] = {}
if iwidget.widget is None:
continue
iwidget_info = iwidget.widget.resource.get_processed_info()
for vardef in iwidget_info['preferences']:
_process_variable(iwidget, svariwidget, vardef, forced_values, values_by_varname, values_by_varid)
for vardef in iwidget_info['properties']:
_process_variable(iwidget, svariwidget, vardef, forced_values, values_by_varname, values_by_varid)
values = {
'by_varid': values_by_varid,
'by_varname': values_by_varname,
}
cache.set(key, values)
return values
def _populate_variables_values_cache(workspace, user, key, forced_values=None):
""" populates VariableValue cached values for that user """
values_by_varid = {}
values_by_varname = {}
if forced_values is None:
context_values = get_context_values(workspace, user)
preferences = get_workspace_preference_values(workspace)
forced_values = process_forced_values(workspace, user, context_values,
preferences)
for iwidget in IWidget.objects.filter(tab__workspace=workspace):
# forced_values uses string keys
svariwidget = str(iwidget.id)
values_by_varname[iwidget.id] = {}
iwidget_info = iwidget.widget.resource.get_processed_info()
for vardef in iwidget_info['preferences']:
_process_variable(iwidget, svariwidget, vardef, forced_values,
values_by_varname, values_by_varid)
for vardef in iwidget_info['properties']:
_process_variable(iwidget, svariwidget, vardef, forced_values,
values_by_varname, values_by_varid)
values = {
'by_varid': values_by_varid,
'by_varname': values_by_varname,
}
cache.set(key, values)
return values
def _get_global_workspace_data(workspaceDAO, user):
user_workspace = UserWorkspace.objects.get(user=user, workspace=workspaceDAO)
data_ret = get_workspace_data(workspaceDAO, user)
# Context information
data_ret['context'] = get_workspace_context(user_workspace)
# Workspace preferences
preferences = get_workspace_preference_values(workspaceDAO.pk)
data_ret['preferences'] = preferences
# Process forced variable values
concept_values = get_context_values(user_workspace)
forced_values = process_forced_values(workspaceDAO, user, concept_values, preferences)
data_ret['empty_params'] = forced_values['empty_params']
data_ret['extra_prefs'] = forced_values['extra_prefs']
if len(forced_values['empty_params']) > 0:
return json.dumps(data_ret, cls=LazyEncoder)
cache_manager = VariableValueCacheManager(workspaceDAO, user, forced_values)
# Tabs processing
# Check if the workspace's tabs have order
tabs = Tab.objects.filter(workspace=workspaceDAO).order_by('position')
if tabs.count() > 0:
if tabs[0].position != None:
tabs = tabs.order_by('position')
else:
#set default order
for i in range(len(tabs)):
tabs[i].position = i
tabs[i].save()
else:
tabs = [createTab(_('Tab'), workspaceDAO)]
tabs_data = [get_tab_data(tab) for tab in tabs]
data_ret['tabs'] = tabs_data
for tab in tabs_data:
tab_pk = tab['id']
iwidgets = IWidget.objects.filter(tab__id=tab_pk).order_by('id')
iwidget_data = []
for iwidget in iwidgets:
iwidget_data.append(get_iwidget_data(iwidget, user, workspaceDAO, cache_manager))
tab['iwidgets'] = iwidget_data
data_ret['wiring'] = json.loads(workspaceDAO.wiringStatus)
for forced_operator_id, forced_preferences in forced_values['ioperator'].iteritems():
for forced_pref_name, forced_preference in forced_preferences.iteritems():
data_ret['wiring']['operators'][forced_operator_id]['preferences'][forced_pref_name]['value'] = forced_preference['value']
# Params
last_published_workspace = PublishedWorkspace.objects.filter(workspace=workspaceDAO).order_by('-pk')
if len(last_published_workspace) > 0:
data_ret["params"] = json.loads(last_published_workspace[0].params)
return json.dumps(data_ret, cls=LazyEncoder)
def _populate_variables_values_cache(workspace, user, key, forced_values=None):
""" populates VariableValue cached values for that user """
values_by_varid = {}
values_by_varname = {}
if forced_values == None:
user_workspace = UserWorkspace.objects.get(user=user, workspace=workspace)
context_values = get_context_values(user_workspace)
preferences = get_workspace_preference_values(workspace)
forced_values = process_forced_values(workspace, user, context_values, preferences)
var_values = VariableValue.objects.filter(user__id=user.id, variable__iwidget__tab__workspace=workspace)
for var_value in var_values.select_related('variable__vardef'):
variwidget = var_value.variable.iwidget.id
varname = var_value.variable.vardef.name
# forced_values uses string keys
svariwidget = str(variwidget)
if not variwidget in values_by_varname:
values_by_varname[variwidget] = {}
entry = {}
if svariwidget in forced_values['iwidget'] and varname in forced_values['iwidget'][svariwidget]:
fv_entry = forced_values['iwidget'][svariwidget][varname]
entry['value'] = fv_entry['value']
if var_value.variable.vardef.secure:
entry['value'] = encrypt_value(entry['value'])
entry['readonly'] = True
entry['hidden'] = fv_entry.get('hidden', False)
else:
if not var_value.variable.vardef.secure:
entry['value'] = var_value.get_variable_value()
else:
entry['value'] = var_value.value
entry['readonly'] = False
entry['hidden'] = False
entry['secure'] = var_value.variable.vardef.secure
values_by_varname[variwidget][varname] = entry
values_by_varid[var_value.variable.id] = entry
values = {
'by_varid': values_by_varid,
'by_varname': values_by_varname,
}
cache.set(key, values)
return values
def _populate_variables_values_cache(workspace, user, key, forced_values=None):
""" populates VariableValue cached values for that user """
values_by_varname = {
"ioperator": {},
"iwidget": {},
}
if forced_values is None:
context_values = get_context_values(workspace, user)
preferences = get_workspace_preference_values(workspace)
forced_values = process_forced_values(workspace, user, context_values, preferences)
for iwidget in IWidget.objects.filter(tab__workspace=workspace):
# forced_values uses string keys
svariwidget = "%s" % iwidget.id
values_by_varname["iwidget"][svariwidget] = {}
if iwidget.widget is None:
continue
iwidget_info = iwidget.widget.resource.get_processed_info()
for vardef in iwidget_info.get('preferences', {}):
value = iwidget.variables.get(vardef['name'], None)
_process_variable("iwidget", svariwidget, vardef, value, forced_values, values_by_varname, user, workspace.creator)
for vardef in iwidget_info.get('properties', {}):
value = iwidget.variables.get(vardef['name'], None)
_process_variable("iwidget", svariwidget, vardef, value, forced_values, values_by_varname, user, workspace.creator)
for operator_id, operator in six.iteritems(workspace.wiringStatus.get('operators', {})):
values_by_varname["ioperator"][operator_id] = {}
vendor, name, version = operator['name'].split('/')
try:
operator_info = CatalogueResource.objects.get(vendor=vendor, short_name=name, version=version).get_processed_info()
except CatalogueResource.DoesNotExist:
continue
for vardef in operator_info.get('preferences', {}):
value = operator.get("preferences", {}).get(vardef['name'], {}).get("value")
_process_variable("ioperator", operator_id, vardef, value, forced_values, values_by_varname, user, workspace.creator)
for vardef in operator_info.get('properties', {}):
value = operator.get("properties", {}).get(vardef['name'], {}).get("value")
_process_variable("ioperator", operator_id, vardef, value, forced_values, values_by_varname, user, workspace.creator)
cache.set(key, values_by_varname)
return values_by_varname
def _get_global_workspace_data(workspaceDAO, user):
data_ret = get_workspace_data(workspaceDAO, user)
# Workspace preferences
preferences = get_workspace_preference_values(workspaceDAO)
data_ret['preferences'] = preferences
data_ret['users'] = []
for u in workspaceDAO.users.all():
try:
is_organization = u.organization is not None
except:
is_organization = False
data_ret['users'].append({
"fullname":
u.get_full_name(),
"username":
u.username,
"organization":
is_organization,
"accesslevel":
"owner" if workspaceDAO.creator == u else "read",
})
# Process forced variable values
concept_values = get_context_values(workspaceDAO, user)
forced_values = process_forced_values(workspaceDAO, user, concept_values,
preferences)
data_ret['empty_params'] = forced_values['empty_params']
data_ret['extra_prefs'] = forced_values['extra_prefs']
if len(forced_values['empty_params']) > 0:
return json.dumps(data_ret, cls=LazyEncoder)
cache_manager = VariableValueCacheManager(workspaceDAO, user,
forced_values)
# Tabs processing
# Check if the workspace's tabs have order
tabs = Tab.objects.filter(workspace=workspaceDAO).order_by('position')
if tabs.count() > 0:
if tabs[0].position is not None:
tabs = tabs.order_by('position')
else:
# set default order
for i in range(len(tabs)):
tabs[i].position = i
tabs[i].save()
else:
tabs = [createTab(_('Tab'), workspaceDAO)]
data_ret['tabs'] = [
get_tab_data(tab,
workspace=workspaceDAO,
cache_manager=cache_manager,
user=user) for tab in tabs
]
data_ret['wiring'] = deepcopy(workspaceDAO.wiringStatus)
for operator_id, operator in six.iteritems(data_ret['wiring'].get(
'operators', {})):
try:
(vendor, name, version) = operator['name'].split('/')
except:
continue
try:
resource = CatalogueResource.objects.get(vendor=vendor,
short_name=name,
version=version)
operator_info = resource.get_processed_info(process_variables=True)
# Check if the resource is available, if not, variables should not be retrieved
if not resource.is_available_for(workspaceDAO.creator):
raise CatalogueResource.DoesNotExist
except CatalogueResource.DoesNotExist:
operator["preferences"] = {}
operator["properties"] = {}
continue
operator_forced_values = forced_values['ioperator'].get(
operator_id, {})
# Build operator preference data
for preference_name, preference in six.iteritems(
operator.get('preferences', {})):
vardef = operator_info['variables']['preferences'].get(
preference_name)
value = preference.get('value', None)
# Handle multiuser
variable_user = user if vardef is not None and vardef[
"multiuser"] else workspaceDAO.creator
if preference_name in operator_forced_values:
preference['value'] = operator_forced_values[preference_name][
'value']
elif value is None or value["users"].get("%s" % variable_user.id,
None) is None:
# If not defined / not defined for the current user, take the default value
preference['value'] = parse_value_from_text(
vardef, vardef['default'])
else:
preference['value'] = value["users"].get("%s" %
variable_user.id)
# Secure censor
if vardef is not None and vardef["secure"]:
preference['value'] = "" if preference.get(
'value') is None or decrypt_value(
preference.get('value')) == "" else "********"
# Build operator property data
for property_name, property in six.iteritems(
operator.get('properties', {})):
vardef = operator_info['variables']['properties'].get(
property_name)
value = property.get('value', None)
# Handle multiuser
variable_user = user if vardef is not None and vardef[
"multiuser"] else workspaceDAO.creator
if property_name in operator_forced_values:
property['value'] = operator_forced_values[property_name][
'value']
elif value is None or value["users"].get("%s" % variable_user.id,
None) is None:
# If not defined / not defined for the current user, take the default value
property['value'] = parse_value_from_text(
vardef, vardef['default'])
else:
property['value'] = value["users"].get("%s" % variable_user.id)
# Secure censor
if vardef is not None and vardef["secure"]:
property['value'] = "" if property.get(
'value') is None or decrypt_value(
property.get('value')) == "" else "********"
return json.dumps(data_ret, cls=LazyEncoder)
def _populate_variables_values_cache(workspace, user, key, forced_values=None):
""" populates VariableValue cached values for that user """
values_by_varname = {
"ioperator": {},
"iwidget": {},
}
if forced_values is None:
context_values = get_context_values(workspace, user)
preferences = get_workspace_preference_values(workspace)
forced_values = process_forced_values(workspace, user, context_values,
preferences)
for iwidget in IWidget.objects.filter(tab__workspace=workspace):
# forced_values uses string keys
svariwidget = "%s" % iwidget.id
values_by_varname["iwidget"][svariwidget] = {}
if iwidget.widget is None:
continue
iwidget_info = iwidget.widget.resource.get_processed_info()
for vardef in iwidget_info.get('preferences', {}):
value = iwidget.variables.get(vardef['name'], None)
_process_variable("iwidget", svariwidget, vardef, value,
forced_values, values_by_varname, user,
workspace.creator)
for vardef in iwidget_info.get('properties', {}):
value = iwidget.variables.get(vardef['name'], None)
_process_variable("iwidget", svariwidget, vardef, value,
forced_values, values_by_varname, user,
workspace.creator)
for operator_id, operator in six.iteritems(
workspace.wiringStatus.get('operators', {})):
values_by_varname["ioperator"][operator_id] = {}
vendor, name, version = operator['name'].split('/')
try:
operator_info = CatalogueResource.objects.get(
vendor=vendor, short_name=name,
version=version).get_processed_info()
except CatalogueResource.DoesNotExist:
continue
for vardef in operator_info.get('preferences', {}):
value = operator.get("preferences", {}).get(vardef['name'],
{}).get("value")
_process_variable("ioperator", operator_id, vardef, value,
forced_values, values_by_varname, user,
workspace.creator)
for vardef in operator_info.get('properties', {}):
value = operator.get("properties", {}).get(vardef['name'],
{}).get("value")
_process_variable("ioperator", operator_id, vardef, value,
forced_values, values_by_varname, user,
workspace.creator)
cache.set(key, values_by_varname)
return values_by_varname
def _get_global_workspace_data(workspaceDAO, user):
data_ret = get_workspace_data(workspaceDAO, user)
# Workspace preferences
preferences = get_workspace_preference_values(workspaceDAO)
data_ret['preferences'] = preferences
data_ret['users'] = []
for user in workspaceDAO.users.all():
try:
is_organization = user.organization is not None
except:
is_organization = False
data_ret['users'].append({
"fullname": user.get_full_name(),
"username": user.username,
"organization": is_organization,
"accesslevel": "owner" if workspaceDAO.creator == user else "read",
})
# Process forced variable values
concept_values = get_context_values(workspaceDAO, user)
forced_values = process_forced_values(workspaceDAO, user, concept_values, preferences)
data_ret['empty_params'] = forced_values['empty_params']
data_ret['extra_prefs'] = forced_values['extra_prefs']
if len(forced_values['empty_params']) > 0:
return json.dumps(data_ret, cls=LazyEncoder)
cache_manager = VariableValueCacheManager(workspaceDAO, user, forced_values)
# Tabs processing
# Check if the workspace's tabs have order
tabs = Tab.objects.filter(workspace=workspaceDAO).order_by('position')
if tabs.count() > 0:
if tabs[0].position is not None:
tabs = tabs.order_by('position')
else:
# set default order
for i in range(len(tabs)):
tabs[i].position = i
tabs[i].save()
else:
tabs = [createTab(_('Tab'), workspaceDAO)]
data_ret['tabs'] = [get_tab_data(tab, workspace=workspaceDAO, cache_manager=cache_manager) for tab in tabs]
data_ret['wiring'] = workspaceDAO.wiringStatus
for operator_id, operator in six.iteritems(data_ret['wiring'].get('operators', {})):
try:
(vendor, name, version) = operator['name'].split('/')
except:
continue
try:
resource = CatalogueResource.objects.get(vendor=vendor, short_name=name, version=version)
if not resource.is_available_for(workspaceDAO.creator):
# The operator used by this instance is missing
continue
except CatalogueResource.DoesNotExist:
continue
operator_info = resource.get_processed_info(process_variables=True)
operator_forced_values = forced_values['ioperator'].get(operator_id, {})
for preference_name, preference in six.iteritems(operator.get('preferences', {})):
vardef = operator_info['variables']['preferences'].get(preference_name)
if preference_name in operator_forced_values:
preference['value'] = operator_forced_values[preference_name]['value']
elif preference.get('value') is None and vardef is not None:
preference['value'] = parse_value_from_text(vardef, vardef['default'])
return json.dumps(data_ret, cls=LazyEncoder)
def _get_global_workspace_data(workspaceDAO, user):
data_ret = get_workspace_data(workspaceDAO, user)
# Workspace preferences
preferences = get_workspace_preference_values(workspaceDAO)
data_ret['preferences'] = preferences
data_ret['users'] = []
for user in workspaceDAO.users.all():
try:
is_organization = user.organization is not None
except:
is_organization = False
data_ret['users'].append({
"fullname":
user.get_full_name(),
"username":
user.username,
"organization":
is_organization,
"accesslevel":
"owner" if workspaceDAO.creator == user else "read",
})
# Process forced variable values
concept_values = get_context_values(workspaceDAO, user)
forced_values = process_forced_values(workspaceDAO, user, concept_values,
preferences)
data_ret['empty_params'] = forced_values['empty_params']
data_ret['extra_prefs'] = forced_values['extra_prefs']
if len(forced_values['empty_params']) > 0:
return json.dumps(data_ret, cls=LazyEncoder)
cache_manager = VariableValueCacheManager(workspaceDAO, user,
forced_values)
# Tabs processing
# Check if the workspace's tabs have order
tabs = Tab.objects.filter(workspace=workspaceDAO).order_by('position')
if tabs.count() > 0:
if tabs[0].position is not None:
tabs = tabs.order_by('position')
else:
# set default order
for i in range(len(tabs)):
tabs[i].position = i
tabs[i].save()
else:
tabs = [createTab(_('Tab'), workspaceDAO)]
data_ret['tabs'] = [
get_tab_data(tab, workspace=workspaceDAO, cache_manager=cache_manager)
for tab in tabs
]
data_ret['wiring'] = workspaceDAO.wiringStatus
for operator_id, operator in six.iteritems(data_ret['wiring'].get(
'operators', {})):
try:
(vendor, name, version) = operator['name'].split('/')
except:
continue
try:
resource = CatalogueResource.objects.get(vendor=vendor,
short_name=name,
version=version)
if not resource.is_available_for(workspaceDAO.creator):
# The operator used by this instance is missing
continue
except CatalogueResource.DoesNotExist:
continue
operator_info = resource.get_processed_info(process_variables=True)
operator_forced_values = forced_values['ioperator'].get(
operator_id, {})
for preference_name, preference in six.iteritems(
operator.get('preferences', {})):
vardef = operator_info['variables']['preferences'].get(
preference_name)
if preference_name in operator_forced_values:
preference['value'] = operator_forced_values[preference_name][
'value']
elif preference.get('value') is None and vardef is not None:
preference['value'] = parse_value_from_text(
vardef, vardef['default'])
return json.dumps(data_ret, cls=LazyEncoder)
def _get_global_workspace_data(workspaceDAO, user):
data_ret = get_workspace_data(workspaceDAO, user)
# Workspace preferences
preferences = get_workspace_preference_values(workspaceDAO)
data_ret['preferences'] = preferences
data_ret['users'] = []
for u in workspaceDAO.users.all():
try:
is_organization = u.organization is not None
except:
is_organization = False
data_ret['users'].append({
"fullname": u.get_full_name(),
"username": u.username,
"organization": is_organization,
"accesslevel": "owner" if workspaceDAO.creator == u else "read",
})
# Process forced variable values
concept_values = get_context_values(workspaceDAO, user)
forced_values = process_forced_values(workspaceDAO, user, concept_values, preferences)
data_ret['empty_params'] = forced_values['empty_params']
data_ret['extra_prefs'] = forced_values['extra_prefs']
if len(forced_values['empty_params']) > 0:
return json.dumps(data_ret, cls=LazyEncoder)
cache_manager = VariableValueCacheManager(workspaceDAO, user, forced_values)
# Tabs processing
# Check if the workspace's tabs have order
tabs = Tab.objects.filter(workspace=workspaceDAO).order_by('position')
if tabs.count() > 0:
if tabs[0].position is not None:
tabs = tabs.order_by('position')
else:
# set default order
for i in range(len(tabs)):
tabs[i].position = i
tabs[i].save()
else:
tabs = [createTab(_('Tab'), workspaceDAO)]
data_ret['tabs'] = [get_tab_data(tab, workspace=workspaceDAO, cache_manager=cache_manager, user=user) for tab in tabs]
data_ret['wiring'] = deepcopy(workspaceDAO.wiringStatus)
for operator_id, operator in six.iteritems(data_ret['wiring'].get('operators', {})):
try:
(vendor, name, version) = operator['name'].split('/')
except:
continue
try:
resource = CatalogueResource.objects.get(vendor=vendor, short_name=name, version=version)
operator_info = resource.get_processed_info(process_variables=True)
# Check if the resource is available, if not, variables should not be retrieved
if not resource.is_available_for(workspaceDAO.creator):
raise CatalogueResource.DoesNotExist
except CatalogueResource.DoesNotExist:
operator["preferences"] = {}
operator["properties"] = {}
continue
operator_forced_values = forced_values['ioperator'].get(operator_id, {})
# Build operator preference data
for preference_name, preference in six.iteritems(operator.get('preferences', {})):
vardef = operator_info['variables']['preferences'].get(preference_name)
value = preference.get('value', None)
# Handle multiuser
variable_user = user if vardef is not None and vardef["multiuser"] else workspaceDAO.creator
if preference_name in operator_forced_values:
preference['value'] = operator_forced_values[preference_name]['value']
elif value is None or value["users"].get("%s" % variable_user.id, None) is None:
# If not defined / not defined for the current user, take the default value
preference['value'] = parse_value_from_text(vardef, vardef['default'])
else:
preference['value'] = value["users"].get("%s" % variable_user.id)
# Secure censor
if vardef is not None and vardef["secure"]:
preference['value'] = "" if preference.get('value') is None or decrypt_value(preference.get('value')) == "" else "********"
# Build operator property data
for property_name, property in six.iteritems(operator.get('properties', {})):
vardef = operator_info['variables']['properties'].get(property_name)
value = property.get('value', None)
# Handle multiuser
variable_user = user if vardef is not None and vardef["multiuser"] else workspaceDAO.creator
if property_name in operator_forced_values:
property['value'] = operator_forced_values[property_name]['value']
elif value is None or value["users"].get("%s" % variable_user.id, None) is None:
# If not defined / not defined for the current user, take the default value
property['value'] = parse_value_from_text(vardef, vardef['default'])
else:
property['value'] = value["users"].get("%s" % variable_user.id)
# Secure censor
if vardef is not None and vardef["secure"]:
property['value'] = "" if property.get('value') is None or decrypt_value(property.get('value')) == "" else "********"
return json.dumps(data_ret, cls=LazyEncoder)
def _get_global_workspace_data(workspaceDAO, user):
data_ret = get_workspace_data(workspaceDAO, user)
# Context information
data_ret['context'] = get_workspace_context(workspaceDAO, user)
# Workspace preferences
preferences = get_workspace_preference_values(workspaceDAO)
data_ret['preferences'] = preferences
data_ret['users'] = []
for user in workspaceDAO.users.all():
try:
is_organization = resource.organization is not None
except:
is_organization = False
data_ret['users'].append({
"fullname":
user.get_full_name(),
"username":
user.username,
"organization":
is_organization,
"accesslevel":
"owner" if workspaceDAO.creator == user else "read",
})
# Process forced variable values
concept_values = get_context_values(workspaceDAO, user)
forced_values = process_forced_values(workspaceDAO, user, concept_values,
preferences)
data_ret['empty_params'] = forced_values['empty_params']
data_ret['extra_prefs'] = forced_values['extra_prefs']
if len(forced_values['empty_params']) > 0:
return json.dumps(data_ret, cls=LazyEncoder)
cache_manager = VariableValueCacheManager(workspaceDAO, user,
forced_values)
# Tabs processing
# Check if the workspace's tabs have order
tabs = Tab.objects.filter(workspace=workspaceDAO).order_by('position')
if tabs.count() > 0:
if tabs[0].position is not None:
tabs = tabs.order_by('position')
else:
# set default order
for i in range(len(tabs)):
tabs[i].position = i
tabs[i].save()
else:
tabs = [createTab(_('Tab'), workspaceDAO)]
tabs_data = [get_tab_data(tab) for tab in tabs]
data_ret['tabs'] = tabs_data
for tab in tabs_data:
tab_pk = tab['id']
iwidgets = IWidget.objects.filter(tab__id=tab_pk).order_by('id')
iwidget_data = []
for iwidget in iwidgets:
iwidget_data.append(
get_iwidget_data(iwidget, workspaceDAO, cache_manager))
tab['iwidgets'] = iwidget_data
data_ret['wiring'] = workspaceDAO.wiringStatus
for forced_operator_id, forced_preferences in six.iteritems(
forced_values['ioperator']):
for forced_pref_name, forced_preference in six.iteritems(
forced_preferences):
data_ret['wiring']['operators'][forced_operator_id]['preferences'][
forced_pref_name]['value'] = forced_preference['value']
return json.dumps(data_ret, cls=LazyEncoder)
def _get_global_workspace_data(workspaceDAO, user):
data_ret = get_workspace_data(workspaceDAO, user)
# Context information
data_ret['context'] = get_workspace_context(workspaceDAO, user)
# Workspace preferences
preferences = get_workspace_preference_values(workspaceDAO)
data_ret['preferences'] = preferences
data_ret['users'] = []
for user in workspaceDAO.users.all():
try:
is_organization = resource.organization is not None
except:
is_organization = False
data_ret['users'].append({
"fullname": user.get_full_name(),
"username": user.username,
"organization": is_organization,
"accesslevel": "owner" if workspaceDAO.creator == user else "read",
})
# Process forced variable values
concept_values = get_context_values(workspaceDAO, user)
forced_values = process_forced_values(workspaceDAO, user, concept_values, preferences)
data_ret['empty_params'] = forced_values['empty_params']
data_ret['extra_prefs'] = forced_values['extra_prefs']
if len(forced_values['empty_params']) > 0:
return json.dumps(data_ret, cls=LazyEncoder)
cache_manager = VariableValueCacheManager(workspaceDAO, user, forced_values)
# Tabs processing
# Check if the workspace's tabs have order
tabs = Tab.objects.filter(workspace=workspaceDAO).order_by('position')
if tabs.count() > 0:
if tabs[0].position is not None:
tabs = tabs.order_by('position')
else:
# set default order
for i in range(len(tabs)):
tabs[i].position = i
tabs[i].save()
else:
tabs = [createTab(_('Tab'), workspaceDAO)]
tabs_data = [get_tab_data(tab) for tab in tabs]
data_ret['tabs'] = tabs_data
for tab in tabs_data:
tab_pk = tab['id']
iwidgets = IWidget.objects.filter(tab__id=tab_pk).order_by('id')
iwidget_data = []
for iwidget in iwidgets:
iwidget_data.append(get_iwidget_data(iwidget, workspaceDAO, cache_manager))
tab['iwidgets'] = iwidget_data
data_ret['wiring'] = workspaceDAO.wiringStatus
for forced_operator_id, forced_preferences in six.iteritems(forced_values['ioperator']):
for forced_pref_name, forced_preference in six.iteritems(forced_preferences):
data_ret['wiring']['operators'][forced_operator_id]['preferences'][forced_pref_name]['value'] = forced_preference['value']
return json.dumps(data_ret, cls=LazyEncoder)
