def edit(request, revision_id=None):
if request.method == 'GET':
visualization_rev = VisualizationDBDAO().get(
request.auth_manager.language,
visualization_revision_id=revision_id)
datastream_rev = DataStreamDBDAO().get(
request.auth_manager.language,
datastream_revision_id=visualization_rev['datastream_revision_id'])
return render_to_response(
'createVisualization/index.html',
dict(request=request,
datastream_revision=datastream_rev,
visualization_revision=visualization_rev))
elif request.method == 'POST':
""" save new or update dataset """
# Formulario
form = VisualizationForm(request.POST)
if not form.is_valid():
logger.info(form.errors)
raise VisualizationSaveException('Invalid form data: %s' %
str(form.errors.as_text()))
visualization_rev = VisualizationDBDAO().get(
request.auth_manager.language,
visualization_revision_id=revision_id)
response = form.save(request, visualization_rev=visualization_rev)
# Signal
visualization_changed.send_robust(
sender='edit_view',
id=visualization_rev['visualization_id'],
rev_id=visualization_rev['visualization_revision_id'])
return JSONHttpResponse(json.dumps(response))
def index(request):
""" list all dataviews """
dao = VisualizationDBDAO()
resources, total_resources = dao.query(account_id=request.account.id, language=request.user.language)
for resource in resources:
resource['url'] = reverse('manageVisualizations.view', urlconf='workspace.urls', kwargs={'revision_id': resource['id']})
filters = dao.query_filters(account_id=request.user.account.id,
language=request.user.language)
return render_to_response('manageVisualizations/index.html', locals())
def action_catalog_xml(request):
logger = logging.getLogger(__name__)
account_id = request.account.id
language = request.auth_manager.language
preferences = request.preferences
domain = get_domain_by_request(request)
api_domain = preferences['account_api_domain']
transparency_domain = preferences['account_api_transparency']
developers_link = 'http://' + domain + reverse('manageDeveloper.action_query')
datastreams_revision_ids = DataStreamRevision.objects.values_list('id').filter(
datastream__user__account_id=account_id, status=StatusChoices.PUBLISHED
)
resources = []
for datastream_revision_id, in datastreams_revision_ids:
try:
ds = DataStreamDBDAO().get(language, datastream_revision_id=datastream_revision_id)
except:
logger.error('catalog ERROR %s %s' % (datastream_revision_id, language))
continue
ds.link = 'http://{}{}'.format(domain, ds.permalink())
ds.export_csv_link = 'http://{}{}'.format(
domain,
reverse('datastream_manager.csv', kwargs={'id': ds.datastream_id, 'slug': ds.slug})
)
ds.export_html_link = 'http://{}{}'.format(
domain,
reverse('datastream_manager.html', kwargs={'id': ds.datastream_id, 'slug': ds.slug})
)
ds.api_link = 'http://' + api_domain + '/dataviews/invoke/' + ds.guid + '?auth_key=your_authkey'
ds.visualizations = []
visualization_revision_ids = VisualizationRevision.objects.values_list('id').filter(
visualization__datastream_id=ds.datastream_id,
status=StatusChoices.PUBLISHED
)
for visualization_revision_id, in visualization_revision_ids:
try:
vz = VisualizationDBDAO().get(language, visualization_revision_id=visualization_revision_id)
except:
logger.error('catalog VIZ ERROR %s %s' % (visualization_revision_id, language))
continue
vz['link'] = 'http://' + domain + vz.permalink()
ds.visualizations.append(vz)
resources.append(ds)
return render_to_response('catalog.xml', locals(), mimetype='application/xml')
def index(request):
""" list all dataviews
:param request:
"""
dao = VisualizationDBDAO()
resources, total_resources = dao.query(account_id=request.account.id, language=request.user.language)
for resource in resources:
resource['url'] = reverse('manageVisualizations.view', urlconf='workspace.urls', kwargs={'revision_id': resource['id']})
filters = dao.query_filters(account_id=request.user.account.id,
language=request.user.language)
return render_to_response('manageVisualizations/index.html', locals())
def retrieveResourcePermalinks(resourceIds, language):
datastreamIds = []
visualizationIds = []
dashboardIds = []
for resource in resourceIds:
if resource['type']== 'chart':
visualizationIds.append(resource['id'])
elif resource['type']== 'ds':
datastreamIds.append(resource['id'])
elif resource['type']== 'db':
dashboardIds.append(resource['id'])
resources = []
if datastreamIds:
idsDataStream = ','.join(datastreamIds)
resources = DataStreamDBDAO().query_hot_n(10,language, hot = idsDataStream)
if visualizationIds:
idsVisualization = ','.join(visualizationIds)
resources += VisualizationDBDAO.query_hot_n(language, hot = idsVisualization)
add_domains_to_permalinks(resources)
return resources
def filter(request, page=0, itemsxpage=settings.PAGINATION_RESULTS_PER_PAGE):
""" filter resources
:param itemsxpage:
:param page:
:param request:
"""
bb_request = request.GET
filters_param = bb_request.get('filters')
filters_dict = dict()
filter_name = ''
sort_by = bb_request.get("sort_by", None)
order = bb_request.get("order", "asc")
if filters_param is not None and filters_param != '':
filters = json.loads(filters_param)
filters_dict['impl_type'] = filters.get('type')
filters_dict['category__categoryi18n__name'] = filters.get('category')
filters_dict['visualization__user__nick'] = filters.get('author')
filters_dict['status'] = filters.get('status')
if bb_request.get('page') is not None and bb_request.get('page') != '':
page = int(bb_request.get('page'))
if bb_request.get('q') is not None and bb_request.get('q') != '':
filter_name = bb_request.get('q')
if bb_request.get('itemxpage') is not None and bb_request.get('itemxpage') != '':
itemsxpage = int(bb_request.get('itemxpage'))
if sort_by:
if sort_by == "title":
sort_by ="visualizationi18n__title"
elif sort_by == "dataset_title":
sort_by ="visualization__datastream__datastreamrevision__dataset__datasetrevision__dataseti18n__title"
elif sort_by == "author":
sort_by ="visualization__user__nick"
if order=="desc":
sort_by = "-"+ sort_by
else:
sort_by='-id'
total_resources = request.stats['account_total_visualizations']
resources,total_entries = VisualizationDBDAO().query(
account_id=request.account.id,
language=request.user.language,
page=page,
itemsxpage=itemsxpage,
filters_dict=filters_dict,
sort_by=sort_by,
filter_name=filter_name
)
for resource in resources:
resource['url'] = reverse('manageVisualizations.view', kwargs=dict(revision_id=resource['id']))
resource['datastream_url'] = reverse('manageDataviews.view', kwargs={'revision_id': resource['visualization__datastream__last_revision__id']})
data = render_to_string('manageVisualizations/visualization_list.json', dict(items=resources, total_entries=total_entries, total_resources=total_resources))
return HttpResponse(data, mimetype="application/json")
def retrieve_resources_for_slider(self, resourceIds, language):
datastreamIds = []
visualizationIds = []
for resource in resourceIds:
if resource['type'] == 'vz':
visualizationIds.append(resource['id'])
elif resource['type'] == 'ds':
datastreamIds.append(resource['id'])
data = []
# usamos el DAO
for i in datastreamIds:
try:
data.append(DataStreamDBDAO().get(self.user,
datastream_id=i,
published=True))
except DataStreamRevision.DoesNotExist:
self.logger.error(
"ThemeBuilder.slider: DataStream.id=%s no existe o no esta publicado"
% i)
for i in visualizationIds:
try:
data.append(VisualizationDBDAO().get(self.user,
visualization_id=i,
published=True))
except VisualizationRevision.DoesNotExist:
self.logger.error(
"ThemeBuilder.slider: Visualization.id=%s no existe o no esta publicado"
% i)
return data
def get_filters_json(request):
""" List all Filters available
:param request:
"""
filters = VisualizationDBDAO().query_filters(
account_id=request.user.account.id, language=request.user.language)
return JSONHttpResponse(json.dumps(filters))
def retrieveResourcePermalinks(self, resourceIds, language):
datastreamIds = []
visualizationIds = []
for resource in resourceIds:
if resource['type'] == 'vz':
visualizationIds.append(resource['id'])
elif resource['type'] == 'ds':
datastreamIds.append(resource['id'])
resources = []
if datastreamIds:
idsDataStream = ','.join(datastreamIds)
resources = DataStreamDBDAO().query_hot_n(10,
language,
hot=idsDataStream)
if visualizationIds:
idsVisualization = ','.join(visualizationIds)
resources += VisualizationDBDAO().query_hot_n(language,
hot=idsVisualization)
add_domains_to_permalinks(resources)
return resources
class RestMapViewSet(ResourceViewSet):
queryset = VisualizationDBDAO()
serializer_class = VisualizationSerializer
lookup_field = 'id'
dao_get_param = 'visualization_revision_id'
data_types = ['vz']
dao_pk = 'visualization_revision_id'
app = 'workspace'
published = False
@detail_route(methods=['get'])
def data(self, request, format=None, *args, **kwargs):
return self.engine_call(request,
'invoke',
format,
form_class=VisualizationRequestForm,
serialize=False)
@list_route(methods=['get'])
def sample(self, request, format=None, *args, **kwargs):
return self.engine_call(request,
'preview',
format,
form_class=VisualizationPreviewMapForm,
serialize=False,
is_detail=False)
def embed(request, guid):
"""
Show an embed microsite view
"""
account = request.account
preferences = request.preferences
msprotocol = 'https' if account.get_preference('account.microsite.https') else 'http'
base_uri = msprotocol + '://' + preferences['account_domain']
try:
visualization_revision = VisualizationDBDAO().get(
preferences['account_language'], published=True, guid=guid )
datastream = DataStreamDBDAO().get(
preferences['account_language'],
datastream_revision_id=visualization_revision["datastream_revision_id"]
)
except:
return render_to_response('viewChart/embed404.html',{'settings': settings, 'request' : request})
#VisualizationHitsDAO(visualization_revision.visualization).add(ChannelTypes.WEB)
VisualizationHitsDAO(visualization_revision).add(ChannelTypes.WEB)
width = request.REQUEST.get('width', False) # TODO get default value from somewhere
height = request.REQUEST.get('height', False) # TODO get default value from somewhere
visualization_revision_parameters = RequestProcessor(request).get_arguments(visualization_revision["parameters"])
visualization_revision_parameters['pId'] = visualization_revision["datastream_revision_id"]
command = AbstractCommandFactory('microsites').create("invoke",
"vz", (visualization_revision_parameters,))
json, type = command.run()
visualization_revision_parameters = urllib.urlencode(visualization_revision_parameters)
return render_to_response('viewChart/embed.html', locals())
def filter(request, page=0, itemsxpage=settings.PAGINATION_RESULTS_PER_PAGE):
""" filter resources """
bb_request = request.GET
filters = bb_request.get('filters')
filters_dict = ''
filter_name= ''
sort_by='-id'
if filters is not None and filters != '':
filters_dict = unset_visualization_revision_nice(json.loads(bb_request.get('filters')))
if bb_request.get('page') is not None and bb_request.get('page') != '':
page = int(bb_request.get('page'))
if bb_request.get('itemxpage') is not None and bb_request.get('itemxpage') != '':
itemsxpage = int(bb_request.get('itemxpage'))
if bb_request.get('q') is not None and bb_request.get('q') != '':
filter_name = bb_request.get('q')
if bb_request.get('sort_by') is not None and bb_request.get('sort_by') != '':
if bb_request.get('sort_by') == "title":
sort_by ="visualizationi18n__title"
if bb_request.get('sort_by') == "dataset_title":
sort_by ="visualization__datastream__datastreamrevision__dataset__datasetrevision__dataseti18n__title"
if bb_request.get('sort_by') == "author":
sort_by ="visualization__user__nick"
if bb_request.get('order')=="desc":
sort_by = "-"+ sort_by
#limit = int(bb_request.get('rp'))
#sort_by = bb_request.get('sortname')
#order = bb_request.get('sortorder')
#filters_dict=filters_dict
vs_dao = VisualizationDBDAO()
resources,total_resources = vs_dao.query(
account_id=request.account.id,
language=request.user.language,
page=page,
itemsxpage=itemsxpage,
filters_dict=filters_dict,
sort_by=sort_by,
filter_name=filter_name
)
for resource in resources:
resource['url'] = reverse('manageVisualizations.view', kwargs=dict(revision_id=resource['id']))
resource['datastream_url'] = reverse('manageDataviews.view', kwargs={'revision_id': resource['visualization__datastream__last_revision__id']})
data = render_to_string('manageVisualizations/filter.json', dict(items=resources, total_entries=total_resources))
return HttpResponse(data, mimetype="application/json")
class VisualizationViewSet(ResourceViewSet):
queryset = VisualizationDBDAO()
serializer_class = VisualizationSerializer
lookup_field = 'guid'
dao_get_param = 'guid'
data_types = ['vz']
app = 'microsites'
hits_dao = VisualizationHitsDAO
def get_visualization(self,
resource_id=None,
revision_id=None,
published=True):
from core.daos.visualizations import VisualizationDBDAO
return VisualizationDBDAO().get(self.user,
visualization_id=resource_id,
visualization_revision_id=revision_id,
published=published)
def retrieve_childs(request):
visualization_revision_id = request.GET.get('revision_id', '')
visualization_id = request.GET.get('visualization_id', '')
visualizations = VisualizationDBDAO().query_childs(
visualization_id=visualization_id,
language=request.auth_manager.language
)
list_result = [associated_visualization for associated_visualization in visualizations]
return HttpResponse(json.dumps(list_result), mimetype="application/json")
def view(request, revision_id):
try:
visualization_revision = VisualizationDBDAO().get(
request.user, visualization_revision_id=revision_id)
except VisualizationRevision.DoesNotExist:
logger.info("VisualizationRevision ID %s does not exist" % revision_id)
raise VisualizationNotFoundException()
return render_to_response('viewVisualization/index.html', locals())
def sitemap(request):
language = request.auth_manager.language
account = request.account
params = request.GET
domain = get_domain_by_request(request)
now = now()
dss = DataStreamDBDAO().query(account_id=account.id, language=language, filters_dict=dict(status=[3]))[0]
vss = VisualizationDBDAO().query(account_id=account.id, language=language, filters_dict=dict(status=[3]))[0]
return render_to_response('sitemap.xml', locals(), content_type="application/xml")
class RestMapViewSet(ResourceViewSet):
queryset = VisualizationDBDAO()
serializer_class = VisualizationSerializer
lookup_field = 'id'
dao_get_param = 'visualization_revision_id'
data_types = ['vz']
dao_pk = 'visualization_revision_id'
app = 'microsites'
@detail_route(methods=['get'])
def data(self, request, format=None, *args, **kwargs):
return self.engine_call( request, 'invoke', format,
form_class=VisualizationRequestForm,
serialize=False)
def view(request, id, slug=None):
"""
Show a microsite view
"""
account = request.account
preferences = request.preferences
try:
visualization_revision = VisualizationDBDAO().get(request.user,
visualization_id=id,
published=True)
visualization = visualization_revision['visualization']
# For datastream sidebar functions (downloads and others)
datastream = DataStreamDBDAO().get(
request.user,
datastream_revision_id=visualization_revision[
"datastream_revision_id"])
except VisualizationRevision.DoesNotExist:
raise VisualizationRevisionDoesNotExist
else:
VisualizationHitsDAO(visualization_revision).add(ChannelTypes.WEB)
visualization_revision_parameters = RequestProcessor(
request).get_arguments(visualization_revision["parameters"])
chart_type = json.loads(
visualization_revision["impl_details"]).get('format').get('type')
if chart_type == 'mapchart':
geo_type = json.loads(visualization_revision["impl_details"]).get(
'chart').get('geoType')
else:
geo_type = ''
visualization_revision_parameters = urllib.urlencode(
visualization_revision_parameters)
url_query = urllib.urlencode(
RequestProcessor(request).get_arguments(
visualization_revision['parameters']))
notes = visualization_revision['notes']
if request.GET.get('embedded', False) == 'true':
return render_to_response('viewChart/embedded.html', locals())
else:
return render_to_response('viewChart/index.html', locals())
def get_catalog_xml(request):
logger = logging.getLogger(__name__)
account_id = request.account.id
language = request.auth_manager.language
preferences = request.preferences
account = request.account
domain = get_domain_by_request(request)
api_domain = preferences['account_api_domain']
transparency_domain = preferences['account_api_transparency']
account = Account.objects.get(pk=account_id)
msprotocol = 'https' if account.get_preference('account.microsite.https') else 'http'
apiprotocol = 'https' if account.get_preference('account.api.https') else 'http'
developers_link = msprotocol + '://' + domain + reverse('manageDeveloper.filter')
datastreams_revision_ids = DataStream.objects.values_list('last_published_revision').filter(last_published_revision__status=StatusChoices.PUBLISHED,
user__account_id=account_id)
# necesario, porque el DAO.get requiere un usuario para obtener el language y el account
user = AccountAnonymousUser(account, request.auth_manager.language)
resources = []
for datastream_revision_id, in datastreams_revision_ids:
ds = DataStreamDBDAO().get(user, datastream_revision_id=datastream_revision_id, published=True)
permalink = reverse('viewDataStream.view', urlconf='microsites.urls', kwargs={'id': ds['resource_id'], 'slug': ds['slug']})
ds['link'] = '{}://{}{}'.format(msprotocol, domain, permalink)
ds['export_csv_link'] = '{}://{}{}'.format(msprotocol, domain,reverse('datastreams-data', kwargs={'id': ds['resource_id'],'format':'csv'}))
ds['export_html_link'] = '{}://{}{}'.format(msprotocol, domain, reverse('datastreams-data', kwargs={'id': ds['resource_id'], 'format': 'html'}) )
ds['api_link'] = apiprotocol + '://' + api_domain + '/datastreams/' + ds['guid'] + '/data/?auth_key=your_authkey'
ds['visualizations'] = []
visualization_revision_ids = Visualization.objects.values_list('last_published_revision').filter(
datastream_id=ds['resource_id'],
last_published_revision__status=StatusChoices.PUBLISHED
)
for visualization_revision_id, in visualization_revision_ids:
vz = VisualizationDBDAO().get(user, visualization_revision_id=visualization_revision_id, published=True)
permalink = reverse('chart_manager.view', urlconf='microsites.urls', kwargs={'id': vz['resource_id'], 'slug': vz['slug']})
vz['link'] = msprotocol + '://' + domain + permalink
ds['visualizations'].append(vz)
resources.append(ds)
return render_to_response('catalog.xml', locals(), content_type='application/xml')
def query_related_resources(self):
""" get all related resources for measuring impact """
ret = {}
ds_json = self.get()
ret['datastreams'] = [ds_json] if ds_json else []
# visualizations = Visualization.objects.filter(datastream=self.datastream)
visualizations = Visualization.objects.filter(
last_revision__visualization__datastream=self.datastream)
ret['visualizations'] = []
for visualization in visualizations:
vz = VisualizationDBDAO().get(
self.language,
visualization_revision_id=visualization.
last_published_revision.id,
published=True)
ret['visualizations'].append(vz)
return ret
def retrieve_resources_for_slider(self, resourceIds, language):
datastreamIds = []
visualizationIds = []
for resource in resourceIds:
if resource['type'] == 'vz':
visualizationIds.append(resource['id'])
elif resource['type'] == 'ds':
datastreamIds.append(resource['id'])
data = []
# usamos el DAO
for i in datastreamIds:
data.append(DataStreamDBDAO().get(language, datastream_id=i))
for i in visualizationIds:
data.append(VisualizationDBDAO().get(language, visualization_id=i))
return data
def view(request, id, slug=None):
"""
Show a microsite view
"""
account = request.account
preferences = request.preferences
try:
visualization_revision = VisualizationDBDAO().get(
preferences['account_language'],
visualization_id=id,
published=True
)
# verify if this account is the owner of this viz
visualization = Visualization.objects.get(pk=id)
if account.id != visualization.user.account.id:
raise NotAccesVisualization
#for datastream sidebar functions (downloads and others)
datastream = DataStreamDBDAO().get(
preferences['account_language'],
datastream_revision_id=visualization_revision["datastream_revision_id"]
)
except VisualizationRevision.DoesNotExist:
raise VisualizationRevisionDoesNotExist
else:
VisualizationHitsDAO(visualization_revision).add(ChannelTypes.WEB)
visualization_revision_parameters = RequestProcessor(request).get_arguments(visualization_revision["parameters"])
chart_type = json.loads(visualization_revision["impl_details"]).get('format').get('type')
visualization_revision_parameters = urllib.urlencode(visualization_revision_parameters)
notes = visualization_revision['notes']
return render_to_response('viewChart/index.html', locals())
def get_catalog_xml(request):
logger = logging.getLogger(__name__)
account_id = request.account.id
language = request.auth_manager.language
preferences = request.preferences
account = request.account
domain = get_domain_by_request(request)
api_domain = preferences['account_api_domain']
transparency_domain = preferences['account_api_transparency']
account = Account.objects.get(pk=account_id)
msprotocol = 'https' if account.get_preference(
'account.microsite.https') else 'http'
apiprotocol = 'https' if account.get_preference(
'account.api.https') else 'http'
developers_link = msprotocol + '://' + domain + reverse(
'manageDeveloper.filter')
datastreams_revision_ids = DataStreamRevision.objects.values_list(
'id').filter(datastream__user__account_id=account_id,
status=StatusChoices.PUBLISHED)
resources = []
for datastream_revision_id, in datastreams_revision_ids:
try:
ds = DataStreamDBDAO().get(
language, datastream_revision_id=datastream_revision_id)
except:
logger.error('catalog ERROR %s %s' %
(datastream_revision_id, language))
continue
ds.link = '{}://{}{}'.format(msprotocol, domain, ds.permalink())
ds.export_csv_link = '{}://{}{}'.format(
msprotocol, domain,
reverse('viewDataStream.csv',
kwargs={
'id': ds.datastream_id,
'slug': ds.slug
}))
ds.export_html_link = '{}://{}{}'.format(
msprotocol, domain,
reverse('viewDataStream.html',
kwargs={
'id': ds.datastream_id,
'slug': ds.slug
}))
ds.api_link = apiprotocol + '://' + api_domain + '/datastreams/' + ds.guid + '/data/?auth_key=your_authkey'
ds.visualizations = []
visualization_revision_ids = VisualizationRevision.objects.values_list(
'id').filter(visualization__datastream_id=ds.datastream_id,
status=StatusChoices.PUBLISHED)
for visualization_revision_id, in visualization_revision_ids:
try:
vz = VisualizationDBDAO().get(
language,
visualization_revision_id=visualization_revision_id)
except:
logger.error('catalog VIZ ERROR %s %s' %
(visualization_revision_id, language))
continue
vz['link'] = msprotocol + '://' + domain + vz.permalink()
ds.visualizations.append(vz)
resources.append(ds)
return render_to_response('catalog.xml',
locals(),
mimetype='application/xml')
def change_status(request, visualization_revision_id=None):
"""
Change visualization status
:param request:
:param visualization_revision_id:
:return: JSON Object
"""
if visualization_revision_id:
lifecycle = VisualizationLifeCycleManager(
user=request.user,
visualization_revision_id=visualization_revision_id)
action = request.POST.get('action')
action = 'accept' if action == 'approve' else action # fix para poder llamar dinamicamente al metodo de lifecycle
killemall = True if request.POST.get('killemall',
False) == 'true' else False
if action not in [
'accept', 'reject', 'publish', 'unpublish', 'send_to_review'
]:
raise NoStatusProvidedException()
if action == 'unpublish':
getattr(lifecycle, action)(killemall)
# Signal
visualization_unpublished.send_robust(
sender='change_status_view',
id=lifecycle.visualization.id,
rev_id=lifecycle.visualization_revision.id)
else:
getattr(lifecycle, action)()
if action == 'accept':
title = ugettext('APP-VISUALIZATION-APPROVED-TITLE'),
description = ugettext('APP-VISUALIZATION-APPROVED-TEXT')
elif action == 'reject':
title = ugettext('APP-VISUALIZATION-REJECTED-TITLE'),
description = ugettext('APP-VISUALIZATION-REJECTED-TEXT')
elif action == 'publish':
title = ugettext('APP-VISUALIZATION-PUBLISHED-TITLE'),
description = ugettext('APP-VISUALIZATION-PUBLISHED-TEXT')
elif action == 'unpublish':
title = ugettext('APP-VISUALIZATION-UNPUBLISH-TITLE'),
description = ugettext('APP-VISUALIZATION-UNPUBLISH-TEXT')
elif action == 'send_to_review':
title = ugettext('APP-VISUALIZATION-SENDTOREVIEW-TITLE'),
description = ugettext('APP-VISUALIZATION-SENDTOREVIEW-TEXT')
response = dict(status='ok',
messages={
'title': title,
'description': description
})
# Limpio un poco
response['result'] = VisualizationDBDAO().get(
request.user.language,
visualization_revision_id=visualization_revision_id)
account = request.account
msprotocol = 'https' if account.get_preference(
'account.microsite.https') else 'http'
response['result'][
'public_url'] = msprotocol + "://" + request.preferences[
'account.domain'] + reverse(
'chart_manager.view',
urlconf='microsites.urls',
kwargs={
'id': response['result']['visualization_id'],
'slug': '-'
})
response['result'].pop('parameters')
response['result'].pop('tags')
response['result'].pop('sources')
response['result'].pop('visualization')
return JSONHttpResponse(json.dumps(response, cls=DateTimeEncoder))
