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))