def get(self, request):
self.params['title'] = 'SMS Report'
self.params['body_class'] = 'sms-report-page'
xdata = self.get_xydata(request)[0]
ydata = self.get_xydata(request)[1]
extra_serie1 = {"tooltip": {"y_start": "", "y_end": " cal"}}
chartdata = {
'x': xdata,
'name1': '',
'y1': ydata,
'extra1': extra_serie1,
}
charttype = "discreteBarChart"
chartcontainer = 'discretebarchart_container' # container name
self.params['data'] = {
'charttype': charttype,
'chartdata': chartdata,
'chartcontainer': chartcontainer,
'extra': {
'x_is_date': False,
'x_axis_format': '',
'tag_script_js': True,
'jquery_on_ready': True,
},
}
if request.user.kituser.is_admin:
reporttable = SMSReportTable(
SMSDeliveryReport.objects.filter(
kitu_parent_id=request.user.kituser.id).order_by(
'-created'))
else:
reporttable = SMSReportTable(
SMSDeliveryReport.objects.filter(
kituser_id=request.user.kituser.id).order_by('-created'))
RequestConfig(request, paginate={
'per_page': 25
}).configure(reporttable)
self.params["table"] = reporttable
return render(request, self.template_name, self.params)
def test_render_table_db_queries(self):
Person.objects.create(first_name='brad', last_name='ayers')
Person.objects.create(first_name='davina', last_name='adisusila')
class PersonTable(tables.Table):
class Meta:
model = Person
per_page = 1
request = build_request('/')
with self.assertNumQueries(2):
# one query for pagination: .count()
# one query for page records: .all()[start:end]
request = build_request('/')
table = PersonTable(Person.objects.all())
RequestConfig(request).configure(table)
# render
(Template('{% load django_tables2 %}{% render_table table %}')
.render(Context({'table': table, 'request': request})))
def get(self, request):
if request.user.kituser.is_admin:
reporttable = CallReportTable(
CallDetailReport.objects.filter(
kitu_parent_id=request.user.kituser.id).order_by(
'-a_leg_call_start'))
else:
reporttable = CallReportTable(
CallDetailReport.objects.filter(
kituser_id=request.user.kituser.id).order_by(
'-a_leg_call_start'))
RequestConfig(request, paginate={
'per_page': 25
}).configure(reporttable)
self.params["table"] = reporttable
self.params['title'] = 'Call Report'
self.params['body_class'] = 'call-report-page'
return render(request, self.template_name, self.params)
def search_view(request):
results = None
url = request.get_full_path()
count = url.count('select')
queries = []
if count > 0:
for i in range(1, count + 1):
operator = request.GET.get('operator' + str(i)) or None
field = request.GET.get('select' + str(i))
value = request.GET.get('field' + str(i))
if field == 'tags__name__in':
values_list = value.split(', ')
value = values_list
if field == 'updated_time__range':
dates = value.split(' - ')
start = datetime.date(*[int(x) for x in dates[0].split('/')])
end = datetime.date(*[int(x) for x in dates[1].split('/')])
end = end + datetime.timedelta(days=1)
value = [start, end]
queries.append({
'operator': operator,
'field': field,
'value': value,
})
query = Q(**{queries[0]['field']: queries[0]['value']})
for item in queries[1:]:
if item['operator'] == 'or':
query.add(Q(**{item['field']: item['value']}), Q.OR)
else:
query.add(Q(**{item['field']: item['value']}), Q.AND)
results = ResultsTable(
Cut.objects.filter(
pupil__can_read=request.user).filter(query).distinct().exclude(
Q(private=True) & ~Q(updated_by=request.user)))
RequestConfig(request).configure(results)
export_format = request.GET.get('_export', None)
if TableExport.is_valid_format(export_format):
exporter = TableExport(export_format, results)
return exporter.response('table.{}'.format(export_format))
context = {'title': 'הפאנל', 'nbar': 'search', 'results': results}
return render(request, 'search/search.html', context)
def render_table_db_queries():
with database():
Person.objects.create(first_name="brad", last_name="ayers")
Person.objects.create(first_name="stevie", last_name="armstrong")
class PersonTable(tables.Table):
class Meta:
model = Person
per_page = 1
with queries(count=2):
# one query for pagination: .count()
# one query for page records: .all()[start:end]
request = build_request('/')
table = PersonTable(Person.objects.all())
RequestConfig(request).configure(table)
# render
(Template('{% load django_tables2 %}{% render_table table %}')
.render(Context({'table': table, 'request': request})))
def ajax_search_products(request, pk):
instance = get_object_or_404(Reserva, id_reserva=pk)
q = request.GET.get('q', None)
products = Producto.broswer.is_active().filter(
barcode__icontains=q
)|Producto.broswer.is_active().filter(
descripcion__icontains=q
) if q else Producto.broswer.is_active()
products = products[:6]
products = ProductTable(products)
RequestConfig(request).configure(products)
data = dict()
data['products'] = render_to_string(template_name='include/product_container.html',
request=request,
context={
'products': products,
'instance': instance
})
return JsonResponse(data)
def export_table(request):
table = VisitsTable(Visits.objects.all())
RequestConfig(request).configure(table)
export_format = request.GET.get("csv, json", None)
if TableExport.is_valid_format(export_format):
# exclude columns while creating the TableExport instance:
# exporter = TableExport("csv", table, exclude_columns=("image", "buttons"))
exporter = TableExport(
export_format,
table,
dataset_kwargs={"title": "My Custom Sheet Name"})
# exporter = TableExport(export_format, table)
return exporter.response("table.{}".format(export_format))
return render(request, "tables.html", {
"export_table": table,
})
def test_bootstrap_responsive_template(self):
class BootstrapResponsiveTable(BootstrapTable):
class Meta(BootstrapTable.Meta):
template = 'django_tables2/bootstrap-responsive.html'
table = BootstrapResponsiveTable(MEMORY_DATA)
request = build_request('/')
RequestConfig(request).configure(table)
template = Template('{% load django_tables2 %}{% render_table table %}')
html = template.render(Context({'request': request, 'table': table}))
root = parse(html)
assert len(root.findall('.//thead/tr')) == 1
assert len(root.findall('.//thead/tr/th')) == 4
assert len(root.findall('.//tbody/tr')) == 2
assert len(root.findall('.//tbody/tr/td')) == 8
pager = './/ul/li[@class="cardinality"]/small'
assert root.find(pager).text.strip() == 'Page 1 of 2'
def test_boostrap_template():
table = BootstrapTable(MEMORY_DATA)
request = build_request('/')
RequestConfig(request).configure(table)
template = Template('{% load django_tables2 %}{% render_table table %}')
html = template.render(Context({'request': request, 'table': table}))
root = parse(html)
assert len(root.findall('.//thead/tr')) == 1
assert len(root.findall('.//thead/tr/th')) == 4
assert len(root.findall('.//tbody/tr')) == 2
assert len(root.findall('.//tbody/tr/td')) == 8
assert root.find(
'./ul[@class="pager list-inline"]/li[@class="cardinality"]/small'
).text.strip() == 'Page 1 of 2'
# make sure the link is prefixed
assert root.find('./ul[@class="pager list-inline"]/li[@class="next"]/a'
).get('href') == '?bootstrap-page=2'
def assignment_management_view(request):
"""
Main view for assignment management. Has table of researcher's assignments with modals for more info and
option to delete.
"""
assignment_rows = []
researcher = Researcher.objects.get(id=request.user.id)
assignments = Assignment.objects.filter(researcher=researcher)
# build each row for table. one assignment per row
for assignment in assignments:
row_data = {}
row_data.update({"id": assignment.id,
"name": assignment.name,
"date_assigned": assignment.date_assigned})
assignment_rows.append(row_data)
assignments_table = AssignmentsTable(assignment_rows)
RequestConfig(request, paginate={"per_page": 10}).configure(assignments_table)
return render(request, 'assignment_management/main_view.html', {'table': assignments_table})
def get_context_data(self, **kwargs):
context = super(PermsUserDetailView, self).get_context_data(**kwargs)
user = context['object']
permissions = Permission.objects.all()
search_field = self.request.GET.get('search')
# Filter permissions by search term
if search_field and permissions:
permissions = filter_permissions(search_field, permissions)
permissions = check_perms(user, permissions)
user_permissions_table = CaspUserPermissionsTable(permissions)
RequestConfig(request=self.request, paginate={
"per_page": 20
}).configure(user_permissions_table)
context['user_permissions_table'] = user_permissions_table
return context
def test_bootstrap_responsive_template(self):
class BootstrapResponsiveTable(BootstrapTable):
class Meta(BootstrapTable.Meta):
template_name = "django_tables2/bootstrap-responsive.html"
table = BootstrapResponsiveTable(MEMORY_DATA)
request = build_request("/")
RequestConfig(request).configure(table)
template = Template(
"{% load django_tables2 %}{% render_table table %}")
html = template.render(Context({"request": request, "table": table}))
root = parse(html)
self.assertEqual(len(root.findall(".//thead/tr")), 1)
self.assertEqual(len(root.findall(".//thead/tr/th")), 4)
self.assertEqual(len(root.findall(".//tbody/tr")), 2)
self.assertEqual(len(root.findall(".//tbody/tr/td")), 8)
self.assertEqual(
root.find('.//ul[@class="pagination"]/li[2]/a').text.strip(), "2")
def get_context_data(self, **kwargs):
# Nous récupérons le contexte depuis la super-classe
context = super(AllClients, self).get_context_data(**kwargs)
# = LigneFacture.objects.values('facture__client_id').annotate(
# chiffre_affaire=Sum(
# ExpressionWrapper(F('qte'), output_field=FloatField())
# * F('produit__prix')))
table = ClientTable(
Client.objects.annotate(chiffre_affaire=Sum(
ExpressionWrapper(F('facture_client__lignes_facture__qte'),
output_field=FloatField()) *
F('facture_client__lignes_facture__produit__prix'))))
RequestConfig(self.request, paginate={"per_page": 10}).configure(table)
context['table'] = table
context['btn_end_txt'] = ' Ajouter Un nouveau Client '
context['the_url'] = '/add_client'
context['titre'] = "Tout les Clients"
return context
def test_bootstrap_responsive_template(self):
class BootstrapResponsiveTable(BootstrapTable):
class Meta(BootstrapTable.Meta):
template_name = 'django_tables2/bootstrap-responsive.html'
table = BootstrapResponsiveTable(MEMORY_DATA)
request = build_request('/')
RequestConfig(request).configure(table)
template = Template(
'{% load django_tables2 %}{% render_table table %}')
html = template.render(Context({'request': request, 'table': table}))
root = parse(html)
self.assertEqual(len(root.findall('.//thead/tr')), 1)
self.assertEqual(len(root.findall('.//thead/tr/th')), 4)
self.assertEqual(len(root.findall('.//tbody/tr')), 2)
self.assertEqual(len(root.findall('.//tbody/tr/td')), 8)
self.assertEqual(
root.find('.//ul[@class="pagination"]/li[2]/a').text.strip(), '2')
def test_localization_of_pagination_string():
class Table(tables.Table):
foo = tables.Column(verbose_name='my column')
bar = tables.Column()
class Meta:
default = '---'
table = Table(map(lambda x: [x, x + 100], range(40)))
request = build_request('/')
RequestConfig(request, paginate={'per_page': 10}).configure(table)
with translation_override('en'):
assert 'Page 1 of 4' in table.as_html(request)
with translation_override('nl'):
assert 'Pagina 1 van 4' in table.as_html(request)
with translation_override('it'):
assert 'Pagina 1 di 4' in table.as_html(request)
def add_inventory(request):
queryset = GenotypeUploads.objects.all()
f = GenoUploadsFilter(request.GET, queryset=queryset)
table = UploadRecords(f.qs, order_by="-uploaded_at")
RequestConfig(request, paginate={'per_page': 25}).configure(table)
# Check to see if form is valid, even though we will reinitialize it after
# getting a set of log files created
form = GenotypesUploadForm(request.POST or None, request.FILES or None)
if form.is_valid():
# Grab the file and open it
data = request.FILES.get('document', None)
# Go through each line of the file
log_files = additions_upload(data)
# reinitialize the upload form with the parse out temp file names
form = GenotypesUploadForm(request.POST or None,
request.FILES or None,
initial={
'upload_pass': '******' + log_files[0],
'upload_fail': 'logs/' + log_files[1],
})
# fake save to initialize num issues only to replace with log_file val
form = form.save(commit=False)
form.issues = log_files[2]
form.save()
# This will clear out our form upon submission
form = GenotypesUploadForm()
# This will refresh the page so people don't double post
if int(log_files[2]) == 0:
return HttpResponseRedirect('/SeedInv')
else:
return HttpResponseRedirect('/SeedInv/add_inventory')
return render(request, 'Inventory/add_inventory.html', {
'table': table,
'filter': f,
'GenotypesUploadForm': GenotypesUploadForm
})
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 persons(request, pid):
"""
displays all persons in a parliament
``persons``
A table displaying all parliamentarians in :model:`parliament.Parl`
"""
template = loader.get_template('parliament/persons.html')
parl = Parl.objects.get(pk=pid)
persons = person_table(
Person.objects.filter(seat__parlperiod__parliament=parl))
RequestConfig(request).configure(persons)
context = {'persons': persons, 'parl': parl}
return HttpResponse(template.render(context, request))
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
filter = {}
if self.request.user.is_authenticated:
if self.request.user.user_type == 1:
filter['client'] = self.request.user.client
commandes = Commande.objects.filter(**filter)
if self.request.user.user_type == 0:
table = CommandeTableAdmin(commandes)
elif self.request.user.user_type == 1:
table = CommandeTable(commandes)
RequestConfig(self.request, paginate={"per_page": 8}).configure(table)
context['table'] = table
context['object'] = 'Commande'
context['title'] = 'La liste des commandes :'
return context
def export(request):
config = RequestConfig(request)
cuts_export = ExportCuts(
Cut.objects.filter(pupil__can_read=request.user).exclude(
Q(private=True) & ~Q(updated_by=request.user)),
prefix='cuts')
events_export = ExportEvents(
Event.objects.filter(pupil__can_read=request.user), prefix='events')
config.configure(cuts_export)
config.configure(events_export)
export_format = request.GET.get('_export', None)
model = request.GET.get('model', None)
if TableExport.is_valid_format(export_format):
if model == 'update':
exporter = TableExport(export_format, cuts_export)
return exporter.response('updates.{}'.format(export_format))
elif model == 'event':
exporter = TableExport(export_format, events_export)
return exporter.response('events.{}'.format(export_format))
return render(request, 'export/export.html', {})
def listTags(request, server):
project = Project.objects.get(name=request.session["deploy_project"])
c = Client(str(project.repo_type),
server.ip,
server.port,
key=project.sshKey.key)
res = c.ListTags(project.working_dir)
print res
table = TagTable(res)
table_to_report = RequestConfig(request, paginate={
"per_page": 15
}).configure(table)
if table_to_report:
return create_report_http_response(table_to_report, request)
return render_to_response("deploy2.html", {
"count": len(res),
"mode": "tags",
"tags": table
},
context_instance=RequestContext(request))
def sortidesGestioList(request):
credentials = tools.getImpersonateUser(request)
(user, _) = credentials
professor = User2Professor(user)
filtre = []
socEquipDirectiu = User.objects.filter(pk=user.pk,
groups__name='direcció').exists()
socCoordinador = User.objects.filter(pk=user.pk,
groups__name__in=['sortides'
]).exists()
#si sóc equip directiu només les que tinguin estat 'R' (Revisada pel coordinador)
if socEquipDirectiu:
filtre.append('R')
#si sóc coordinador de sortides només les que tinguin estat 'P' (Proposada)
if socCoordinador:
filtre.append('P')
sortides = (Sortida.objects.exclude(estat='E').filter(
estat__in=filtre).distinct())
table = Table2_Sortides(data=list(sortides), origen="Gestio")
table.order_by = '-calendari_desde'
RequestConfig(request,
paginate={
"paginator_class": DiggPaginator,
"per_page": 10
}).configure(table)
url = r"{0}{1}".format(settings.URL_DJANGO_AULA,
reverse('sortides__sortides__ical'))
return render(request, 'gestioDeSortides.html', {
'table': table,
'url': url,
})
def get_context_data(self, **kwargs):
# Nous récupérons le contexte depuis la super-classe
context = super(FournisseurList, self).get_context_data(**kwargs)
table = FournisseurTable(
Fournisseur.objects.annotate(chiffre_affaire=Sum(
ExpressionWrapper(F(
'fournisseur_produit__lignes_produit__qte'),
output_field=FloatField()) *
F('fournisseur_produit__prix'))))
z = Fournisseur.objects.annotate(chiffre_affaire=Sum(
ExpressionWrapper(F('fournisseur_produit__lignes_produit__qte'),
output_field=FloatField()) *
F('fournisseur_produit__prix')))
#table = FournisseurTable(Fournisseur.objects.filter(fournisseur_produit__lignes_produit__qte=1,fournisseur_produit__prix=))
RequestConfig(self.request, paginate={"per_page": 10}).configure(table)
context['table'] = table
context['btn_end_txt'] = ' Ajouter Un nouveau fournisseur'
context['the_url'] = '/add_fournisseur'
context['titre'] = "Tout les fournissuers"
return context
def listCommits(request,filter=None):
#if request.method == "GET":
res = None
branches=[]
c=None
server=None
project=None
project = Project.objects.get(name=request.session["deploy_project"])
if filter==None: filter=project.default_branch if project.default_branch not in ("",None) else None
print request.GET.get("refresh","False")
if request.GET.get("refresh","False")=="True":
if "commits" in request.session:
request.session.pop("commits","")
request.session.pop("branchs","")
return redirect("./listCommits")
if filter or not "commits" in request.session:
server = Server.objects.get(name=request.session["deploy_server"])
c = Client("git", server.ip, server.port,key=project.sshKey.key)
c.Pull(project.repo,project.working_dir,project.sshKey.key)
res = c.ListCommits(project.working_dir,options={"branch":filter})
request.session["commits"] = res
else:
res = request.session["commits"]
if not "branchs" in request.session:
if not c:
server = Server.objects.get(name=request.session["deploy_server"])
project = Project.objects.get(name=request.session["deploy_project"])
c = Client("git", server.ip, server.port, key=project.sshKey.key)
branches=c.ListBranchs(project.working_dir)
else:
branches=request.session["branchs"]
request.session["branchs"]=branches
table = CommitTable(res)
table_to_report = RequestConfig(request, paginate={"per_page": 15}).configure(table)
if table_to_report:
return create_report_http_response(table_to_report, request)
return render_to_response("deploy2.html", {"project":project,"mode":"commits","commits": table,"branchs":branches,"current_branch":filter}, context_instance=RequestContext(request))
def view_movies(request, *args, **kwargs):
'''
View movies irrespective of the user type
:param request:
:param args:
:param kwargs:
:return:
'''
template = 'show_movies.html'
filter_dict = dict()
if request.GET.get('name'):
filter_dict['name__icontains'] = request.GET.get('name')
if request.GET.get('director'):
filter_dict['director__director_name__icontains'] = request.GET.get('director')
movies = Movie.objects.filter(**filter_dict)
movie_table = MovieTable(movies)
RequestConfig(request).configure(movie_table)
context_dict = {'movies': movies}
return render(request, template, context_dict)
def test_semantic_template(self):
class SemanticTable(CountryTable):
class Meta:
template_name = "django_tables2/semantic.html"
prefix = "semantic-"
per_page = 2
table = SemanticTable(MEMORY_DATA)
request = build_request("/")
RequestConfig(request).configure(table)
template = Template(
"{% load django_tables2 %}{% render_table table %}")
html = template.render(Context({"request": request, "table": table}))
root = parse(html)
self.assertEqual(len(root.findall(".//thead/tr")), 1)
self.assertEqual(len(root.findall(".//thead/tr/th")), 4)
self.assertEqual(len(root.findall(".//tbody/tr")), 2)
self.assertEqual(len(root.findall(".//tbody/tr/td")), 8)
# make sure the link is prefixed
next_page = './/tfoot/tr/th/div[@class="ui right floated pagination menu"]/a[1]'
self.assertEqual(root.find(next_page).get("href"), "?semantic-page=1")
def test_bootstrap_template(self):
table = BootstrapTable(MEMORY_DATA)
request = build_request('/')
RequestConfig(request).configure(table)
template = Template(
'{% load django_tables2 %}{% render_table table %}')
html = template.render(Context({'request': request, 'table': table}))
root = parse(html)
self.assertEqual(root.find('.//table').attrib, {'class': 'table'})
self.assertEqual(len(root.findall('.//thead/tr')), 1)
self.assertEqual(len(root.findall('.//thead/tr/th')), 4)
self.assertEqual(len(root.findall('.//tbody/tr')), 2)
self.assertEqual(len(root.findall('.//tbody/tr/td')), 8)
self.assertEqual(
root.find('.//ul[@class="pagination"]/li[2]/a').text.strip(), '2')
# make sure the link is prefixed
self.assertEqual(
root.find('.//ul[@class="pagination"]/li[@class="next"]/a').get(
'href'), '?bootstrap-page=2')
def test_semantic_template(self):
class SemanticTable(CountryTable):
class Meta:
template_name = 'django_tables2/semantic.html'
prefix = 'semantic-'
per_page = 2
table = SemanticTable(MEMORY_DATA)
request = build_request('/')
RequestConfig(request).configure(table)
template = Template(
'{% load django_tables2 %}{% render_table table %}')
html = template.render(Context({'request': request, 'table': table}))
root = parse(html)
self.assertEqual(len(root.findall('.//thead/tr')), 1)
self.assertEqual(len(root.findall('.//thead/tr/th')), 4)
self.assertEqual(len(root.findall('.//tbody/tr')), 2)
self.assertEqual(len(root.findall('.//tbody/tr/td')), 8)
# make sure the link is prefixed
next_page = './/tfoot/tr/th/div[@class="ui right floated pagination menu"]/a[1]'
self.assertEqual(root.find(next_page).get('href'), '?semantic-page=1')
def search_list_results(request, sid):
template = loader.get_template('parliament/search-list-results.html')
s = Search.objects.get(pk=sid)
if s.search_object_type == 1:
pars = Paragraph.objects.filter(search_matches=s)
results_table = SearchParTable(pars)
if s.text:
results_table.reg_replace(s.text)
else:
uts = Utterance.objects.filter(search_matches=s)
results_table = SearchSpeechTable(uts)
if s.text:
results_table.reg_replace(s.text)
RequestConfig(request).configure(results_table)
context = {'search': s, 'table_object': results_table}
return HttpResponse(template.render(context, request))
def ajax_add_product(request, pk, dk):
instance = get_object_or_404(Reserva, id_reserva=pk)
product = get_object_or_404(Producto, id_producto=dk)
detalle_venta_prod, created = DetalleVentaProd.objects.get_or_create(id_reserva_fk=instance, id_producto_fk=product)
if created:
detalle_venta_prod.cantidad = 1
detalle_venta_prod.precio = product.precio1
else:
detalle_venta_prod.cantidad += 1
detalle_venta_prod.save()
product.stock -= 1
product.save()
instance.refresh_from_db()
detalle_venta_prod = DetVentaProdTable(instance.detalle_venta_prod.all())
RequestConfig(request).configure(detalle_venta_prod)
data = dict()
data['result'] = render_to_string(template_name='include/order_container.html',
request=request,
context={'instance': instance,
'detalle_venta_prod': detalle_venta_prod
}
)
return JsonResponse(data)
