def report_jm(request):
template = 'report/jm.html'
data = models.Orders.objects.all()
today = datetime.now().date()
if request.GET.get('order_date'):
d_range = request.GET.get('order_date')
start_date = d_range[:10]
end_date = d_range[13:23]
else:
start_date = today
end_date = today
data = data.filter(order_date__range=[start_date, end_date])
filter = filters.JMFilter(request.GET, queryset=data)
orderstable = JMTable(data)
orderstable.paginate(page=request.GET.get('page', 1), per_page=10)
RequestConfig(request).configure(orderstable)
export_format = request.GET.get('_export', None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, orderstable)
return exporter.response('table.{}'.format(export_format))
context = {'orderstable': orderstable, 'filter': filter}
return render(request, template, context)
def report_origin(request):
template = 'report/origin.html'
data = models.Orders.objects.values('origin__name').annotate(
Count('number')).order_by()
if request.GET.get('order_date'):
d_range = request.GET.get('order_date')
#04/01/2018 - 04/30/2018
start_date = d_range[:10]
end_date = d_range[13:23]
data = data.filter(order_date__range=[start_date, end_date])
filter = filters.OriginFilter(request.GET, queryset=data)
orderstable = OriginTable(data)
orderstable.paginate(page=request.GET.get('page', 1), per_page=10)
RequestConfig(request).configure(orderstable)
export_format = request.GET.get('_export', None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, orderstable)
return exporter.response('table.{}'.format(export_format))
context = {'orderstable': orderstable, 'filter': filter}
return render(request, template, context)
def change_view(self, request, object_id=None, extra_context=None):
if not object_id:
return render(request, 'access_denied.html')
object = report_models.GeneratedReport.objects.get(pk=object_id)
if not object:
return render(request, 'access_denied.html')
query_string = object.sql
result = self.__execute_query(query_string)
if result:
table_class = get_table_class(result[0])
table = table_class(result)
table.export_formats = ['xls']
RequestConfig(request).configure(table)
export_format = request.GET.get('_export', None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, table)
return exporter.response('table.{}'.format(export_format))
form = ReportForm(instance=object, prefix="report")
extra_context = {
'result': table,
'form': form,
'id': object_id,
'request': request,
'report': object
}
return super().change_view(request,
object_id,
extra_context=extra_context)
def cursos(request, sort='inicio_fecha'):
if request.user.is_authenticated:
CURSOS = Curso.objects.all()
futuros = CURSOS.filter(
inicio_fecha__gte = timezone.now()
).order_by(sort)
pasados = CURSOS.filter(
inicio_fecha__lte = timezone.now() - timezone.timedelta(days=1)
).order_by(sort)
vigentes = {}
vigentes['titulo'] = 'Cursos'
vigentes['subtitulo'] = 'Vigentes'
vigentes['items'] = CursosTable( futuros )
vigentes['botones'] = [
{'texto':'descargar CSV ','destino':'.?export=csv&tabla=0', },
{'texto':'descargar XLS ','destino':'.?export=xls&tabla=0', },
]
anteriores = {}
anteriores['titulo'] = 'Cursos'
anteriores['subtitulo'] = 'Anteriores'
anteriores['items'] = CursosTable( pasados )
anteriores['botones'] = [
{'texto':'descargar CSV ','destino':'.?export=csv&tabla=1', },
{'texto':'descargar XLS ','destino':'.?export=xls&tabla=1', },
]
TABLAS = [
vigentes,
anteriores,
]
if request.method == 'GET' and 'export' in request.GET and 'tabla' in request.GET:
n_tabla = int(request.GET['tabla'])
tabla = TABLAS[n_tabla]['items']
titulo = TABLAS[n_tabla]['titulo'] + '_' + TABLAS[n_tabla]['subtitulo']
RequestConfig( request ).configure( tabla )
export_format = request.GET['export']
if TableExport.is_valid_format( export_format ):
exporter = TableExport( export_format, tabla)
return exporter.response( titulo.lower().replace(" ","_") +'.{}'.format( export_format ) )
return render(
request,
'multitabla.html',
{
'titulo':'Todos los Cursos',
'bajada':'eo',
'botones': [
{'texto':'Nuevo Curso','destino':'/gestion/curso/nuevo','clase':'btn-success'},
{'texto':'Nuevo Docente','destino':'/admin/gestion/user/add/ ','clase':'btn-success boton'}
],
'tablas':TABLAS
}
)
else:
return HttpResponseRedirect('/admin/login/?next=%s' % request.path)
def DetailFiltered(request):
## if not request.user.is_authenticated:
## return redirect('%s?next=%s' % (settings.LOGIN_URL, request.path))
data = ModelClassName.objects.all()
filter = CurrentFilter(request.GET, queryset=data)
table = CurrentTable(filter.qs)
export_format = request.GET.get("_export", None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format,
table,
exclude_columns=("detail", ))
return exporter.response("table.{}".format(export_format))
RequestConfig(request, paginate={
'per_page': Rows_Per_Page
}).configure(table)
return render(
request, 'General/Generic_Table_view_filter_panel.html', {
'objects': table,
'filter': filter,
'page_title': PageTitle,
'form_name': FormName,
})
def DetailFiltered(request):
data = ModelClassName.objects.all()
filter = CurrentFilter(request.GET, queryset=data)
table = CurrentTable(filter.qs)
export_format = request.GET.get("_export", None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format,
table,
exclude_columns=('detail', 'detailed'))
return exporter.response("table.{}".format(export_format))
RequestConfig(request, paginate={
'per_page': Rows_Per_Page
}).configure(table)
return render(
request,
'General/Generic_Table_view_filter_panel.html',
{
'objects': table,
'filter': filter,
'page_title': PageTitle,
'form_name': FormName, #})
'param_action1_name': AltComName,
'param_action1': reverse(PathStart + AltComAction),
})
def transient_query(request):
transients = Transients.objects.all()
transients_filter = TransientFilter(request.GET, queryset=transients)
table = TransientQueryTable(transients_filter.qs)
#save the queryset IDs to the session
query_ids = [t.id for t in transients_filter.qs]
request.session['query_ids'] = query_ids
user = request.user
user_id = user.id
#Have to be logged in to submit a category and to own the image
if user.is_authenticated():
the_url = request.build_absolute_uri()
if "?" in the_url:
query_string = the_url.split("?")
user_obj = User.objects.get(pk=user_id)
user_obj.profile.last_query = query_string[-1]
user_obj.save()
RequestConfig(request).configure(table)
export_format = request.GET.get('_export', None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, table)
return exporter.response('query_result.{}'.format(export_format))
return render(request, 'transients_list.html', {
'filter': transients_filter,
'table': table
})
def survey_query(request, survey_name, query_name):
# username = None
mymodel = apps.get_model('bns', query_name)
class myTable(tables.Table):
name = mymodel.table_name
class Meta:
model = mymodel
template_name = 'bootstrap.html'
class myFilter(django_filters.FilterSet):
class Meta:
model = mymodel
fields = mymodel.filter_fields
queryset = mymodel.objects.filter(dataset_uuid__dataset_name=survey_name)
filter = myFilter(request.GET, queryset=queryset)
table = myTable(filter.qs)
RequestConfig(request).configure(table)
export_format = request.GET.get('_export', None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, table)
return exporter.response('{}.{}'.format(mymodel.table_name, export_format))
table.paginate(page=request.GET.get('page', 1), per_page=request.GET.get('per_page', 10))
table.export_formats = ['csv', 'xls', 'json', 'tsv']
return render(request, 'bns_survey_query.html', {'table': table, 'filter': filter, 'survey_name': survey_name})
def transients(request, pk, transient_filter):
image = Image.objects.get(pk=pk)
if transient_filter == "all":
transient_sources = Transients.objects.all().filter(
image_id=pk).order_by("id")
table = TransientTableAll(transient_sources)
total = image.transients_master_total
elif transient_filter == "flagged":
transient_sources = Transients.objects.all().filter(
image_id=pk).exclude(pipelinetag="Candidate").filter(
ratio__gte=2.0).order_by("id")
table = TransientTable(transient_sources)
total = image.transients_master_flagged_total
else:
transient_sources = Transients.objects.all().filter(
image_id=pk).filter(pipelinetag="Candidate").filter(
ratio__gte=2.0).order_by("id")
table = TransientTable(transient_sources)
total = image.transients_master_candidates_total
RequestConfig(request, paginate={'per_page': 100}).configure(table)
export_format = request.GET.get('_export', None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, table)
return exporter.response('transients_image{}.{}'.format(
pk, export_format))
return render(
request, 'transients.html', {
'transient_sources': transient_sources,
'image': image,
"table": table,
"querytype": "transients",
"total": total,
"view_type": transient_filter
})
def rawdata_list(request):
table = RawdataTable(Post.objects.all(), order_by="-id")
RequestConfig(request).configure(table)
export_format = request.GET.get('_export', None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, table)
return exporter.response('table.{}'.format(export_format))
return render(request, 'rawdata/rawdata_list.html', {'table': table})
def data_management_view(request):
table = Berita_Tabel(Tabel_Berita.objects.filter(user_id=request.user))
RequestConfig(request, paginate={'per_page': 10}).configure(table)
export_format = request.GET.get('_export', None)
pks = request.GET.getlist('amend')
#mengecek tombol mana yang dipilih user
if 'delete' in request.GET:
sel = Tabel_Berita.objects.filter(pk__in=pks)
sel.delete()
if 'mind_map' in request.GET:
maps = Tabel_Berita.objects.filter(pk__in=pks)
list1 = []
for row in maps:
list1.append({
'judul_berita': row.judul_berita,
'konten_berita': row.konten_berita
})
return render(request, 'crawling_mindmap.html', {'list_news1': list1})
if 'summarizer' in request.GET:
maps = Tabel_Berita.objects.filter(pk__in=pks)
list1 = []
for row in maps:
list1.append({
'judul_berita': row.judul_berita,
'konten_berita': row.konten_berita
})
return render(request, 'crawling_summarizer.html',
{'list_news1': list1})
if 'preprocess' in request.GET:
mapss = Tabel_Berita.objects.filter(pk__in=pks)
list2 = []
for row in mapss:
list2.append({
'id_berita': row.id_berita,
'judul_berita': row.judul_berita,
'konten_berita': row.konten_berita
})
return render(request, 'crawling_preprocess.html',
{'list_news1': list2})
if 'word_cloud' in request.GET:
vis = Tabel_Berita.objects.filter(pk__in=pks)
viss = []
for row in vis:
viss.append({'konten_berita': row.konten_berita})
return render(request, 'wordcloud_universal.html',
{'list_news1': viss})
selected = Berita_Tabel(Tabel_Berita.objects.filter(pk__in=pks))
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format,
selected,
exclude_columns=('amend', 'user_id',
'id_berita'))
return exporter.response('table.{}'.format(export_format))
return render(request, 'data_management.html', {'table': table})
def capture_list(request):
table = CapturesTable(RawCapture.objects.all())
export_format = request.GET.get('_export', None)
RequestConfig(request, paginate={'per_page': 25}).configure(table)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, table)
return exporter.response('table.{}'.format(export_format))
return render(request, 'capture_list.html', {'table': table})
def table_view(request):
table = Table(Person.objects.all())
RequestConfig(request).configure(table)
export_format = request.GET.get("_export", None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, table)
return exporter.response("table.{}".format(export_format))
return render(request, "django_tables2/table.html", {"table": table})
def test_None_values(self):
table = Table(
[
{"first_name": "Yildiz", "last_name": "van der Kuil"},
{"first_name": "Jan", "last_name": None},
]
)
exporter = TableExport("csv", table)
expected = ("First name,Last name", "Yildiz,van der Kuil", "Jan,")
self.assertEqual(exporter.export(), CSV_SEP.join(expected) + CSV_SEP)
def as_tablib_databook(report, parent_context):
render_context = _report(report, parent_context)
databook = Databook()
for element in render_context["elements"].values():
dataset = TableExport(TableExport.XLSX, element["table"]).dataset
dataset.title = element["title"][:31]
databook.add_sheet(dataset)
return databook
def biblios_table_export_view(request):
table = BiblioTable(Biblio.objects.all())
table.export_formats = {'csv','json','latex', 'ods', 'tsv', 'xls', 'xlsx', 'yml'}
RequestConfig(request).configure(table)
export_format = request.GET.get('_export', None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, table, exclude_columns=('selection','biblio'))
return exporter.response('bibliostable.{}'.format(export_format))
return render(request, 'tutorial/biblios_export.html', {
'table': table
})
def borrowers_table_export_view(request):
table = BorrowersTable(Borrowers.objects.all())
table.export_formats = {'csv','json','latex', 'ods', 'tsv', 'xls', 'xlsx', 'yml'}
RequestConfig(request).configure(table)
export_format = request.GET.get('_export', None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, table, exclude_columns=('selection','patron','photo'))
return exporter.response('borrowerstable.{}'.format(export_format))
return render(request, 'intranet/borrowers_export.html', {
'table': table
})
def generate_service_report(request):
if request.method == 'GET':
queryset = ResourcesUsage.objects.select_related().all()
f = ResourcesUsageFilter(request.GET, queryset=queryset)
table = AllServicesTable(f.qs)
export_format = request.GET.get('_export', None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, table)
return exporter.response('report.{}'.format(export_format))
def get(self, request):
table = self.table_class(self.table_class._meta.model.objects.all())
RequestConfig(request).configure(table)
export_format = "xlsx"
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, table)
return exporter.response(
f"{self.activity['short']}.{export_format}")
return render(request, f"{self.activity['short']}/filter_table.html", {
'activity': self.activity,
'export': True
})
def tracker_list(request):
table = TrackerTable(Post.objects.all(), order_by="-id")
#filter = AFilter(request.GET, queryset=table)
RequestConfig(request, paginate={'per_page': 100}).configure(table)
export_format = request.GET.get('_export', None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format,
table,
exclude_columns=('editable', 'selection'))
return exporter.response('table.{}'.format(export_format))
return render(request, 'posts/tracker_list.html', {'table': table})
def generate_clients_report(request):
if request.method == 'GET':
queryset = Client.objects.select_related().all()
f = ClientTableFilter(request.GET, queryset=queryset)
table = ClientTable(f.qs, order_by="last_name")
export_format = request.GET.get('_export', None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, table)
return exporter.response('report.{}'.format(export_format))
def updates_list(request):
table = UpdateTable(Update.objects.all(), order_by="-id")
#filter = AFilter(request.GET, queryset=table)
RequestConfig(request).configure(table)
export_format = request.GET.get('_export', None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format,
table,
exclude_columns=('editable', 'selection'))
return exporter.response('table.{}'.format(export_format))
return render(request, 'updates/updates_list.html', {'table': table})
def test_None_values(self):
table = Table([{
'first_name': 'Yildiz',
'last_name': 'van der Kuil'
}, {
'first_name': 'Jan',
'last_name': None
}])
exporter = TableExport('csv', table)
expected = ('First Name,Last Name', 'Yildiz,van der Kuil', 'Jan,')
self.assertEquals(exporter.export(), CSV_SEP.join(expected) + CSV_SEP)
def test_null_values(self):
Person.objects.create(first_name="Jan", last_name="Coen")
class Table(tables.Table):
first_name = tables.Column()
last_name = tables.Column(verbose_name="Last name")
occupation = tables.Column(verbose_name="Occupation")
table = Table(Person.objects.all())
exporter = TableExport("csv", table)
expected = ("First name,Last name,Occupation", "Jan,Coen,")
self.assertEqual(exporter.export(), CSV_SEP.join(expected) + CSV_SEP)
def test_null_values(self):
Person.objects.create(first_name='Jan', last_name='Coen')
class Table(tables.Table):
first_name = tables.Column()
last_name = tables.Column(verbose_name='Last Name')
occupation = tables.Column(verbose_name='Occupation')
table = Table(Person.objects.all())
exporter = TableExport('csv', table)
expected = ('First Name,Last Name,Occupation', 'Jan,Coen,')
self.assertEquals(exporter.export(), CSV_SEP.join(expected) + CSV_SEP)
def test_exporting_unicode_header(self):
unicode_header = "hé"
class Table(tables.Table):
name = tables.Column(verbose_name=unicode_header)
exporter = TableExport("csv", Table([]))
response = exporter.response()
self.assertEqual(response.getvalue().decode("utf8"), unicode_header + "\r\n")
exporter = TableExport("xls", Table([]))
# this would fail if the header contains unicode and string converstion is attempted.
exporter.export()
def generate_weakly_worker_services_report(request):
if request.method == 'GET':
request_worker = Worker.objects.get(user_login = request.user.id)
resources_usage = ResourcesUsage.objects.filter(worker = request_worker, start_timestamp__gte = datetime.date.today(), finish_timestamp__lte = datetime.date.today() + datetime.timedelta(days = 7))
table = AllServicesTable(resources_usage)
export_format = request.GET.get('_export', None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, table)
return exporter.response('weekly_report.{}'.format(export_format))
def inscriptosxcursos(request, sort='inicio_fecha'):
if request.user.is_authenticated:
queryset = Curso.objects.all().order_by(sort)
botones=[
{'texto':'descargar CSV ','destino':'.?export=csv' },
{'texto':'descargar XLS ','destino':'.?export=xls' },
]
CURSOS = []
for index, curso in enumerate(queryset):
c = {}
c['titulo'] = curso.nombre
docentes = ', '.join( [ d.get_full_name() for d in curso.docentes.all() ] )
c['subtitulo'] = docentes
c['codigo'] = curso.codigo
c['fecha'] = curso.inicio_fecha
INSCRIPTOS = []
inscriptos = curso.inscriptos
INSCRIPTOS = InscriptosXCursosTable(inscriptos)
c['items'] = INSCRIPTOS
c['botones'] = [
{'texto':'descargar CSV ','destino':'.?export=csv&tabla=' + str( index ), },
{'texto':'descargar XLS ','destino':'.?export=xls&tabla=' + str( index ), },
]
CURSOS.append(c)
if request.method == 'GET' and 'export' in request.GET and 'tabla' in request.GET:
n_tabla = int(request.GET['tabla'])
tabla = CURSOS[n_tabla]['items']
titulo = str(CURSOS[n_tabla]['codigo']) + '_' + str(CURSOS[n_tabla]['subtitulo'])
RequestConfig( request ).configure( tabla )
export_format = request.GET['export']
if TableExport.is_valid_format( export_format ):
exporter = TableExport( export_format, tabla)
return exporter.response( titulo.lower().replace(" ","_") +'.{}'.format( export_format ) )
return render(
request,
'multitabla.html',
{
'titulo':'Inscriptos a cada curso',
'tablas':CURSOS,
#'botones': [{'texto':'PRUEBA ','destino':'/gestion/curso/nuevo','clase':'btn-success'}],
}
)
else:
return HttpResponseRedirect('/admin/login/?next=%s' % request.path)
def samples(request):
queryset=Sample.objects.select_related().all()
data = request.GET.copy()
#if 'status' not in data:
#data['status'] = 'Ready'
f = SampleFilter(data,queryset=queryset)
table = SampleTable(f.qs)
RequestConfig(request).configure(table)
export_format = request.GET.get('_export', None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, table)
return exporter.response('table.{}'.format(export_format))
return render(request, 'samples.html', {'table': table, 'filter':f})
def record(request):
table = UserTable(UserInfo.objects.all())
RequestConfig(request).configure(table)
export_formats = request.GET.get('_export', None)
CONTEXT = {
'table': UserInfo.objects.all(),
'page': table,
'export_format': export_formats
}
if TableExport.is_valid_format(export_formats):
exporter = TableExport(export_formats, table)
return exporter.response('table.{}'.format(export_formats))
return render(request, 'coop/record.html', context=CONTEXT)
def InventoryTable(request):
queryset = Genotypes.objects.all()
f = GenoFilter(request.GET, queryset=queryset)
table = GenotypesTable(f.qs)
RequestConfig(request, paginate={'per_page': 25}).configure(table)
export_format = request.GET.get('_export', None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, table)
return exporter.response('table.{}'.format(export_format))
return render(request, 'Inventory/index.html', {
'table': table,
'filter': f,
})
def test_export_accessors_queryset(self):
programmer = Occupation.objects.create(name="Programmer")
for first_name, last_name in NAMES:
Person.objects.create(first_name=first_name, last_name=last_name, occupation=programmer)
class AccessorRelationTable(AccessorTable):
occupation = tables.Column(
accessor=tables.A("occupation.name"), verbose_name="Occupation"
)
table = AccessorRelationTable(Person.objects.all())
exporter = TableExport("csv", table)
expected = ("Given name,Surname,Occupation",) + tuple(
row + "," + programmer.name for row in EXPECTED_CSV_DATA
)
self.assertEqual(exporter.export(), CSV_SEP.join(expected) + CSV_SEP)
def test_export_accessors_list_of_dicts(self):
table = AccessorTable(NAMES_LIST_OF_DICTS)
exporter = TableExport("csv", table)
expected = ("Given name,Surname",) + EXPECTED_CSV_DATA
self.assertEqual(exporter.export(), CSV_SEP.join(expected) + CSV_SEP)
