def unpublish(request, datastream_revision_id, type="resource"):
""" unpublish resource """
lifecycle = DatastreamLifeCycleManager(user=request.user, datastream_revision_id=datastream_revision_id)
if type == 'revision':
lifecycle.unpublish()
# si quedan revisiones, redirect a la ultima revision, si no quedan, redirect a la lista.
if lifecycle.dataset.last_revision_id:
last_revision_id = lifecycle.datastream.last_revision_id
else:
last_revision_id = -1
return JSONHttpResponse(json.dumps({
'status': True,
'messages': [ugettext('APP-UNPUBLISH-DATASTREAM-REV-ACTION-TEXT')],
'revision_id': last_revision_id,
}))
else:
lifecycle.unpublish(killemall=True)
return HttpResponse(json.dumps({
'status': True,
'messages': [ugettext('APP-UNPUBLISH-DATASTREAM-ACTION-TEXT')],
'revision_id': -1,
}), content_type='text/plain')
def view(request, revision_id):
language = request.auth_manager.language
try:
datastream = DataStreamDBDAO().get(request.user,
datastream_revision_id=revision_id,
published=False)
except DataStreamRevision.DoesNotExist:
raise DataStreamNotFoundException()
account_id = request.auth_manager.account_id
credentials = request.auth_manager
categories = CategoryI18n.objects.filter(
language=language,
category__account=account_id).values('category__id', 'name')
status_options = credentials.get_allowed_actions()
try:
lifecycle = DatastreamLifeCycleManager(
user=request.user, datastream_revision_id=revision_id)
datastream[
'can_publish_bof_children'] = lifecycle.can_publish_bof_children()
except Exception as e:
pass
return render_to_response('viewDataStream/index.html', locals())
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'],
parameters=[], #TODO: Add parameters to UI
**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 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 update(self, instance, validated_data):
lcycle = DatastreamLifeCycleManager(self.context['request'].user,
datastream_id=instance['datastream_id'])
instance.update(validated_data)
instance.pop('datastream', None)
instance.pop('dataset', None)
instance.pop('user', None)
instance.pop('status', None)
instance.pop('parameters', None)
if 'category' not in instance:
instance['category'] = instance['category_id']
return self.getDao(lcycle.edit(changed_fields=validated_data.keys(),
**instance))
def update(self, instance, validated_data):
lcycle = DatastreamLifeCycleManager(
self.context['request'].user,
datastream_id=instance['datastream_id'])
instance.update(validated_data)
instance.pop('datastream', None)
instance.pop('dataset', None)
instance.pop('user', None)
instance.pop('status', None)
instance.pop('parameters', None)
if 'category' not in instance:
instance['category'] = instance['category_id']
return self.getDao(
lcycle.edit(changed_fields=validated_data.keys(), **instance))
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
response = DefaultDataViewEdit(template='datastream_edit_response.json').render(
categories, status,
status_options,
lifecycle.datastream_revision,
lifecycle.datastreami18n
)
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 create(self, validated_data):
if 'dataset' not in validated_data:
raise exceptions.ValidationError({'dataset': 'No hay dataset'})
return self.getDao(
DatastreamLifeCycleManager(
self.context['request'].user).create(**validated_data))
def handle(self, *args, **options):
# OH SI, Hardcodeo el idioma
# en realidad deberia cambiar el loc
for dataset_rev in DatasetRevision.objects.all():
try:
translation.activate(dataset_rev.user.language)
lifecycle = DatasetLifeCycleManager(
dataset_rev.user, dataset_revision_id=dataset_rev.id)
lifecycle._log_activity(ActionStreams.CREATE)
except:
pass
finally:
translation.deactivate()
for datastream_rev in DataStreamRevision.objects.all():
try:
translation.activate(datastream_rev.user.language)
lifecycle = DatastreamLifeCycleManager(
datastream_rev.user,
datastream_revision_id=datastream_rev.id)
lifecycle._log_activity(ActionStreams.CREATE)
except:
pass
finally:
translation.deactivate()
def clone(self, request, *args, **kwargs):
instance = self.get_object()
dsr = DatastreamLifeCycleManager(
request.user, datastream_id=instance['datastream_id']).clone()
dsdao = DataStreamDBDAO().get(user=request.user,
datastream_revision_id=dsr.id,
published=False)
serializer = self.get_serializer(dsdao)
return Response(serializer.data)
def remove(request, datastream_revision_id, type="resource"):
""" remove resource
:param type:
:param datastream_revision_id:
:param request:
"""
lifecycle = DatastreamLifeCycleManager(user=request.user, datastream_revision_id=datastream_revision_id)
if type == 'revision':
lifecycle.remove()
# si quedan revisiones, redirect a la ultima revision, si no quedan, redirect a la lista.
if lifecycle.datastream.last_revision_id:
last_revision_id = lifecycle.datastream.last_revision.id
else:
last_revision_id = -1
# Send signal
datastream_rev_removed.send_robust(sender='remove_view', id=lifecycle.datastream.id,
rev_id=datastream_revision_id)
return JSONHttpResponse(json.dumps({
'status': True,
'messages': [ugettext('APP-DELETE-DATASTREAM-REV-ACTION-TEXT')],
'revision_id': last_revision_id,
}))
else:
lifecycle.remove(killemall=True)
# Send signal
datastream_removed.send_robust(sender='remove_view', id=lifecycle.datastream.id,
rev_id=lifecycle.datastream_revision.id)
return HttpResponse(json.dumps({
'status': True,
'messages': [ugettext('APP-DELETE-DATASTREAM-ACTION-TEXT')],
'revision_id': -1,
}), content_type='text/plain')
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 _wrapped_view(request, *args, **kwargs):
# check for new status
if request.POST.get('status', StatusChoices.DRAFT) == StatusChoices.PUBLISHED:
# new status is published the check the related resource
if request.POST.get('dataset_revision_id', False):
dataset_revision_id=request.POST['dataset_revision_id']
resource = DatasetLifeCycleManager(user = request.user.id, dataset_revision_id=dataset_revision_id)
if resource.dataset_revision.status != StatusChoices.PUBLISHED:
raise DatastreamParentNotPublishedException(resource.dataset_revision)
elif request.POST.get('datastream_revision_id', False):
datastream_revision_id=request.POST['datastream_revision_id']
resource = DatastreamLifeCycleManager(user = request.user.id, resource_revision_id=datastream_revision_id)
if resource.dataset_revision.status != StatusChoices.PUBLISHED:
raise VisualizationParentNotPublishedException(resource.dataset_revision)
else:
raise ParentNotPublishedException()
return view_func(request, *args, **kwargs)
def remove(request, datastream_revision_id, type="resource"):
""" remove resource
:param type:
:param datastream_revision_id:
:param request:
"""
lifecycle = DatastreamLifeCycleManager(
user=request.user, datastream_revision_id=datastream_revision_id)
resource_id = lifecycle.datastream.id
if type == 'revision':
lifecycle.remove()
# si quedan revisiones, redirect a la ultima revision, si no quedan, redirect a la lista.
if lifecycle.datastream.last_revision_id:
last_revision_id = lifecycle.datastream.last_revision.id
else:
last_revision_id = -1
# Send signal
datastream_removed.send_robust(sender='remove_view',
id=resource_id,
rev_id=datastream_revision_id)
return JSONHttpResponse(
json.dumps({
'status':
True,
'messages':
[ugettext('APP-DELETE-DATASTREAM-REV-ACTION-TEXT')],
'revision_id':
last_revision_id,
}))
else:
lifecycle.remove(killemall=True)
# Send signal
datastream_removed.send_robust(sender='remove_view',
id=lifecycle.datastream.id,
rev_id=-1)
return HttpResponse(json.dumps({
'status':
True,
'messages': [ugettext('APP-DELETE-DATASTREAM-ACTION-TEXT')],
'revision_id':
-1,
}),
content_type='text/plain')
def change_status(request, datastream_revision_id=None):
"""
Change dataview status
:param request:
:param datastream_revision_id:
:return: JSON Object
"""
if request.method == 'POST' and datastream_revision_id:
lifecycle = DatastreamLifeCycleManager(
user=request.user,
datastream_revision_id=datastream_revision_id
)
action = request.POST.get('action')
if action == 'approve':
lifecycle.accept()
# Signal
datastream_changed.send_robust(sender='change_status_view', id=lifecycle.datastream.id)
response = dict(
status='ok',
messages={
'title': ugettext('APP-DATAVIEW-APPROVED-TITLE'),
'description': ugettext('APP-DATAVIEW-APPROVED-TEXT')
}
)
elif action == 'reject':
lifecycle.reject()
# Signal
datastream_changed.send_robust(sender='change_status_view', id=lifecycle.datastream.id)
response = dict(
status='ok',
messages={
'title': ugettext('APP-DATAVIEW-REJECTED-TITLE'),
'description': ugettext('APP-DATAVIEW-REJECTED-TEXT')
}
)
elif action == 'publish':
lifecycle.publish()
# Signal
datastream_changed.send_robust(sender='change_status_view', id=lifecycle.datastream.id)
response = dict(
status='ok',
messages={
'title': ugettext('APP-DATAVIEW-PUBLISHED-TITLE'),
'description': ugettext('APP-DATAVIEW-PUBLISHED-TEXT')
}
)
elif action == 'unpublish':
killemall = True if request.POST.get('killemall', False) == 'true' else False
lifecycle.unpublish(killemall=killemall)
if killemall:
description = ugettext('APP-DATAVIEW-UNPUBLISHALL-TEXT')
else:
description = ugettext('APP-DATAVIEW-UNPUBLISH-TEXT')
# Signal
datastream_changed.send_robust(sender='change_status_view', id=lifecycle.datastream.id)
datastream_unpublished.send_robust(sender='change_status_view', id=lifecycle.datastream.id)
response = dict(
status='ok',
messages={
'title': ugettext('APP-DATAVIEW-UNPUBLISH-TITLE'),
'description': description
}
)
elif action == 'send_to_review':
lifecycle.send_to_review()
# Signal
datastream_changed.send_robust(sender='change_status_view', id=lifecycle.datastream.id)
response = dict(
status='ok',
messages={
'title': ugettext('APP-DATAVIEW-SENDTOREVIEW-TITLE'),
'description': ugettext('APP-DATAVIEW-SENDTOREVIEW-TEXT')
}
)
else:
raise NoStatusProvidedException()
# Limpio un poco
response['result'] = DataStreamDBDAO().get(request.user.language, datastream_revision_id=datastream_revision_id)
response['result'].pop('parameters')
response['result'].pop('tags')
response['result'].pop('sources')
return JSONHttpResponse(json.dumps(response, cls=DateTimeEncoder))
def change_status(request, datastream_revision_id=None):
"""
Change dataview status
:param request:
:param datastream_revision_id:
:return: JSON Object
"""
if datastream_revision_id:
lifecycle = DatastreamLifeCycleManager(
user=request.user, datastream_revision_id=datastream_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
datastream_unpublished.send_robust(
sender='change_status_view',
id=lifecycle.datastream.id,
rev_id=lifecycle.datastream_revision.id)
else:
getattr(lifecycle, action)()
if action == 'accept':
title = ugettext('APP-DATAVIEW-APPROVED-TITLE'),
description = ugettext('APP-DATAVIEW-APPROVED-TEXT')
elif action == 'reject':
title = ugettext('APP-DATAVIEW-REJECTED-TITLE'),
description = ugettext('APP-DATAVIEW-REJECTED-TEXT')
elif action == 'publish':
title = ugettext('APP-DATAVIEW-PUBLISHED-TITLE'),
description = ugettext('APP-DATAVIEW-PUBLISHED-TEXT')
elif action == 'unpublish':
if killemall:
description = ugettext('APP-DATAVIEW-UNPUBLISHALL-TEXT')
else:
description = ugettext('APP-DATAVIEW-UNPUBLISH-TEXT')
title = ugettext('APP-DATAVIEW-UNPUBLISH-TITLE'),
elif action == 'send_to_review':
title = ugettext('APP-DATAVIEW-SENDTOREVIEW-TITLE'),
description = ugettext('APP-DATAVIEW-SENDTOREVIEW-TEXT')
response = dict(status='ok',
messages={
'title': title,
'description': description
})
# Limpio un poco
response['result'] = DataStreamDBDAO().get(
request.user, datastream_revision_id=datastream_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(
'viewDataStream.view',
urlconf='microsites.urls',
kwargs={
'id': response['result']['datastream_id'],
'slug': '-'
})
response['result'].pop('parameters')
response['result'].pop('tags')
response['result'].pop('sources')
return JSONHttpResponse(json.dumps(response, cls=DateTimeEncoder))
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 change_status(request, datastream_revision_id=None):
"""
Change dataview status
:param request:
:param datastream_revision_id:
:return: JSON Object
"""
if request.method == 'POST' and datastream_revision_id:
lifecycle = DatastreamLifeCycleManager(
user=request.user,
datastream_revision_id=datastream_revision_id
)
action = request.POST.get('action')
if action == 'approve':
lifecycle.accept()
response = dict(
status='ok',
datastream_status=StatusChoices.APPROVED,
messages={
'title': ugettext('APP-DATAVIEW-APPROVED-TITLE'),
'description': ugettext('APP-DATAVIEW-APPROVED-TEXT')
}
)
elif action == 'reject':
lifecycle.reject()
response = dict(
status='ok',
datastream_status=StatusChoices.DRAFT,
messages={
'title': ugettext('APP-DATAVIEW-REJECTED-TITLE'),
'description': ugettext('APP-DATAVIEW-REJECTED-TEXT')
}
)
elif action == 'publish':
lifecycle.publish()
response = dict(
status='ok',
datastream_status=StatusChoices.PUBLISHED,
messages={
'title': ugettext('APP-DATAVIEW-PUBLISHED-TITLE'),
'description': ugettext('APP-DATAVIEW-PUBLISHED-TEXT')
}
)
elif action == 'unpublish':
lifecycle.unpublish()
response = dict(
status='ok',
datastream_status=StatusChoices.DRAFT,
messages={
'title': ugettext('APP-DATAVIEW-UNPUBLISH-TITLE'),
'description': ugettext('APP-DATAVIEW-UNPUBLISH-TEXT')
}
)
elif action == 'send_to_review':
lifecycle.send_to_review()
response = dict(
status='ok',
datastream_status=StatusChoices.PENDING_REVIEW,
messages={
'title': ugettext('APP-DATAVIEW-SENDTOREVIEW-TITLE'),
'description': ugettext('APP-DATAVIEW-SENDTOREVIEW-TEXT')
}
)
else:
raise NoStatusProvidedException()
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(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))
