def post(self, req):
form = ReportForm(req.POST)
# Verifica validacao
if form.is_valid():
dados_form = form.data
report = Report.objects.create(condition=dados_form['condition'],
name=dados_form['name'],
command=dados_form['command'])
report.save()
# Valores para tabela na pagina principal
commands = Command.objects.all()
computers = Computer.objects.all()
return render(
req, 'pagina_principal.html', {
"computers": computers,
"commands": commands,
"event": 1,
"msg": "Report editado com sucesso."
})
return render(req, self.template_name, {'form': form})
def edit_report(request, lot_number):
report = Report.objects.get(lot_number=lot_number)
if request.method == 'POST':
reportform = ReportForm(request.POST, instance=report)
if reportform.is_valid():
report = reportform.save()
action.send(request.user, verb='edited lot number', target=report)
return HttpResponseRedirect(report.get_absolute_url())
else:
reportform = ReportForm(instance=report)
return render_to_response('reports/new_report.html',
{'reportform': reportform,},
context_instance=RequestContext(request))
def new_report(request):
if request.method == 'POST':
reportform = ReportForm(request.POST)
if reportform.is_valid():
report = reportform.save()
report.created_by = request.user
report.save()
action.send(request.user,
verb='created lot number',
action_object=report,
target=report)
return HttpResponseRedirect(report.get_absolute_url())
else:
copy = request.GET.get('copy', None)
if copy:
report = Report.objects.get(lot_number=copy)
reportform = ReportForm(instance=report)
else:
reportform = ReportForm(
initial={'receiving_date': time.strftime("%Y-%m-%d")})
return render_to_response('reports/new_report.html', {
'reportform': reportform,
},
context_instance=RequestContext(request))
def create_report_view(request):
form = ReportForm(request.POST or None)
if request.is_ajax():
image = request.POST.get('image')
img = get_report_image(image)
author_profile = Profile.objects.get(user=request.user)
if form.is_valid():
instance = form.save(commit=False)
instance.image = img
instance.author = author_profile
instance.save()
return JsonResponse({'msg': 'success'})
return JsonResponse({})
def home_view(request):
sale_form = SaleSearchForm(request.POST or None)
report_form = ReportForm()
data_all = by_id = by_date = chart = None
# allow to user search data for time periods
if request.method == 'POST':
date_from = request.POST.get('date_from')
date_to = request.POST.get('date_to')
chart_type = request.POST.get('chart_type')
result_by = request.POST.get('result_by')
# all logic in util.py file
logic_util = sales_and_positions(date_from, date_to, chart_type,
result_by, request)
if logic_util:
data_all, by_id, by_date, chart = logic_util
context = {
'title': 'Sales Home',
'sale_form': sale_form,
'report_form': report_form,
'data': data_all,
"by_id": by_id,
"by_date": by_date,
"chart": chart
}
return render(request, 'sales/home.html', context)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['title'] = 'Reporte de Salidas'
context['entity'] = 'Reportes'
context['list_url'] = reverse_lazy('sale_report')
context['form'] = ReportForm()
return context
def home_view(request):
sales_df = None
positions_df = None
merged_df = None
df = None
chart = None
no_data = None
search_form = SalesSearchForm(request.POST or None)
reportform = ReportForm()
if request.method == 'POST':
date_from = request.POST.get('date_from')
date_to = request.POST.get('date_to')
chart_type = request.POST.get('chart_type')
results_by = request.POST.get('results_by')
sales_qs = Sale.objects.filter(created__date__gte=date_from,created__date__lte=date_to)
if len(sales_qs)>0:
sales_df = pd.DataFrame(sales_qs.values())
sales_df['customer_id'] = sales_df['customer_id'].apply(get_customer_from_id)
sales_df['salesman_id'] = sales_df['salesman_id'].apply(get_salesman_from_id)
sales_df = sales_df.rename({'customer_id':'customer','salesman_id':'salesman','id':'sales_id'},axis=1)
sales_df['created'] = sales_df['created'].apply(lambda x:x.strftime('%y-%m-%d'))
sales_df['updated'] = sales_df['updated'].apply(lambda x:x.strftime('%y-%m-%d'))
# sales_df['sales_id'] = sales_df['id']
positions_data = []
#there will be multiple sales in sales_qs
for sale in sales_qs:
#there will be multiple positions in 1 sale
for pos in sale.get_positions():
obj = {'position_id':pos.pk,
'product':pos.product.name,
'quantity':pos.quantity,
'price':pos.price,
'sales_id':pos.get_sales_id(),}
positions_data.append(obj)
positions_df = pd.DataFrame(positions_data)
merged_df = pd.merge(sales_df,positions_df,on='sales_id')
df = merged_df.groupby('transaction_id',as_index=False)['price'].agg('sum')
print('v1',df['transaction_id'].values)
chart = get_chart(chart_type,sales_df,results_by)
sales_df = sales_df.to_html()
positions_df = positions_df.to_html()
merged_df = merged_df.to_html()
df = df.to_html()
else:
no_data = 'no data is available in this date range'
context={'search_form':search_form,'reportform':reportform,
'sales_df':sales_df,'positions_df':positions_df,'merged_df':merged_df,
'df':df,'chart':chart,'no_data':no_data}
return render(request,'sales/home.html',context)
def report_view(request, production_line):
r_form = ReportForm(request.POST or None)
p_form = ProblemReportedForm(request.POST or None)
queryset = Report.objects.filter(production_line__name=production_line)
if p_form.is_valid():
print(request.POST)
context = {'r_form': r_form, 'p_form': p_form, 'object_list': queryset}
return render(request, 'reports/report.html', context)
def list_file(request):
'''
:param request:
:return:a response
'''
report_form = ReportForm(request.POST or None)
file_form = FileForm(request.POST or None, request.FILES or None)
if file_form.is_valid():
collection_name = create_collection(request, file_form)
instance = file_form.save(commit=False)
instance.collection = collection_name
instance.save()
collection_obj = get_collection(request, collection_name)
field_list, _ = get_fields_and_data_from_collection(collection_obj)
field_instance_list = []
for turn in field_list:
field_instance_list.append(
Field.objects.create(name=turn[0], type=turn[1],
file=instance))
print(Field.objects.all())
return redirect(reverse('files:list'))
elif report_form.is_valid():
instance = report_form.save()
narrative_instance = Narrative.objects.create(report=instance)
narrative_instance.segments.create(index=0)
print(instance.name, instance.file)
return redirect(reverse('reports:editor', kwargs={'id': instance.id}))
else:
file_qs = File.objects.all()
collection_list = []
for turn in file_qs:
collection_list.append(get_summary_of_collection(request, turn))
context = {
'collection_list': collection_list,
'file_form': file_form,
'report_form': report_form,
}
return render(request, 'files/list.html', context)
def new_report(request):
if request.method == 'POST':
reportform = ReportForm(request.POST)
if reportform.is_valid():
report = reportform.save()
report.created_by = request.user
report.save()
action.send(request.user, verb='created lot number', action_object=report, target=report)
return HttpResponseRedirect(report.get_absolute_url())
else:
copy = request.GET.get('copy', None)
if copy:
report = Report.objects.get(lot_number=copy)
reportform = ReportForm(instance=report)
else:
reportform = ReportForm(initial={'receiving_date': time.strftime("%Y-%m-%d")})
return render_to_response('reports/new_report.html',
{'reportform': reportform,},
context_instance=RequestContext(request))
def report(request):
if request.method == "POST":
form = ReportForm(request.POST)
if form.is_valid():
model_instance = form.save(commit=False)
model_instance.save()
return redirect(reverse("reportdone"))
else:
form = ReportForm()
return render(request, 'reports/report.html', {'form': form})
def edit_report(request, lot_number):
report = Report.objects.get(lot_number=lot_number)
if request.method == 'POST':
reportform = ReportForm(request.POST, instance=report)
if reportform.is_valid():
report = reportform.save()
action.send(request.user, verb='edited lot number', target=report)
return HttpResponseRedirect(report.get_absolute_url())
else:
reportform = ReportForm(instance=report)
return render_to_response('reports/new_report.html', {
'reportform': reportform,
},
context_instance=RequestContext(request))
def index(request):
if request.user.is_authenticated:
if request.method == 'GET':
form = ReportForm(data=request.POST,
user_from=request.user.username)
context = {'form': form}
return render(request, 'reports/report.html', context)
if request.method == 'POST':
form = ReportForm(data=request.POST,
user_from=request.user.username)
if form.is_valid():
instance = form.save()
report_reverse = instance.pk
return redirect(
reverse('reports:status',
kwargs={'report_id': str(report_reverse)}))
else:
return redirect(reverse('user:login'))
def report(request, id):
try:
reported_elem = Node.objects.get(id=id)
except:
reported_elem = Edge.objects.get(id=id)
if request.method == "POST":
form = ReportForm(request.POST)
if form.is_valid():
model_instance = form.save(commit=False)
model_instance.save()
return redirect(reverse("reportdone"))
else:
form = ReportForm()
return render(request, 'reports/report.html', {
'form': form,
"element": reported_elem
})
def view_reports(request):
formset = ReportForm()
if request.method == 'POST':
if request.POST.get('report'):
report = get_object_or_404(Report, pk=request.POST.get('report'))
form = ReportForm(request.POST, instance=report)
if form.is_valid():
report = form.save()
report.save()
return render_to_response('reports/reports.html',{
'success': "success",
'form': formset,
'reports': Report.objects.all()},
context_instance=RequestContext(request))
else:
return render_to_response('reports/reports.html',{
'error': form.errors,
'form': formset,
'reports': Report.objects.all()},
context_instance=RequestContext(request))
else:
form = ReportForm(request.POST)
if form.is_valid():
new_report= form.save()
return render_to_response('reports/reports.html',{
'success': "success",
'form': formset,
'reports': Report.objects.all()},
context_instance=RequestContext(request))
else:
return render_to_response('reports/reports.html',{
'error': form.errors,
'form': formset,
'reports': Report.objects.all()},
context_instance=RequestContext(request))
else:
return render_to_response('reports/reports.html',{
'form': formset,
'reports': Report.objects.all()},
context_instance=RequestContext(request))
def home_view(request):
search_form = SalesSearchForm(request.POST or None)
report_form = ReportForm()
sales_df = None
position_df = None
merged_df = None
df = None
chart = None
no_data = None
if request.method == 'POST':
date_from = request.POST.get('date_from')
date_to = request.POST.get('date_to')
chart_type = request.POST.get('chart_type')
results_by = request.POST.get('results_by')
sale_qs = Sale.objects.filter(created__date__gte=date_from,
created__date__lte=date_to)
if len(sale_qs) > 0:
sales_df = pd.DataFrame(sale_qs.values())
sales_df['customer_id'] = sales_df['customer_id'].apply(
get_customer_from_id)
sales_df['salesman_id'] = sales_df['salesman_id'].apply(
get_salesman_from_id)
sales_df['created'] = sales_df['created'].apply(
lambda x: x.strftime('%Y-%m-%d'))
sales_df.rename(
{
'customer_id': 'customer',
'salesman_id': 'salesman',
'id': 'sales_id'
},
axis=1,
inplace=True)
positions_data = []
for sale in sale_qs:
for pos in sale.get_positions():
obj = {
'position_id': pos.id,
'product': pos.product,
'quantity': pos.quantity,
'price': pos.price,
'sales_id': pos.get_sale_id()
}
positions_data.append(obj)
position_df = pd.DataFrame(positions_data)
merged_df = pd.merge(sales_df, position_df, on='sales_id')
df = merged_df.groupby('transaction_id',
as_index=False)['price'].agg('sum')
chart = get_chart(chart_type, sales_df, results_by)
sales_df = sales_df.to_html()
position_df = position_df.to_html()
merged_df = merged_df.to_html()
df = df.to_html()
else:
no_data = "Sorry! 😔 No Data Available."
context = {
'search_form': search_form,
'report_form': report_form,
'sales_df': sales_df,
'position_df': position_df,
'merged_df': merged_df,
'df': df,
'chart': chart,
'no_data': no_data,
}
return render(request, 'sales/home.html', context=context)
def reports_edit(request, **kwargs):
# Get id
report_id = kwargs.get('id')
# Get current user's reports
user_reports = request.user.report_set.all()
# Check if the `report_id` is correct
try:
report_to_edit = user_reports.get(id=report_id)
except:
return render(request,
'error_page.html',
context={
'error_message':
"No report with id:" + str(report_id) + " was found!"
})
# Create the formset, specifying the form and formset we want to use
ReportElementFormSet = formset_factory(ReportElementForm,
formset=BaseFormSet,
extra=0)
# Get our data for. This is used as initial data.
report_elements = ReportElement.objects.filter(
report=report_to_edit).order_by("element_order")
report_elements_count = report_elements.count()
if request.method == 'POST':
if request.POST.get('delete'):
return redirect('reports_delete', id=report_id)
report_form = ReportForm(request.POST)
report_element_formset = ReportElementFormSet(
request.POST, form_kwargs={'user': request.user})
if report_form.is_valid() and report_element_formset.is_valid():
report_new_data = report_form.cleaned_data
# Update `report` object
for attr, value in report_new_data.items():
# print('{} = {}'.format(attr, value))
setattr(report_to_edit, attr, value)
report_to_edit.save()
# Now save the data for each form in the formset
new_elements = []
for form in report_element_formset:
new_data = form.cleaned_data
new_element = ReportElement(report=report_to_edit)
for attr, value in new_data.items():
# print('{} = {}'.format(attr, value))
setattr(new_element, attr, value)
new_elements.append(new_element)
try:
with transaction.atomic():
#Replace the old with the new
ReportElement.objects.filter(
report=report_to_edit).delete()
ReportElement.objects.bulk_create(new_elements)
# And notify our users that it worked
messages.success(
request,
'<i class="uk-icon-floppy-o"></i> Report saved!',
extra_tags='safe')
except IntegrityError: #If the transaction failed
messages.error(
request,
'<i class="uk-icon-ban"></i> There was an error saving your report.',
extra_tags='safe')
if request.POST.get('add'):
return redirect('reports_add_element', id=report_id)
else:
report_form = ReportForm(
initial={
'report_name': report_to_edit.report_name,
'report_description': report_to_edit.report_description,
})
report_element_formset = ReportElementFormSet(
initial=[{
'id': el.id,
'element_name': el.element_name,
'element_order': el.element_order,
'element_type': el.element_type,
'text': el.text,
'caption': el.caption,
'style': el.style,
'spreadsheet': el.spreadsheet,
'plot': el.plot,
'embedded_raport': el.embedded_raport,
'element_start': el.element_start,
'element_end': el.element_end,
} for el in report_elements],
form_kwargs={'user': request.user})
return render(request,
'reports_edit.html',
context={
'report': report_to_edit,
'report_form': report_form,
'report_element_formset': report_element_formset,
'report_elements_count': report_elements_count,
})
def get(self, request):
success_message = ''
form = ReportForm()
context = {'form': form, 'success_message': success_message}
return render(request, 'reports/new_report.html', context)
def report_list(request):
# If we have an account_id provided via URI, using it as inital
# value for the form.
language = get_language()
decimal_separator = get_format("DECIMAL_SEPARATOR", language, True)
context = {"account": None, 'user': request.user}
if not request.user.accounts.real_ib().exists():
return {"TEMPLATE": "reports/403.html"}
excluded_for_user = set(
AccountGroup.objects.excluded_for_user(request.user))
if request.method == "POST":
form = ReportForm(data=request.POST or None, **context)
if form.is_valid():
error_context = {
"form":
form,
'DECIMAL_SEPARATOR':
decimal_separator,
'should_show_form':
True,
"reports":
SavedReport.objects.filter(
for_user=request.user).order_by('-creation_ts')
}
error_context.update(context)
def error():
messages.error(
request,
_("You aren't allowed to view reports of that type for account"
))
return error_context
codename = form.cleaned_data.get("report_type")
if not codename:
return error()
report = settings.REPORTS.get(codename)
if not report:
return error()
account = None
groups_to_include = None
groups_to_exclude = None
if report["type"] == reports.ACCOUNT_GROUP:
groups_to_include = form.cleaned_data.get(
"account_group_include")
# мы хотим проверить, есть ли указанные пользователем группы среди доступных ему
# - если в форме указаны группы, то проверяем их вхождения
# - если они в форме не были указаны (для групп включения это означает использовать все счета),
# то если юзер имеет разрешение reports.can_use_any_account - ему это разрешено, иначе нет.
# так как set([None]) не является подмножеством ни пустого сета, ни реального,
# то он покажет ошибку при проверке вхождений множеств.
# set() является подмножеством любого сета и гарантированно пройдет проверку вхождения
if groups_to_include:
groups_to_include = set(groups_to_include)
else:
groups_to_include = set() if request.user.has_perm("reports.can_use_any_account") \
else set([None])
groups_to_exclude = form.cleaned_data.get(
"account_group_exclude")
groups_to_exclude = set(
groups_to_exclude) if groups_to_exclude else set()
available_inclusion_groups = set(
AccountGroup.objects.for_user(request.user))
available_exclusion_groups = available_inclusion_groups | excluded_for_user
if (groups_to_include and not groups_to_include.issubset(available_inclusion_groups)) or \
(groups_to_exclude and not groups_to_exclude.issubset(available_exclusion_groups)):
return error()
elif report["type"] == reports.GLOBAL:
if not request.user.has_perm("reports.can_use_any_account"):
return error()
elif report["type"] == reports.PRIVATE_OFFICE:
pass # No checks are required
else:
if not request.user.has_perm("reports.can_use_any_account"):
account = form.cleaned_data.get("account")
if account and account.user != request.user:
return error()
else:
account = TradingAccount(
mt4_id=int(request.POST.get("account")))
if not request.user.has_perm("reports.can_generate_%s" % codename):
return error()
template = report.get(
'template_name') or "reports/%s.html" % codename
report = SavedReport()
report.for_user = request.user
report.name = unicode(form) % settings.REPORTS[codename]["name"]
report.save()
form_data = {
'account_group_include': groups_to_include or [],
'account_group_exclude': groups_to_exclude or [],
'account': account,
'report_type': codename,
'start': form.cleaned_data['start'],
'end': form.cleaned_data['end'],
}
task = generate_report.delay(form_data, template,
decimal_separator, report, language,
request.user)
report.celery_task_id = task.pk
report.save()
messages.success(
request,
_("Your report order has been received and is now being processed. \
You will receive an email when the processing finishes.")
)
return redirect("reports_report_list")
else:
today = date.today()
form = ReportForm(initial={
"start":
today + relativedelta(day=1),
"end":
today + relativedelta(day=1, days=-1, months=1)
},
**context)
context["form"] = form
context["reports"] = SavedReport.objects.filter(
for_user=request.user).order_by('-creation_ts')
context['DECIMAL_SEPARATOR'] = decimal_separator
context['should_show_form'] = True
context['excluded_for_user'] = excluded_for_user
return context
def home_view(request):
## function views
search_form = SalesSearchForm(request.POST or None)
report_form = ReportForm()
sales_df, position_df, merged_df, gdf = None, None, None, None
chart = None
no_data = None
if request.method == 'POST':
date_from = request.POST.get('date_from')
date_to = request.POST.get('date_to')
chart_type = request.POST.get('chart_type')
result_by = request.POST.get('results_by')
sales_qs = Sale.objects.filter(
created_at__date__lte=date_to,
created_at__date__gte=date_from) # queryset
if len(sales_qs) > 0:
sales_df = pd.DataFrame(sales_qs.values())
sales_df['salesman_id'] = sales_df['salesman_id'].apply(
get_salesman_from_id)
sales_df['customer_id'] = sales_df['customer_id'].apply(
get_customer_from_id)
sales_df.rename(
{
'customer_id': 'customer',
'salesman_id': 'salesman',
'id': 'sales_id'
},
axis=1,
inplace=True)
sales_df['created_at'] = sales_df['created_at'].apply(
lambda dt: dt.strftime("%d-%m-%Y"))
position_data = [{
'position_id': pos.id,
'product': pos.product.name,
'quantity': pos.quantity,
'price': pos.price,
'sales_id': pos.get_sales_id(),
} for sale in sales_qs for pos in sale.get_positions()]
position_df = pd.DataFrame(position_data)
merged_df = pd.merge(sales_df, position_df, on='sales_id')
gdf = merged_df.groupby('transaction_id',
as_index=False)['price'].agg('sum')
chart = get_chart(
chart_type, sales_df,
result_by) # labels=gdf['transaction_id'].values)
sales_df = sales_df.to_html()
position_df = position_df.to_html()
merged_df = merged_df.to_html()
gdf = gdf.to_html()
else:
no_data = 'No data is available in this date range'
ctxt = {
'search_form': search_form,
'report_form': report_form,
'sales_df': sales_df,
'position_df': position_df,
'merged_df': merged_df,
'gdf': gdf,
'chart': chart,
'no_data': no_data,
}
return render(request, 'sales/home.html', ctxt)
def home_view(request):
sales_df = None
positions_df = None
merged_df = None
df = None
chart = None
no_data = None
search_form = SalesSearchForm(request.POST or None)
report_form = ReportForm()
if request.method == 'POST':
date_from = request.POST.get('date_from')
date_to = request.POST.get('date_to')
chart_type = request.POST.get('chart_type')
results_by = request.POST.get('results_by')
#print(date_from, date_to, chart_type)
sale_qs = Sale.objects.filter(created__date__lte=date_to, created__date__gte=date_from)
if len(sale_qs) > 0:
sales_df = pd.DataFrame(sale_qs.values())
sales_df['customer_id'] = sales_df['customer_id'].apply(get_customer_from_id) # returns
sales_df['salesman_id'] = sales_df['salesman_id'].apply(get_salesman_from_id)
sales_df['created'] = sales_df['created'].apply(lambda x: x.strftime('%y-%m-%d'))
sales_df['updated'] = sales_df['updated'].apply(lambda x: x.strftime('%y-%m-%d'))
sales_df.rename({'customer_id': 'Customer', 'salesman_id':'Salesperson', 'id': 'sales_id'}, axis=1, inplace=True)
#sales_df['sales_id'] = sales_df['id']
# need to set dataframe to HTML to display
positions_data = []
for sale in sale_qs:
for pos in sale.get_positions():
obj = {
'position_id': pos.id,
'product': pos.product.name,
'quantity': pos.quantity,
'price': pos.price,
'sales_id': pos.get_sales_id(),
}
positions_data.append(obj)
positions_df = pd.DataFrame(positions_data)
#combining sales and positions df
merged_df = pd.merge(sales_df, positions_df, on='sales_id')
df = merged_df.groupby('transaction_id', as_index=False)['price'].agg('sum')
chart = get_chart(chart_type, sales_df, results_by)
positions_df = positions_df.to_html()
sales_df = sales_df.to_html()
merged_df = merged_df.to_html()
df = df.to_html()
else:
no_data = 'No data is available in this date range.'
context = {
'search_form': search_form,
'sales_df': sales_df,
'positions_df': positions_df,
'merged_df': merged_df,
'df': df,
'chart': chart,
'report_form': report_form,
'no_data': no_data,
}
return render(request, 'sales/home.html', context) # with dictionary can specify what you want to pass to template
