def edit(request, datastream_revision_id=None):
if request.method == 'GET':
account_id = request.auth_manager.account_id
credentials = request.auth_manager
language = request.auth_manager.language
categories = CategoryI18n.objects.filter(
language=language,
category__account=account_id).values('category__id', 'name')
status_options = credentials.get_allowed_actions()
lifecycle = DatastreamLifeCycleManager(
user=request.user, datastream_revision_id=datastream_revision_id)
status = lifecycle.datastream_revision.status
dao = DataStreamDBDAO().get(
request.user, datastream_revision_id=datastream_revision_id)
response = DefaultDataViewEdit(
template='datastream_edit_response.json').render(
categories, status, status_options,
lifecycle.datastream_revision, lifecycle.datastreami18n, dao)
return JSONHttpResponse(response)
elif request.method == 'POST':
"""update dataset """
form = EditDataStreamForm(request.POST)
if not form.is_valid():
raise LifeCycleException('Invalid form data: %s' %
str(form.errors.as_text()))
if form.is_valid():
lifecycle = DatastreamLifeCycleManager(
user=request.user,
datastream_revision_id=datastream_revision_id)
lifecycle.edit(language=request.auth_manager.language,
changed_fields=form.changed_data,
**form.cleaned_data)
# Signal
datastream_changed.send_robust(
sender='edit_view',
id=lifecycle.datastream.id,
rev_id=lifecycle.datastream_revision.id)
response = dict(
status='ok',
datastream_revision_id=lifecycle.datastream_revision.id,
messages=[ugettext('APP-DATASET-CREATEDSUCCESSFULLY-TEXT')],
)
return JSONHttpResponse(json.dumps(response))
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 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 create(request):
if request.method == 'GET':
datastream_revision_id = request.GET.get('datastream_revision_id',
None)
try:
datastream_rev = DataStreamDBDAO().get(
request.user.language,
datastream_revision_id=datastream_revision_id,
published=False)
except DataStreamRevision.DoesNotExist:
raise DataStreamNotFoundException()
return render_to_response(
'createVisualization/index.html',
dict(request=request, datastream_revision=datastream_rev))
elif request.method == 'POST':
""" save new or update dataset """
# Valido que llegue el ID de la revision del datastream
datastream_rev_id = request.GET.get('datastream_revision_id', None)
if not datastream_rev_id:
raise Http404
datastream_rev = DataStreamRevision.objects.get(pk=datastream_rev_id)
# 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()))
response = form.save(request, datastream_rev=datastream_rev)
return JSONHttpResponse(json.dumps(response))
def create(request):
auth_manager = request.auth_manager
if request.method == 'POST':
""" save new or update dataset """
form = CreateDataStreamForm(request.POST)
if not form.is_valid():
raise DatastreamSaveException('Invalid form data: %s' % str(form.errors.as_text()))
dataset_revision = DatasetRevision.objects.get(pk=form.cleaned_data['dataset_revision_id'])
dataview = DatastreamLifeCycleManager(user=request.user)
dataview.create(
dataset=dataset_revision.dataset,
language=request.auth_manager.language,
category_id=form.cleaned_data['category'],
**form.cleaned_data
)
response = dict(
status='ok',
datastream_revision_id=dataview.datastream_revision.id,
messages=[ugettext('APP-DATASET-CREATEDSUCCESSFULLY-TEXT')]
)
return JSONHttpResponse(json.dumps(response))
elif request.method == 'GET':
form = InitalizeCollectForm(request.GET)
if form.is_valid():
is_update = False
is_update_selection = False
data_set_id = form.cleaned_data['dataset_revision_id']
datastream_id = None
if auth_manager.is_level('level_5'):
meta_data = Account.objects.get(pk=auth_manager.account_id).meta_data
try:
dataset_revision = DatasetRevision.objects.get(pk=data_set_id)
except DatasetRevision.DoesNotExist:
raise DatasetNotFoundException()
end_point = dataset_revision.end_point
type = dataset_revision.dataset.type
impl_type = dataset_revision.impl_type
impl_details = dataset_revision.impl_details
bucket_name = request.bucket_name
return render_to_response('view_manager/insertForm.html', locals())
else:
raise Http404
def remove(request, visualization_revision_id, type="resource"):
""" remove resource
:param type:
:param visualization_revision_id:
:param request:
"""
lifecycle = VisualizationLifeCycleManager(
user=request.user, visualization_revision_id=visualization_revision_id)
if type == 'revision':
lifecycle.remove()
# si quedan revisiones, redirect a la ultima revision, si no quedan, redirect a la lista.
if lifecycle.visualization.last_revision_id:
last_revision_id = lifecycle.visualization.last_revision_id
else:
last_revision_id = -1
# Send signal
visualization_rev_removed.send_robust(sender='remove_view',
id=lifecycle.visualization.id,
rev_id=visualization_revision_id)
return JSONHttpResponse(
json.dumps({
'status':
True,
'messages':
[ugettext('APP-DELETE-VISUALIZATION-REV-ACTION-TEXT')],
'revision_id':
last_revision_id
}))
else:
lifecycle.remove(killemall=True)
# Send signal
visualization_removed.send_robust(
sender='remove_view',
id=lifecycle.visualization.id,
rev_id=lifecycle.visualization_revision.id)
return HttpResponse(json.dumps({
'status':
True,
'messages': [ugettext('APP-DELETE-VISUALIZATION-ACTION-TEXT')],
'revision_id':
-1,
}),
content_type='text/plain')
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))
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['datastream__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(
'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 sort_by:
if sort_by == "title":
sort_by = "datastreami18n__title"
elif sort_by == "dataset_title":
sort_by = "dataset__last_revision__dataseti18n__title"
elif sort_by == "author":
sort_by = "datastream__user__nick"
if order == "desc":
sort_by = "-" + sort_by
else:
# no se por que setea un orden de este tipo si no
# se envia el parametro
sort_by = '-id'
total_resources = request.stats['account_total_datastreams']
resources, total_entries = DataStreamDBDAO().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('manageDataviews.view',
urlconf='workspace.urls',
kwargs={'revision_id': resource['id']})
resource['dataset_url'] = reverse(
'manageDatasets.view',
urlconf='workspace.urls',
kwargs={'revision_id': resource['dataset__last_revision__id']})
data = {
'total_entries': total_entries,
'total_resources': total_resources,
'resources': resources,
'total_entries': total_entries
}
response = DatastreamList().render(data)
return JSONHttpResponse(response)
def create(request):
auth_manager = request.auth_manager
if request.method == 'POST':
""" save new or update dataset """
form = CreateDataStreamForm(request.POST)
if not form.is_valid():
raise DatastreamSaveException(form)
dataset_revision = DatasetRevision.objects.get(
pk=form.cleaned_data['dataset_revision_id'])
dataview = DatastreamLifeCycleManager(user=request.user)
dataview.create(dataset=dataset_revision.dataset,
language=request.auth_manager.language,
category_id=form.cleaned_data['category'],
**form.cleaned_data)
response = dict(
status='ok',
datastream_revision_id=dataview.datastream_revision.id,
messages=[ugettext('APP-DATASET-CREATEDSUCCESSFULLY-TEXT')])
return JSONHttpResponse(json.dumps(response))
elif request.method == 'GET':
form = InitalizeCollectForm(request.GET)
if form.is_valid():
is_update = False
is_update_selection = False
data_set_id = form.cleaned_data['dataset_revision_id']
datastream_id = None
if auth_manager.is_level('level_5'):
meta_data = Account.objects.get(
pk=auth_manager.account_id).meta_data
try:
dataset_revision = DatasetRevision.objects.get(pk=data_set_id)
except DatasetRevision.DoesNotExist:
raise DatasetNotFoundException()
end_point = dataset_revision.end_point
type = dataset_revision.dataset.type
impl_type = dataset_revision.impl_type
impl_details = dataset_revision.impl_details
bucket_name = request.bucket_name
categoriesQuery = CategoryI18n.objects\
.filter(language=request.auth_manager.language,
category__account=request.auth_manager.account_id)\
.values('category__id', 'name')
categories = [[category['category__id'], category['name']]
for category in categoriesQuery]
preferences = auth_manager.get_account().get_preferences()
try:
default_category = int(preferences['account.default.category'])
except:
default_category = categories[0][0]
# Agregar categoria por defecto
categories = map(lambda x: x + [int(x[0]) == default_category],
categories)
sources = [source for source in dataset_revision.get_sources()]
tags = [tag for tag in dataset_revision.get_tags()]
return render_to_response('createDataview/index.html', locals())
else:
raise Http404
def edit(request, datastream_revision_id=None):
lifecycle = DatastreamLifeCycleManager(
user=request.user, datastream_revision_id=datastream_revision_id)
dao = DataStreamDBDAO().get(request.user,
datastream_revision_id=datastream_revision_id)
auth_manager = request.auth_manager
if request.method == 'GET':
is_update = True
is_update_selection = True
dataset_revision = Dataset.objects.get(
id=dao['dataset_id']).last_revision
datastream_id = None
if auth_manager.is_level('level_5'):
meta_data = Account.objects.get(
pk=auth_manager.account_id).meta_data
end_point = dataset_revision.end_point
type = dataset_revision.dataset.type
impl_type = dataset_revision.impl_type
impl_details = dataset_revision.impl_details
bucket_name = request.bucket_name
categoriesQuery = CategoryI18n.objects\
.filter(language=request.auth_manager.language,
category__account=request.auth_manager.account_id)\
.values('category__id', 'name')
categories = [[category['category__id'], category['name']]
for category in categoriesQuery]
preferences = auth_manager.get_account().get_preferences()
try:
default_category = int(preferences['account.default.category'])
except:
default_category = categories[0][0]
# Agregar categoria por defecto
categories = map(lambda x: x + [int(x[0]) == default_category],
categories)
sources = [source for source in dataset_revision.get_sources()]
tags = [tag for tag in dataset_revision.get_tags()]
return render_to_response('createDataview/index.html', locals())
elif request.method == 'POST':
"""update dataset """
form = EditDataStreamForm(request.POST)
if not form.is_valid():
raise DatastreamSaveException(form)
if form.is_valid():
lifecycle = DatastreamLifeCycleManager(
user=request.user,
datastream_revision_id=datastream_revision_id)
lifecycle.edit(language=request.auth_manager.language,
changed_fields=form.changed_data,
**form.cleaned_data)
# Signal
datastream_changed.send_robust(
sender='edit_view',
id=lifecycle.datastream.id,
rev_id=lifecycle.datastream_revision.id)
response = dict(
status='ok',
datastream_revision_id=lifecycle.datastream_revision.id,
messages=[ugettext('APP-DATASET-CREATEDSUCCESSFULLY-TEXT')],
)
return JSONHttpResponse(json.dumps(response))
