def hits_stats(request, id, channel_type=None):
""" hits stats for chart datastreams """
try:
ds = DataStream.objects.get(pk=int(id))
except Visualization.DoesNotExist:
raise Http404
dao = DatastreamHitsDAO(ds)
hits = dao.count_by_days(30, channel_type)
field_names = [unicode(ugettext_lazy("REPORT-CHART-DATE")), unicode(ugettext_lazy("REPORT-CHART-TOTAL_HITS"))]
t = loader.get_template("datastream_manager/hits_stats.json")
c = Context({"data": list(hits), "field_names": field_names, "request": request, "cache": dao.from_cache})
return HttpResponse(t.render(c), content_type="application/json")
def hits_stats(request, id, channel_type=None):
""" hits stats for chart datastreams """
try:
datastream = DataStream.objects.get(pk=int(id))
except DataStream.DoesNotExist:
raise DataStreamDoesNotExist
hits_dao = DatastreamHitsDAO(datastream)
hits = hits_dao.count_by_days(30, channel_type)
field_names = [unicode(ugettext_lazy('REPORT-CHART-DATE')),unicode(ugettext_lazy('REPORT-CHART-TOTAL_HITS'))]
t = loader.get_template('viewDataStream/hits_stats.json')
c = Context({'data': list(hits), 'field_names': field_names, "request": request, "cache": hits_dao.from_cache})
return HttpResponse(t.render(c), content_type="application/json")
def embed(request, guid):
account = request.account
preferences = request.preferences
msprotocol = 'https' if account.get_preference(
'account.microsite.https') else 'http'
base_uri = msprotocol + '://' + preferences['account_domain']
try:
datastream = DataStreamDBDAO().get(preferences['account_language'],
guid=guid,
published=True)
parameters_query = RequestProcessor(request).get_arguments(
datastream['parameters'])
except Http404:
return render_to_response('viewDataStream/embed404.html', {
'settings': settings,
'request': request
})
DatastreamHitsDAO(datastream).add(ChannelTypes.WEB)
end_point = urllib.urlencode(parameters_query)
header_row = request.REQUEST.get('header_row', False)
fixed_column = request.REQUEST.get('fixed_column', False)
return render_to_response('viewDataStream/embed.html', locals())
def embed(request, guid):
"""
Get an embedded datastream
:param request:
:param guid:
:return:
"""
account = request.account
preferences = request.preferences
msprotocol = 'https' if account.get_preference(
'account.microsite.https') else 'http'
base_uri = msprotocol + '://' + preferences['account_domain']
try:
# parche horrible para usar account_language en vez del language del user
user = request.user
user.language = preferences['account_language']
datastream = DataStreamDBDAO().get(user, guid=guid, published=True)
parameters_query = RequestProcessor(request).get_arguments(
datastream['parameters'])
except DataStreamRevision.DoesNotExist:
return render_to_response('viewDataStream/embed404.html', {
'settings': settings,
'request': request
})
DatastreamHitsDAO(datastream).add(ChannelTypes.WEB)
end_point = urllib.urlencode(parameters_query)
header_row = request.REQUEST.get('header_row', False)
fixed_column = request.REQUEST.get('fixed_column', False)
return render_to_response('viewDataStream/embed.html', locals())
def view(request, id, slug):
"""
Get a datastream
:param request:
:param id:
:param slug:
:return:
"""
logger = logging.getLogger(__name__)
account = request.account
preferences = request.preferences
# parche horrible para usar account_language en vez del language del user
user = request.user
user.language = preferences['account_language']
datastream = DataStreamDBDAO().get(user, datastream_id=id, published=True)
url_query = urllib.urlencode(
RequestProcessor(request).get_arguments(datastream['parameters']))
DatastreamHitsDAO(datastream).add(ChannelTypes.WEB)
notes = datastream['notes']
if request.GET.get('embedded', False) == 'true':
return render_to_response('viewDataStream/embedded.html', locals())
else:
return render_to_response('viewDataStream/index.html', locals())
def index_datastreams(self):
if self.options['datastreams']:
if self.options['debug']: print "[Iniciando datastreams]"
for datastream in DataStream.objects.filter(
last_published_revision__status=StatusChoices.PUBLISHED):
try:
datastreamrevision = datastream.last_published_revision
datastream_rev = DataStreamDBDAO().get(
datastreamrevision.user,
datastream_revision_id=datastreamrevision.id,
published=True)
search_dao = DatastreamSearchDAOFactory().create(
datastreamrevision)
try:
search_dao.add()
except DatastreamI18n.MultipleObjectsReturned:
print "[ERROR ds] DatastreamI18n.MultipleObjectsReturned (ds.id= %s)" % datastream.id
continue
except AttributeError:
print "[ERROR ds] self.datastream.last_published_revision == None (ds= %s)" % datastream.id
continue
h = DatastreamHitsDAO(datastream_rev)
doc = {
'docid': "DS::%s" % datastreamrevision.datastream.guid,
"type": "ds",
"doc": {
"fields": {
"hits": h.count(),
"web_hits": h.count(channel_type=0),
"api_hits": h.count(channel_type=1)
}
}
}
try:
self.es.update(doc)
except:
if self.options['debug']:
print "[ERROR]: No se pudo ejecutar: ", doc
except:
print "[ERROR ds] Fallo al indexar ID {} de la cuenta: {}".format(
datastream.id, datastream.user.account.name)
def data(self, request, pk=None, format=None, *args, **kwargs):
instance = self.get_object()
DatastreamHitsDAO(instance).add(1)
if format == 'json' or not format:
return self.engine_call(request, 'invoke')
return self.engine_call(request,
'invoke',
format,
serialize=False,
form_class=DatastreamRequestForm,
download=False)
def index_datastreams(self):
if self.options['datastreams']:
if self.options['debug']: print "[Iniciando datastreams]"
for datastream in DataStream.objects.filter(last_published_revision__status=StatusChoices.PUBLISHED):
try:
datastreamrevision=datastream.last_published_revision
datastream_rev = DataStreamDBDAO().get(datastreamrevision.user,
datastream_revision_id=datastreamrevision.id,
published=True
)
search_dao = DatastreamSearchDAOFactory().create(datastreamrevision)
try:
search_dao.add()
except DatastreamI18n.MultipleObjectsReturned:
print "[ERROR ds] DatastreamI18n.MultipleObjectsReturned (ds.id= %s)" % datastream.id
continue
except AttributeError:
print "[ERROR ds] self.datastream.last_published_revision == None (ds= %s)" % datastream.id
continue
h = DatastreamHitsDAO(datastream_rev)
doc={
'docid': "DS::%s" % datastreamrevision.datastream.guid,
"type": "ds",
"doc": {
"fields": {
"hits": h.count(),
"web_hits": h.count(channel_type=0),
"api_hits": h.count(channel_type=1)
}
}
}
try:
self.es.update(doc)
except:
if self.options['debug']: print "[ERROR]: No se pudo ejecutar: ",doc
except:
print "[ERROR ds] Fallo al indexar ID {} de la cuenta: {}".format(datastream.id, datastream.user.account.name)
def view(request, id, slug):
logger = logging.getLogger(__name__)
account = request.account
preferences = request.preferences
datastream = DataStreamDBDAO().get(
language=preferences['account_language'],
datastream_id=id,
published=True)
url_query = urllib.urlencode(
RequestProcessor(request).get_arguments(datastream['parameters']))
DatastreamHitsDAO(datastream).add(ChannelTypes.WEB)
notes = datastream['notes']
return render_to_response('viewDataStream/index.html', locals())
def handle(self, *args, **options):
# index resources
if options['reindex']:
# destruye el index
ElasticsearchIndex().flush_index()
es = ElasticsearchIndex()
for dataset in Dataset.objects.filter(last_published_revision__status=StatusChoices.PUBLISHED):
datasetrevision=dataset.last_published_revision
search_dao = DatasetSearchDAOFactory().create(datasetrevision)
search_dao.add()
for vz in Visualization.objects.filter(last_published_revision__status=StatusChoices.PUBLISHED):
vz_revision=vz.last_published_revision
search_dao = VisualizationSearchDAOFactory().create(vz_revision)
search_dao.add()
h = VisualizationHitsDAO(vz_revision)
doc={
'docid': "VZ::%s" % vz.guid,
"type": "vz",
"doc": {
"fields": {
"hits": h.count(),
"web_hits": h.count(channel_type=0),
"api_hits": h.count(channel_type=1)
}
}
}
try:
es.update(doc)
except:
pass
# TODO Hay que usar el metodo query del DAO
for datastream in DataStream.objects.filter(last_published_revision__status=StatusChoices.PUBLISHED):
datastreamrevision=datastream.last_published_revision
datastream_rev = DataStreamDBDAO().get(
datastreamrevision.user.language,
datastream_revision_id=datastreamrevision.id,
published=True
)
search_dao = DatastreamSearchDAOFactory().create(datastreamrevision)
search_dao.add()
h = DatastreamHitsDAO(datastream_rev)
doc={
'docid': "DS::%s" % datastreamrevision.datastream.guid,
"type": "ds",
"doc": {
"fields": {
"hits": h.count(),
"web_hits": h.count(channel_type=0),
"api_hits": h.count(channel_type=1)
}
}
}
try:
es.update(doc)
except:
pass
for plugin in DatalPluginPoint.get_active_with_att('reindex'):
plugin.reindex(es)