def papers_view(request):
if request.user.is_authenticated:
user = request.user
sci = SCITable(SCIJournals.objects.filter(user=user))
RequestConfig(request).configure(sci)
up = UnpaidScopusTable(UnpaidScopus.objects.filter(user=user))
RequestConfig(request).configure(up)
p = PaidScopusTable(PaidScopus.objects.filter(user=user))
RequestConfig(request).configure(p)
oj = OtherJournalTable(OtherJournals.objects.filter(user=user))
RequestConfig(request).configure(oj)
table = {'sci': sci, 'up': up, 'p': p, 'oj': oj}
export_format_sci = request.GET.get('sci_export', None)
export_format_ps = request.GET.get('ps_export', None)
export_format_unp = request.GET.get('unp_export', None)
export_format_oj = request.GET.get('oj_export', None)
if TableExport.is_valid_format(export_format_sci):
exporter = TableExport(export_format_sci, sci, exclude_columns=('edit', 'delete'))
return exporter.response(filename=str(user) + '_SCI.xlsx')
if TableExport.is_valid_format(export_format_ps):
exporter = TableExport(export_format_ps, p, exclude_columns=('edit', 'delete'))
return exporter.response(filename=str(user) + '_PS.xlsx')
if TableExport.is_valid_format(export_format_unp):
exporter = TableExport(export_format_unp, up, exclude_columns=('edit', 'delete'))
return exporter.response(filename=str(user) + '_UNP.xlsx')
if TableExport.is_valid_format(export_format_oj):
exporter = TableExport(export_format_oj, oj, exclude_columns=('edit', 'delete'))
return exporter.response(filename=str(user) + '_OJ.xlsx')
return render(request, 'papers_view.html', {'user': user, 'table': table})
else:
return redirect('/login')
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 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 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 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 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 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 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 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 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 other_seminars_view(request, user):
if request.user.is_authenticated and request.user.is_staff:
other = user
user = User.objects.get(username=user)
ca = ConferencesAttendedTable(ConferencesAttended.objects.filter(user=user))
ca.exclude = ('edit', 'delete')
RequestConfig(request).configure(ca)
sa = SeminarsAttendedTable(SeminarsAttended.objects.filter(user=user))
sa.exclude = ('edit', 'delete')
RequestConfig(request).configure(sa)
wa = WorkshopsAttendedTable(WorkshopsAttended.objects.filter(user=user))
wa.exclude = ('edit', 'delete')
RequestConfig(request).configure(wa)
tpa = TrainingProgAttendedTable(TrainingProgAttended.objects.filter(user=user))
tpa.exclude = ('edit', 'delete')
RequestConfig(request).configure(tpa)
co = ConferencesAttendedTable(ConferencesAttended.objects.filter(user=user))
co.exclude = ('edit', 'delete')
RequestConfig(request).configure(co)
wo = WorkshopsOrgTable(WorkshopsOrg.objects.filter(user=user))
wo.exclude = ('edit', 'delete')
RequestConfig(request).configure(wo)
so = SeminarsOrgTable(SeminarsOrg.objects.filter(user=user))
so.exclude = ('edit', 'delete')
RequestConfig(request).configure(wo)
table = {'ca': ca, 'sa': sa, 'wa': wa, 'tpa': tpa, 'co': co, 'wo': wo, 'so': so}
export_format_ca = request.GET.get('ca_export', None)
export_format_sa = request.GET.get('sa_export', None)
export_format_wa = request.GET.get('wa_export', None)
export_format_tpa = request.GET.get('tpa_export', None)
export_format_co = request.GET.get('co_export', None)
export_format_wo = request.GET.get('wo_export', None)
export_format_so = request.GET.get('so_export', None)
if TableExport.is_valid_format(export_format_ca):
exporter = TableExport(export_format_ca, ca, exclude_columns=('edit', 'delete'))
return exporter.response(filename=str(user) + '_CA.xlsx')
if TableExport.is_valid_format(export_format_sa):
exporter = TableExport(export_format_sa, sa, exclude_columns=('edit', 'delete'))
return exporter.response(filename=str(user) + '_SA.xlsx')
if TableExport.is_valid_format(export_format_wa):
exporter = TableExport(export_format_wa, wa, exclude_columns=('edit', 'delete'))
return exporter.response(filename=str(user) + '_WA.xlsx')
if TableExport.is_valid_format(export_format_tpa):
exporter = TableExport(export_format_tpa, tpa, exclude_columns=('edit', 'delete'))
return exporter.response(filename=str(user) + '_TPA.xlsx')
if TableExport.is_valid_format(export_format_co):
exporter = TableExport(export_format_co, co, exclude_columns=('edit', 'delete'))
return exporter.response(filename=str(user) + '_CO.xlsx')
if TableExport.is_valid_format(export_format_wo):
exporter = TableExport(export_format_wo, wo, exclude_columns=('edit', 'delete'))
return exporter.response(filename=str(user) + '_WO.xlsx')
if TableExport.is_valid_format(export_format_so):
exporter = TableExport(export_format_so, so, exclude_columns=('edit', 'delete'))
return exporter.response(filename=str(user) + '_SO.xlsx')
user = request.user
return render(request, 'other_seminars_view.html', {'user': user, 'table': table, 'other': other})
else:
return redirect('/login')
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 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 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 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 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 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 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 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 data_management_view(request):
table = Berita_Tabel(Tabel_Berita.objects.all())
RequestConfig(request, paginate={'per_page': 10}).configure(table)
export_format = request.GET.get('_export', None)
pks = request.GET.getlist('amend')
if 'delete' in request.GET:
sel = Tabel_Berita.objects.filter(pk__in=pks)
sel.delete()
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'))
return exporter.response('table.{}'.format(export_format))
return render(request, 'data_management.html', {'table': table})
def tracking(request):
table = TrackingTable(
CalendarEvent.objects.filter(user_id=request.user.id),
template_name='django_tables2/bootstrap.html')
RequestConfig(request).configure(table)
table.paginate(page=request.GET.get('page', 1), per_page=25)
export_format = request.GET.get('_export', None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, table)
return exporter.response('table.{}'.format('xlsx'))
return render(request, 'tracking/list.html', {'table': table})
def home(request):
images = Image.objects.all().order_by("id")
table = ImageTable(images)
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('images.{}'.format(export_format))
try:
hotkeys_off = request.GET["hotkeys_off"]
request.session["hotkeys"] = "false"
except:
pass
return render(request, 'home.html', {'images': images, 'table': table})