def edit_waterproofing(id):
report = Report.query.get(id)
form = ReportForm(obj=report)
if request.method == 'POST':
if request.form['action'] == 'Upload':
form.populate_obj(report)
bim_file = form.bimimg.data
if bim_file and allowed_file(bim_file.filename):
bim_filename = secure_filename(str(uuid.uuid4()) + bim_file.filename)
bim_file.save(os.path.join(app.config['UPLOAD_FOLDER'], bim_filename))
report.bimimg_filename = bim_filename
site_file = form.siteimg.data
if site_file and allowed_file(site_file.filename):
site_filename = secure_filename(str(uuid.uuid4()) + site_file.filename)
site_file.save(os.path.join(app.config['UPLOAD_FOLDER'], site_filename))
report.siteimg_filename = site_filename
report.site_caption = form.site_caption.data
report.date = form.date.data
report.note = form.note.data
report.summary = form.summary.data
db.session.commit()
return redirect(url_for('report_waterproofing'))
elif request.form['action'] == 'Edit Previous':
id_object = form.edit_date.data
r = Report.query.get(id_object.id)
id = r.id
return redirect(url_for('edit_waterproofing', id=id))
elif request.method == 'GET':
return render_template('create_waterproofing.html', form=form, data_type=report.date, action="Edit")
def Page8(request):
if CheckAccess(request,'8') != 'OK':
return render_to_response("auto/notaccess/page8.html")
if request.method == 'POST':
form = ReportForm(request.POST)
if form.is_valid():
start_date = form.cleaned_data['start_date']
end_date = form.cleaned_data['end_date']
report = form.cleaned_data['report']
response = HttpResponse(mimetype="application/ms-excel")
response['Content-Disposition'] = 'attachment; filename=report.xls'
if report == '0':
return Report_0(response,start_date,end_date)
form = ReportForm(None)
c = RequestContext(request,{'form':form})
c.update(csrf(request))
return render_to_response("auto/page8.html",c)
def submit_report(request):
if request.method == "GET":
submit_report_form = ReportForm()
# print submit_report_form
return render(request,'submit_report.html', {'submit_report_form':submit_report_form})
if request.method == 'POST':
submit_report_form = ReportForm(request.POST,request.FILES)
print submit_report_form
if submit_report_form.is_valid():
report = submit_report_form.save(commit=False)
report.profile=UserProfile.objects.get(user=request.user)
report.save()
return show_report(request, report_id=report.id)
return render(request,'submit_report.html', {'submit_report_form':submit_report_form})
def edit_report(request, report_id):
if request.method == 'POST':
r = Report.objects.get(pk=report_id)
if request.FILES:
updated_form = ReportForm(request.POST, request.FILES, instance=r)
r.variant_set.all().delete()
else:
updated_form = ReportForm(request.POST, instance=r)
if updated_form.is_valid():
updated_form.save()
report_parser.load_into_db(r)
return HttpResponseRedirect(reverse('manage_report'))
else:
project_pk = request.session.get('viewing_project', None)
if project_pk is None:
return HttpResponseRedirect(reverse('no_project'))
project = Project.objects.get(pk=project_pk)
report_obj = Report.objects.get(pk=report_id)
rform = ReportForm(instance=report_obj)
rform.fields['study'].queryset = project.study_set.all()
context = {'report_form': rform,
'report': report_obj.report_file,
'pk': report_id,}
context.update(csrf(request))
return render_to_response('viewer/report/edit_report.html', context,
context_instance=RequestContext(request))
def report_paste(request,hash_key):
""" Sends a e-mail to the site administrator, reporting a Paste
"""
entry = get_object_or_404(Paste, hash_key=hash_key)
report_message = ""
if request.method == "POST":
form = ReportForm(request.POST)
if form.is_valid():
reason = form.cleaned_data['reason']
comment = form.cleaned_data['comment']
email = form.cleaned_data['email']
# prepare the e-mail with data submitted by the user
report_body = ''' Paste located at http://incollo.com/%s has been reported with reason '%s'.\n Additional comment: %s .\n User e-mail: %s ''' % (hash_key, reason, comment, email)
# send the e-mail
report = EmailMessage('Report abuse from bd-incollo!',
report_body,
to=settings.MANAGERS[0],
)
report.send()
report_message = "Thank you for your report!"
else:
report_message = "Some fields are either missing or invalid, please complete the form"
report_form = ReportForm() # create a form for reporting the Paste (if needed)
return render_to_response('report_paste.html', {
'report_message': report_message,
'entry': entry,
'report_form': report_form,
},context_instance=RequestContext(request))
def upload_report(request):
if request.method == 'POST':
print "POST from upload_report"
if request.FILES:
rform = ReportForm(request.POST, request.FILES)
else:
rform = ReportForm(request.POST)
if rform.is_valid():
report = rform.save()
report_parser.load_into_db(report)
return HttpResponseRedirect(reverse('manage_report'))
else:
print "rform (ReportForm) is Invalid"
print str(rform)
else:
project_pk = request.session.get('viewing_project', None)
if project_pk is None:
return HttpResponseRedirect(reverse('no_project'))
project = Project.objects.get(pk=project_pk)
rform = ReportForm(instance=Report(), initial={})
rform.fields['study'].queryset = project.study_set.all()
context = {'report_form': rform}
context.update(csrf(request))
return render_to_response('viewer/report/upload_report.html', context,
context_instance=RequestContext(request))
def report():
form = ReportForm()
current_user = flask_login.current_user
if current_user.is_anonymous():
is_admin = False
else:
is_admin = current_user.role == 1
if form.validate_on_submit():
if form.user.data == "000000":
all_tasks = Task.query.all()
if form.user.data != "000000":
all_tasks = Task.query.filter_by(user_id=form.user.data)
tasks_returned = []
for task in all_tasks:
if datetime.datetime(form.year_to.data, form.month_to.data, form.day_to.data) >= datetime.datetime(task.start_year, task.start_month, task.start_day) >= datetime.datetime(form.year_from.data, form.month_from.data, form.day_from.data):
tasks_returned.append(task)
task_list = []
for task in tasks_returned:
task_attributes=[task.id, task.user_id, task.type_label,task.start_weekday, task.start_day, task.start_month, task.start_year, task.end_day, task.end_month, task.end_year, task.start_hour, task.start_minute, task.time_taken]
task_list.append(task_attributes)
with open('app/report.csv', 'wb') as test_file:
file_writer = csv.writer(test_file)
file_writer.writerow(header_list)
for task in task_list:
file_writer.writerow(task)
return render_template("generated_report.html", task_list=task_list, anonymous=current_user.is_anonymous(), user=form.user.data,tasks_returned=tasks_returned, current_user=current_user,
is_admin = is_admin)
return render_template("report.html", form=form, anonymous=current_user.is_anonymous(), current_user=current_user,
is_admin = is_admin)
def addOrUpdateReport():
userId=session['userId']
user=User.getById(userId)
if user is None :
return json.dumps(rs.NO_DATA.__dict__,ensure_ascii=False)
#权限查看
if UserRole.checkRole(db_session,userId,constant.RoleId.Admin) == False:
return json.dumps(rs.PERMISSION_DENY.__dict__,ensure_ascii=False)
form = ReportForm(request.form)
formResult=form.validate()
if formResult.status==rs.SUCCESS.status:
diagnose=Diagnose.getDiagnoseById(form.diagnoseId)
if diagnose is None:
return json.dumps(rs.NO_DATA.__dict__,ensure_ascii=False)
#session['remember_me'] = form.remember_me.data
# login and validate the user...
report = None
if form.reportId:
report=Report.getReportById(form.reportId)
if report.type==constant.ReportType.Doctor:
return json.dumps(rs.PERMISSION_DENY.__dict__,ensure_ascii=False)
Report.update(form.reportId,None,form.status,None,form.techDesc,form.imageDesc,form.diagnoseDesc)
else:
report=Report(form.techDesc,form.imageDesc,form.diagnoseDesc,form.fileUrl,ReportType.Admin,form.status)
Report.save(report)
diagnose.reportId=report.id
Diagnose.save(diagnose)
#flash('成功添加诊断评论')
if form.status and form.status == constant.ReportStatus.Commited:
diagnose=Diagnose.getDiagnoseById(form.diagnoseId)
if diagnose:
Diagnose.changeDiagnoseStatus(diagnose.id,constant.DiagnoseStatus.NeedDiagnose)
if form.reportId is None and report:
form.reportId = report.id
Report.update(form.reportId,constant.ReportType.Doctor,status=constant.ReportStatus.Draft)
if diagnose and hasattr(diagnose,'doctor'):
doctor=diagnose.doctor
if doctor and doctor.userId:
content=dataChangeService.getDoctorNeedDiagnoseMessageContent(diagnose,doctor)
#诊断通知
message=Message(constant.DefaultSystemAdminUserId,doctor.userId,'诊断通知',content,constant.MessageType.Diagnose)
Message.save(message)
#诊断日志
diagoseLog=DiagnoseLog(userId,form.diagnoseId,constant.DiagnoseLogAction.FetchDiagnoseEndAction)
DiagnoseLog.save(db_session,diagoseLog)
return json.dumps(formResult.__dict__,ensure_ascii=False)
return json.dumps(formResult.__dict__,ensure_ascii=False)
def create_report(request):
if request.method == 'GET':
form = ReportForm()
return render_to_response('add_edit_report.html', {'form': form}, context_instance=RequestContext(request))
if request.method == 'POST':
form = ReportForm(request.POST)
if form.is_valid():
new_report = form.save()
return redirect(reverse('edit_report', args=(new_report.id,)))
return render_to_response('add_edit_report.html', {'form': form}, context_instance=RequestContext(request))
def report(authority):
db_auth = Authority.query.filter_by(short=authority).first()
if db_auth == None:
flash('Authority %s not found.' % authority)
return redirect(url_for('index'))
types = Type.query.filter_by(authority_id = db_auth.id).all()
form = ReportForm()
form.type_id.choices = [(t.id, t.name) for t in types]
if form.validate_on_submit():
return after_report(request)
print form.errors
return render_template('report.html',
form=form)
def new_report(request):
if request.method == 'POST':
form = ReportForm(request.POST)
if form.is_valid():
f = form.save(commit=False)
f.created_by = request.user.username
f.save()
messages.success(request, "Created new report: %s." % f.name)
return HttpResponseRedirect(reverse('reports.views.view_report',
kwargs={'report':f.slug}))
else:
form = ReportForm()
return render(request, 'reports/new_report.html', {'form': form })
def addreport(request):
if request.method == 'POST':
form = ReportForm(request.POST)
if form.is_valid():
report = Report()
report.headline = form.cleaned_data.get("headline")
report.content = form.cleaned_data.get("content")
report.reporter = request.user.username
report.date = datetime.now()
report.save()
return HttpResponseRedirect(reverse('news:index'))
else:
form = ReportForm()
return render_to_response('news/addreport.html', {'form':form}, context_instance=RequestContext(request))
def reports():
form = ReportForm()
if form.validate_on_submit():
if form.department.data != 100:
department = Department.query.filter(Department.id ==
form.department.data).first()
csv = create_csv(department)
else:
csv = '\n'.join(sorted([create_csv(department)
for department in Department.query.all()]))
response = make_response(csv)
response.headers[
'Content-Disposition'] = "attachment; filename=report.csv"
return response
return render_template('reports.html', form=form)
def ItReport(request):
if CheckAccess(request,'17') != 'OK':
return render_to_response("ithelpdesk/notaccess/report.html")
### --- Сохранение закладки ----
request.session['bookmark'] = 'itreport'
if request.method == 'POST':
form = ReportForm(request.POST)
if form.is_valid():
start_date = form.cleaned_data['start_date']
end_date = form.cleaned_data['end_date']
request.session['start_date'] = start_date
request.session['end_date'] = end_date
try:
start_date = request.session['start_date']
end_date = request.session['end_date']
except:
start_date = datetime.date.today()
end_date = datetime.date.today()
form = ReportForm(None)
form.fields['start_date'].initial = start_date
form.fields['end_date'].initial = end_date
data = GetDataReport(start_date,end_date)
### --- вывод в excel файл ---
try:
report_excel = request.GET['report-excel']
response = HttpResponse(mimetype="application/ms-excel")
response['Content-Disposition'] = 'attachment; filename=report.xls'
return ItReportFile(start_date,end_date,response,data)
except:
pass
c = RequestContext(request,{'form':form,'data':data})
c.update(csrf(request))
return render_to_response("ithelpdesk/report.html",c)
def report():
form = ReportForm()
if current_user.is_admin:
form.user.choices = [(g.uid, g.login) for g in User.query.order_by('name')]
else:
form.user.choices = [(g.uid, g.login) for g in current_user.subusers]
form.user.choices.append((current_user.uid, current_user.login))
form.user.choices.insert(0,(-1, u"Все пользователи"))
if request.method == "POST":
if form.validate():
title = CONST.INVOICE_NAME[form.inv_type.data]
rpt_filter = [Invoice.inv_type==form.inv_type.data]
filter_text = u''
if form.org_uid.data != u'':
filter_text = filter_text + u'Организация: ' + form.org.data + ' '
rpt_filter.append(Invoice.org_uid==form.org_uid.data)
if form.agent_uid.data !=u'':
filter_text = filter_text + u'Контрагент: ' + form.agent.data + ' '
rpt_filter.append(Invoice.agent_uid==form.agent_uid.data)
if form.user.data !=-1:
filter_text = filter_text + u"Пользователь: " + User.query.get(form.user.data).login + ' '
rpt_filter.append(Invoice.user_uid==form.user.data)
if form.dbegin.data is not None:
filter_text = filter_text + u'с ' + datetime.strftime(form.dbegin.data, '%d.%m.%Y') + ' '
rpt_filter.append(Invoice.dinvoice>=datetime.combine(form.dbegin.data, datetime.min.time()))
if form.dend.data is not None:
filter_text = filter_text + u'по ' + datetime.strftime(form.dend.data, '%d.%m.%Y') + ' '
rpt_filter.append(Invoice.dinvoice<=datetime.combine(form.dend.data, datetime.max.time()))
invoices = current_user.available_invoices(inv_type=form.inv_type.data, rpt_filter=rpt_filter)
if form.agent_inn.data != u'':
filer_text = filer_text + u'ИНН Контрагента: ' + form.agent_inn.data + ' '
invoices.join(Agent).filter(Agent.inn.contains(form.agent_inn.data))
sums = invoices.with_entities(func.sum(Invoice.sum_snds),
func.sum(Invoice.sum_no_nds18),
func.sum(Invoice.sum_nds18),
func.sum(Invoice.sum_no_nds10),
func.sum(Invoice.sum_nds10),
func.sum(Invoice.commission)).first()
if request.form['submit']==u'excel':
return export_xls(title, filter_text, invoices)
else:
return render_template("report.html", invoices=invoices.all(),
dbegin=Settings.dbegin(),
dend=Settings.dend(),
sums=sums, title=title, filter_text=filter_text)
return render_template("frmReport.html", form=form)
def create_report():
return_url = request.referrer or '/'
form = ReportForm()
if form.validate_on_submit():
report = Report(category=form.category.data,
description=form.description.data,
address=form.address.data)
if current_user.team_id:
report.team_id = current_user.team_id
db.session.add(report)
db.session.commit()
if not current_user.is_admin:
create_new_notification(1, report)
flash('!הדיווח נוצר בהצלחה', 'success')
return redirect(url_for('reports'))
return render_template('/create_report.html',
form=form,
legend="יצירת דיווח",
return_url=return_url)
def edit_report(request, report_id):
if request.method == 'POST':
r = Report.objects.get(pk=report_id)
if request.FILES:
updated_form = ReportForm(request.POST, request.FILES, instance=r)
else:
updated_form = ReportForm(request.POST, instance=r)
if updated_form.is_valid():
updated_form.save()
return HttpResponseRedirect('/viewer/report')
else:
report_obj = Report.objects.get(pk=report_id)
rform = ReportForm(instance=report_obj)
context = {'report_form': rform,
'report': report_obj.report_file,
'pk': report_id,}
context.update(csrf(request))
return render_to_response('viewer/report/edit_report.html', context,
context_instance=RequestContext(request))
def board_catalog(board_name, boards):
posts = get_boards_posts(board_name)
report = ReportForm()
return render_template(
'catalog.html',
board_name=board_name,
boards=boards,
posts=posts,
report_form=report,
)
def report():
form = ReportForm()
ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
#print(request.environ.get('HTTP_X_REAL_IP', request.remote_addr))
if form.validate_on_submit(): #form.method == 'POST'
#request.get_json()["ip"]
id = Note.getNote(session["randomNote"]["lookupId"]).lookupId
comments = ""
if request.form:
comments = request.form["comments"]
session.clear()
msg = Message("Someone reported a post!", sender="*****@*****.**", recipients=["*****@*****.**"])
msg.body = "Note UUID: " + id + "\n" + "Comments: " + comments + "\n" + "IP Address: " + ip
mail.send(msg)
return render_template("success.html")
try:
return render_template("report.html", form=form, note=Note.getNote(session["randomNote"]["lookupId"]), ip=ip)
except:
return render_template("error/403.html"), 403
def reporting(request):
from forms import ReportForm
from analytics import get_html, get_html_table, get_flash_chart
from models import Users
report = ""
errors = []
if request.POST:
report_form = ReportForm(request.POST)
if report_form.is_valid():
if request.session.has_key("analytics"):
aa_obj = request.session['analytics']
else:
user = Users.objects.get(organization=request.organization)
aa_obj = AqAnalytics(user_name=user.email,
password=user.password)
aa_obj.authenticate()
if report_form.cleaned_data['chart_type'] == 'table':
report, row_count, is_valid = aa_obj.DataFeedQuery(
parse_as='flat', **report_form.cleaned_data)
if is_valid == True:
report = get_html_table(report[0], report[1], row_count)
elif report_form.cleaned_data['chart_type'][:5] == 'chart':
report = get_flash_chart(**report_form.cleaned_data)
else:
report = ''
errors = is_valid
else:
report_form = ReportForm(
initial={"table_id": request.analytics.selected_site})
if request.is_ajax():
return report
else:
return render_to_response("reports.html", {
"report": report,
"form": report_form,
'error_list': errors
},
context_instance=RequestContext(request))
def edit_global_report(request, month=0, day=0, year=0):
projects = Project.objects.all()
if request.method == 'POST':
form = ReportForm(request.POST)
if form.is_valid():
try:
q = DailyReport.objects.filter(date=form.cleaned_data['date'])
report = q[0] if q else DailyReport(date=form.cleaned_data['date'])
report.description = form.cleaned_data['personalReport']
report.save()
return redirect('daily_reports.views.edit_global_report')
except Exception as e:
print(e)
return render_to_response('daily_reports/daily_report_form.html', {'form': form, 'global': True, "projects": projects}, context_instance=RequestContext(request))
else:
return render_to_response('daily_reports/daily_report_form.html', {'form': form, 'global': True, "projects": projects}, context_instance=RequestContext(request))
else:
d = date.today()
if (year != 0):
try:
d = date(int(year), int(month), int(day))
except:
return redirect('daily_reports.views.edit_global_report')
if (d.year < 2013 or d.year > date.today().year + 1):
return redirect('daily_reports.views.edit_global_report')
q = None
try:
q = DailyReport.objects.filter(date=d)
except Exception as e:
print("Exception: " + str(e))
raise e
if q:
form = ReportForm(initial={"date": d, "personalReport": q[0].description})
else:
form = ReportForm(initial={"date": d})
return render_to_response("daily_reports/daily_report_form.html", {'form': form, 'global': True, "projects": projects}, context_instance=RequestContext(request))
def edit_report(request, report_id):
report = Report.objects.get(id=report_id)
if request.method == 'GET':
form = ReportForm(instance=report)
return render_to_response('add_edit_report.html',
{'form':form, 'editing':True, 'report':report},
context_instance=RequestContext(request)
)
if request.method == 'POST':
form = ReportForm(request.POST, instance=report)
if form.is_valid():
report = form.save()
return redirect(reverse('report_home'))
return render_to_response('add_edit_report.html',
{'form':form, 'editing':True, 'report':report},
context_instance=RequestContext(request)
)
def reporting(request):
from forms import ReportForm
from analytics import get_html, get_html_table, get_flash_chart
from models import Users
report = ""
errors = []
if request.POST:
report_form = ReportForm(request.POST)
if report_form.is_valid():
if request.session.has_key("analytics"):
aa_obj = request.session["analytics"]
else:
user = Users.objects.get(organization=request.organization)
aa_obj = AqAnalytics(user_name=user.email, password=user.password)
aa_obj.authenticate()
if report_form.cleaned_data["chart_type"] == "table":
report, row_count, is_valid = aa_obj.DataFeedQuery(parse_as="flat", **report_form.cleaned_data)
if is_valid == True:
report = get_html_table(report[0], report[1], row_count)
elif report_form.cleaned_data["chart_type"][:5] == "chart":
report = get_flash_chart(**report_form.cleaned_data)
else:
report = ""
errors = is_valid
else:
report_form = ReportForm(initial={"table_id": request.analytics.selected_site})
if request.is_ajax():
return report
else:
return render_to_response(
"reports.html",
{"report": report, "form": report_form, "error_list": errors},
context_instance=RequestContext(request),
)
def report(ownerEmail):
form = ReportForm()
if request.method == 'GET':
return render_template('report.html', form=form)
elif request.method == 'POST':
description = form.description.data
date = form.dateOfOffense.data
todaysDate = datetime.date(datetime.now())
db = get_db()
cur = db.cursor()
cur.execute(
"INSERT INTO REPORT (User_email, Reported_user_email, Admin_ID, Offense_description, Date_of_offense, Date_of_report) VALUES (?,?,?,?,?,?)",
(g.user['Email'], ownerEmail, None, description, date, todaysDate))
db.commit()
return redirect(url_for('renterTransactions'))
def board_post(board_name, post_id, boards):
post = get_post(post_id)
if not post:
abort(404)
replies = get_post_replies(post_id)
report = ReportForm()
return render_template(
'post.html',
board_name=board_name,
boards=boards,
post=post,
replies=replies,
report_form=report,
)
def report(request):
if request.method == 'POST':
name = request.user.username
profile = get_object_or_404(Peep, username=name)
form = ReportForm(request.POST, instance=profile)
form.save()
return redirect('home')
else:
form = ReportForm()
return render(request, 'report.html', {'form': form})
def upload_report(request):
if request.method == 'POST':
rform = ReportForm(request.POST, request.FILES)
if rform.is_valid():
rform.save()
return HttpResponseRedirect('/viewer/upload_report/')
else:
rform = ReportForm(instance=Report())
context = {'report_form': rform}
reports = Report.objects.all()
context['reports'] = reports
context.update(csrf(request))
return render_to_response('viewer/upload_report.html',
context,
context_instance=RequestContext(request))
def new_report(request):
if request.method == 'POST':
form = ReportForm(request.POST)
if form.is_valid():
f = form.save(commit=False)
f.created_by = request.user.username
f.save()
messages.success(request, "Created new report: %s." % f.name)
return HttpResponseRedirect(reverse('reports.views.view_report',
kwargs={'report':f.slug}))
else:
form = ReportForm()
return render(request, 'reports/new_report.html', {'form': form })
def home(ip):
boards = get_boards()
posts = get_recent_posts(n=6)
feedback = FeedbackForm()
report = ReportForm()
if feedback.validate_on_submit():
subject = feedback.subject.data
message = feedback.message.data
create_feedback(subject, message, ip)
flash(FEEDBACK_MSG)
return redirect(url_for('home'))
return render_template(
'home.html',
boards=boards,
posts=posts,
feedback_form=feedback,
report_form=report,
rules=RULES,
)
def upload_report(request):
if request.method == 'POST':
print "POST from upload_report"
if request.FILES:
rform = ReportForm(request.POST, request.FILES)
else:
rform = ReportForm(request.POST)
if rform.is_valid():
rform.save()
return HttpResponseRedirect('/viewer/report/')
else:
print "rform (ReportForm) is Invalid"
print str(rform)
else:
rform = ReportForm(instance=Report(), initial={})
context = {'report_form': rform}
context.update(csrf(request))
return render_to_response('viewer/report/upload_report.html', context,
context_instance=RequestContext(request))
def issue(request, issue_id, context=None):
if context is None:
context = {}
current_issue = get_object_or_404(Issue, pk=issue_id)
comment_form = CommentForm()
description_form = DescriptionForm(instance=current_issue)
report_form = ReportForm(instance=current_issue)
control_form = ControlForm(instance=current_issue)
if request.method == 'POST':
if 'comment_form' in request.POST:
comment_form = CommentForm(request.POST)
if comment_form.is_valid():
curr_comment = comment_form.save(commit=False)
curr_comment.author = request.user
curr_comment.issue = current_issue
curr_comment.save()
comment_form = CommentForm()
if 'description_form' in request.POST:
description_form = DescriptionForm(request.POST, instance=current_issue)
if description_form.is_valid():
description_form.save()
description_form = DescriptionForm(instance=current_issue)
if 'report_form' in request.POST:
report_form = ReportForm(request.POST, instance=current_issue)
if report_form.is_valid():
report_form.save()
report_form = ReportForm(instance=current_issue)
if 'control_form' in request.POST:
control_form = ControlForm(request.POST, instance=current_issue)
if control_form.is_valid():
control_form.save()
control_form = ControlForm(instance=current_issue)
context['issue'] = current_issue
context['comment_form'] = comment_form
context['description_form'] = description_form
context['report_form'] = report_form
context['control_form'] = control_form
context['status_list'] = Status.objects.all()
return render(request, 'helpdesk/issue.html', context)
def advertiser_reports(request):
from atrinsic.base.models import Organization,PublisherGroup,UserAqWidget,AqWidget, Report_Adv_Pub
from forms import ReportForm
inits = {}
inits = {
'start_date':request.GET.get('start_date',None),
'end_date':request.GET.get('end_date',None),
'group_by':request.GET.get('group_by',0),
'run_reporting_by':request.GET.get('run_reporting_by',0),
'report_type':request.GET.get('report_type',0),
'specific_advertiser':request.GET.get('specific_advertiser',None),
'advertiser_category':request.GET.get('advertiser_category',None),
'run_reporting_by_publisher':request.GET.getlist('run_reporting_by_publisher'),
'run_reporting_by_vertical':request.GET.getlist('run_reporting_by_vertical'),
'run_reporting_by_group':request.GET.getlist('run_reporting_by_group'),
}
this_page = 'advertiser-reports'
form = ReportForm(request.organization,inits)
refilter=0
widget_report = None
if request.GET:
if form.is_valid():
refilter=1
date_start,date_end = time_period(form)
if date_start == None:
date_start = datetime.datetime.now()
if date_end == None:
date_end = datetime.datetime.now()
all_publishers = Organization.objects.filter(advertiser_relationships__status=RELATIONSHIP_ACCEPTED,
advertiser_relationships__advertiser=request.organization)
pids = []
if form.cleaned_data["run_reporting_by"] == '0': # all publishers
pids = [j.id for j in all_publishers]
elif form.cleaned_data["run_reporting_by"] == '3': # specific publisher
if inits.has_key("run_reporting_by_publisher"):
pids.extend([int(x[2:]) for x in inits["run_reporting_by_publisher"]])
else:
pids = []
for j in all_publishers:
pids.append(j.id)
elif form.cleaned_data["run_reporting_by"] == '2': # publisher by category
pids = []
for j in all_publishers:
for site in j.website_set.all():
try:
if site.vertical in form.cleaned_data["run_reporting_by_vertical"]:
pids.append(j.id)
except:
print ' - web site with bad vertical: %s -- %s' % (site,site.id)
elif form.cleaned_data["run_reporting_by"] == '1': # publisher by group
for g_id in form.cleaned_data["run_reporting_by_group"]:
group = PublisherGroup.objects.get(id=int(g_id[2:]))
pids.extend([g.id for g in group.publishers.all()])
z,created = UserAqWidget.objects.get_or_create(page=this_page,zone=4,organization=request.organization, widget=AqWidget.objects.get(pk=form.cleaned_data["report_type"]))
z.custom_date_range = date_start.strftime('%m/%d/%Y')+","+date_end.strftime('%m/%d/%Y')
z.save()
widget = UserAqWidget.prep([z],request,pids)
widget_report = widget[0]
else:
report = None
form = ReportForm(request.organization)
if request.GET.get("target",None) or int(request.GET['report_type']) == REPORTTYPE_ORDER_DETAIL:
if int(request.GET['report_type']) == REPORTTYPE_ORDER_DETAIL:
target = REPORTFORMAT_CSV
else:
target = int(request.GET.get("target"))
from AqWidgets import QuickReports
if int(form.cleaned_data["report_type"]) == REPORTTYPE_SALES:
report = DateReport(date_start,date_end,request.organization,group_by=form.cleaned_data["group_by"], spec=REPORTTYPE_SALES, publisher_set=pids)
if form.cleaned_data["report_type"] == REPORTTYPE_SALES_BY_PUBLISHER:
report = OrgDateReport(date_start,date_end,request.organization,group_by=form.cleaned_data["group_by"], spec=REPORTTYPE_SALES_BY_PUBLISHER, publisher_set=pids)
if form.cleaned_data["report_type"] == REPORTTYPE_REVENUE:
report = RevenueReport(date_start,date_end,request.organization,group_by=form.cleaned_data["group_by"], spec=REPORTTYPE_REVENUE, publisher_set=pids)
if form.cleaned_data["report_type"] == REPORTTYPE_REVENUE_BY_PUBLISHER:
report = OrgRevenueReport(date_start,date_end,request.organization,group_by=form.cleaned_data["group_by"], spec=REPORTTYPE_REVENUE_BY_PUBLISHER, publisher_set=pids)
if form.cleaned_data["report_type"] == REPORTTYPE_CREATIVE:
report = CreativeReport(date_start,date_end,request.organization,group_by=form.cleaned_data["group_by"], spec=REPORTTYPE_CREATIVE, publisher_set=pids)
if form.cleaned_data["report_type"] == REPORTTYPE_CREATIVE_BY_PROMO:
report = PromoReport(date_start,date_end,request.organization,group_by=form.cleaned_data["group_by"], spec=REPORTTYPE_CREATIVE_BY_PROMO, publisher_set=pids)
if form.cleaned_data["report_type"] == REPORTTYPE_ORDER_DETAIL:
report = OrderReport(date_start,date_end,request.organization,group_by=form.cleaned_data["group_by"], spec=REPORTTYPE_ORDER_DETAIL, publisher_set=pids)
if form.cleaned_data["report_type"] == REPORTTYPE_ACCOUNTING:
report = AccountingReport(date_start,date_end,request.organization,group_by=form.cleaned_data["group_by"], spec=REPORTTYPE_ACCOUNTING, publisher_set=pids)
if target == REPORTFORMAT_EXCEL:
from atrinsic.util.xls import write_rows
import tempfile
file_id,file_path = tempfile.mkstemp()
res = [[]]
for row in report.RenderHeader():
res[0].append(row[0])
for row in report.RenderContents():
res.append(row)
last_row = []
res.append([])
for row in report.RenderFooter():
last_row.append(row[1])
res.append(last_row)
#return HttpResponse(str(res))
write_rows(file_path,res)
res = open(file_path).read()
#return HttpResponse(str(res))
response = HttpResponse(res,mimetype="application/vnd.ms-excel")
response['Content-Disposition'] = 'attachment; filename=download.xls'
return response
""" Old way of doing it"""
response = render_to_response("misc/reports/dataxls.html", {'report': report,})
filename = "misc/reports/download.xls"
response['Content-Disposition'] = 'attachment; filename='+filename
response['Content-Type'] = 'application/vnd.ms-excel; charset=utf-8'
return response
elif target == REPORTFORMAT_CSV:
response = HttpResponse(render_to_string("misc/reports/download.csv",{"report":report}),mimetype="text/csv")
response['Content-Disposition'] = 'attachment; filename=report.csv'
return response
elif target == REPORTFORMAT_TSV:
response = HttpResponse(render_to_string("misc/reports/download.txt",{"report":report}),mimetype="application/octet-stream")
response['Content-Disposition'] = 'attachment; filename=report.txt'
return response
return AQ_render_to_response(request, "advertiser/reports/index.html",{
"form":form,
'refilter':refilter,
"widget":widget_report,
"reporting":1,
"url": 'advertiser/reports/download'#request.META['REQUEST_URI'].replace('advertiser/reports','advertiser/reports/download'),
},context_instance=RequestContext(request))
def report(request, *args):
"""View that renders a report page to fetch all items sold under three
constraints which are: Category, Begin Date/Time and End Date/Time."""
if request.GET:
form = ReportForm(request.GET)
if form.is_valid():
date_start = form.cleaned_data['date_start']
date_end = form.cleaned_data['date_end']
sel_server = form.cleaned_data['sel_server']
qs = Bill.objects.filter(deleted_by='')
if date_start:
qs = qs.filter(date__gte=date_start)
if date_end:
qs = qs.filter(date__lte=date_end)
if sel_server:
qs = qs.filter(server__in=[s for s in sel_server])
if not qs.exists():
return render(request, 'webpos/report.html',
{'form': form,
# 'report': None,
'qs_empty': True})
report_dict = {}
for category in Category.objects.all():
report_dict[category] = {'itemss': {},
'items_sold': 0,
'total_price': Decimal(0.00)
}
for item in category.item_set.all():
clear = {'quantity': 0, 'price': Decimal(0.00)}
report_dict[category]['itemss'][item] = clear
total_earn = Decimal(0)
total_cash = Decimal(0)
for bill in qs:
total_cash += bill.total
for billitem in bill.billitem_set.all():
quantity = billitem.quantity
price = billitem.item_price * billitem.quantity
entry_category = report_dict[billitem.category]
entry_category['items_sold'] += quantity
entry_category['total_price'] += abs(price)
entry_item = entry_category['itemss'][billitem.item]
entry_item['quantity'] += quantity
entry_item['price'] += abs(price)
if price > 0:
total_earn += price
for extra in billitem.billitemextra_set.all():
entry_category['items_sold'] += extra.quantity * billitem.quantity
entry_category['total_price'] += extra.total_cost
entry_item = entry_category['itemss'][extra.item]
entry_item['quantity'] += extra.quantity * billitem.quantity
entry_item['price'] += extra.total_cost
total_earn += extra.total_cost
return render(request, 'webpos/report.html',
{'form': form,
'report': report_dict,
'total_earn': total_earn,
'total_cash': total_cash,
# 'qs_empty': False
})
else:
return render(request, 'webpos/report.html',
{'form': 'Form Error!',
# 'qs_empty': qs_empty
})
else:
form = ReportForm()
return render(request, 'webpos/report.html',
{'form': form,
# 'qs_empty': qs_empty
})
def report_home(request):
data = {}
systems = None
initial = {
'system_type': ['SYSTEM'],
'site': ['-1'],
'system_status': ['-1'],
}
if request.method == 'POST':
form = ReportForm(request.POST)
if form.is_valid():
search_q = Q()
allocation = request.POST.get('allocation', '')
server_models = request.POST.get('server_models', '')
operating_system = request.POST.get('operating_system', '')
system_status = request.POST.getlist('system_status')
site = request.POST.get('site')
systems = System.objects.all()
if 'SYSTEM' in request.POST.getlist('system_type'):
if site:
if '-1' not in request.POST.getlist('site'):
for site in request.POST.getlist('site'):
search_q |= Q(system_rack__site__id=site)
total_count = System.with_related.filter(
search_q).count()
systems = systems.filter(search_q)
if allocation != '':
systems = systems.filter(Q(allocation=allocation))
if server_models != '':
systems = systems.filter(
Q(server_model__model__icontains=server_models)
| Q(server_model__vendor__icontains=server_models))
if operating_system != '':
systems = systems.filter(
Q(operating_system__name__icontains=operating_system) |
Q(operating_system__version__icontains=operating_system
))
if '-1' not in system_status:
the_query = Q()
for ss in system_status:
the_query |= Q(system_status__id=ss)
systems = systems.filter(the_query)
total_count = systems.count()
if 'UNMANAGED' in request.POST.getlist('system_type'):
pass
data['content'] = str(total_count)
if 'CSV' == request.POST['output']:
response = HttpResponse(mimetype='text/csv')
response[
'Content-Disposition'] = 'attachment; filename=inventory_report.csv'
writer = csv.writer(response)
columns = [
'Hostname',
'Asset Tag',
'Purchase Date',
'Server Model',
'Serial',
'Status',
'Purchase Price',
'Operating System',
'Site',
]
writer.writerow(columns)
for system in systems:
writer.writerow([
system.hostname,
system.asset_tag,
system.purchase_date,
system.server_model,
system.serial,
system.system_status,
system.purchase_price,
system.operating_system
if system.operating_system else '',
system.system_rack.site if system.system_rack else '',
])
return response
if 'SCREEN' == request.POST['output']:
template = 'reports/index.html'
else:
form = ReportForm(request.POST)
data['form'] = form
template = 'reports/index.html'
else:
form = ReportForm(initial=initial)
data['form'] = form
template = 'reports/index.html'
return jinja_render_to_response(template, {
'systems': systems,
'form': form
})
def addOrUpdateReport():
userId = session['userId']
user = User.getById(userId)
if user is None:
return json.dumps(rs.NO_DATA.__dict__, ensure_ascii=False)
#权限查看
if UserRole.checkRole(db_session, userId, constant.RoleId.Admin) == False:
return json.dumps(rs.PERMISSION_DENY.__dict__, ensure_ascii=False)
form = ReportForm(request.form)
formResult = form.validate()
if formResult.status == rs.SUCCESS.status:
diagnose = Diagnose.getDiagnoseById(form.diagnoseId)
if diagnose is None:
return json.dumps(rs.NO_DATA.__dict__, ensure_ascii=False)
#session['remember_me'] = form.remember_me.data
# login and validate the user...
report = None
if form.reportId:
report = Report.getReportById(form.reportId)
if report.type == constant.ReportType.Doctor:
return json.dumps(rs.PERMISSION_DENY.__dict__,
ensure_ascii=False)
Report.update(form.reportId, None, form.status, None,
form.techDesc, form.imageDesc, form.diagnoseDesc)
else:
report = Report(form.techDesc, form.imageDesc, form.diagnoseDesc,
form.fileUrl, ReportType.Admin, form.status)
Report.save(report)
diagnose.reportId = report.id
Diagnose.save(diagnose)
#add report and diagnose to relation table
reportDiagnoseRelation = ReportDiagnoseRelation(
report.id, diagnose.id)
ReportDiagnoseRelation.save(reportDiagnoseRelation)
#flash('成功添加诊断评论')
if form.status and form.status == constant.ReportStatus.Commited:
diagnose = Diagnose.getDiagnoseById(form.diagnoseId)
if diagnose:
Diagnose.changeDiagnoseStatus(
diagnose.id, constant.DiagnoseStatus.NeedDiagnose)
if form.reportId is None and report:
form.reportId = report.id
#copy a report and add to relation table
newReport = Report(form.techDesc, form.imageDesc,
form.diagnoseDesc, form.fileUrl,
ReportType.Doctor, constant.ReportStatus.Draft)
Report.save(newReport)
reportDiagnoseRelation = ReportDiagnoseRelation(
newReport.id, diagnose.id)
ReportDiagnoseRelation.save(reportDiagnoseRelation)
diagnose.reportId = newReport.id
Diagnose.save(diagnose)
#end copy
if diagnose and hasattr(diagnose, 'doctor'):
doctor = diagnose.doctor
if doctor and doctor.userId:
content = dataChangeService.getDoctorNeedDiagnoseMessageContent(
diagnose, doctor)
#诊断通知
message = Message(constant.DefaultSystemAdminUserId,
doctor.userId, '诊断通知', content,
constant.MessageType.Diagnose)
Message.save(message)
#诊断日志
diagoseLog = DiagnoseLog(
userId, form.diagnoseId,
constant.DiagnoseLogAction.FetchDiagnoseEndAction)
DiagnoseLog.save(db_session, diagoseLog)
return json.dumps(formResult.__dict__, ensure_ascii=False)
return json.dumps(formResult.__dict__, ensure_ascii=False)
def report_home(request):
data = {}
systems = None
initial = {
'system_type': ['SYSTEM'],
'site': ['-1'],
'system_status': ['-1'],
}
if request.method == 'POST':
form = ReportForm(request.POST)
if form.is_valid():
search_q = Q()
allocation = request.POST.get('allocation', '')
server_models = request.POST.get('server_models', '')
operating_system = request.POST.get('operating_system', '')
system_status = request.POST.getlist('system_status')
site = request.POST.get('site')
systems = System.objects.all()
if 'SYSTEM' in request.POST.getlist('system_type'):
if site:
if '-1' not in request.POST.getlist('site'):
for site in request.POST.getlist('site'):
search_q |= Q(system_rack__site__id=site)
total_count = System.with_related.filter(search_q).count()
systems = systems.filter(search_q)
if allocation != '':
systems = systems.filter(Q(allocation=allocation))
if server_models != '':
systems = systems.filter(Q(server_model__model__icontains=server_models)|Q(server_model__vendor__icontains=server_models))
if operating_system != '':
systems = systems.filter(Q(operating_system__name__icontains=operating_system)|Q(operating_system__version__icontains=operating_system))
if '-1' not in system_status:
the_query = Q()
for ss in system_status:
the_query |= Q(system_status__id=ss)
systems = systems.filter(the_query)
total_count = systems.count()
if 'UNMANAGED' in request.POST.getlist('system_type'):
pass
data['content'] = str(total_count)
if 'CSV' == request.POST['output']:
response = HttpResponse(mimetype='text/csv')
response['Content-Disposition'] = 'attachment; filename=inventory_report.csv'
writer = csv.writer(response)
columns = [
'Hostname',
'Asset Tag',
'Purchase Date',
'Server Model',
'Serial',
'Status',
'Purchase Price',
'Operating System',
'Site',
]
writer.writerow(columns)
for system in systems:
writer.writerow([
system.hostname,
system.asset_tag,
system.purchase_date,
system.server_model,
system.serial,
system.system_status,
system.purchase_price,
system.operating_system if system.operating_system else '',
system.system_rack.site if system.system_rack else '',
])
return response
if 'SCREEN' == request.POST['output']:
template = 'reports/index.html'
else:
form = ReportForm(request.POST)
data['form'] = form
template = 'reports/index.html'
else:
form = ReportForm(initial=initial)
data['form'] = form
template = 'reports/index.html'
return jinja_render_to_response(template, {
'systems': systems,
'form': form
})
def report_new(request):
return render(request, 'ddos/templates/report/new.html',
{'form': ReportForm()})
def report(request, *args):
"""View that renders a report page to fetch all items sold under three
constraints which are: Category, Begin Date/Time and End Date/Time."""
if request.GET:
form = ReportForm(request.GET)
if form.is_valid():
date_start = form.cleaned_data['date_start']
date_end = form.cleaned_data['date_end']
sel_server = form.cleaned_data['sel_server']
qs = Bill.objects.filter(deleted_by='')
if date_start:
qs = qs.filter(date__gte=date_start)
if date_end:
qs = qs.filter(date__lte=date_end)
if sel_server:
qs = qs.filter(server__in=[s for s in sel_server])
if not qs.exists():
return render(
request,
'webpos/report.html',
{
'form': form,
# 'report': None,
'qs_empty': True
})
report_dict = {}
for category in Category.objects.all():
report_dict[category] = {
'itemss': {},
'items_sold': 0,
'total_price': Decimal(0.00)
}
for item in category.item_set.all():
clear = {'quantity': 0, 'price': Decimal(0.00)}
report_dict[category]['itemss'][item] = clear
total_earn = Decimal(0)
total_cash = Decimal(0)
for bill in qs:
total_cash += bill.total
for billitem in bill.billitem_set.all():
quantity = billitem.quantity
price = billitem.item_price * billitem.quantity
entry_category = report_dict[billitem.category]
entry_category['items_sold'] += quantity
entry_category['total_price'] += abs(price)
entry_item = entry_category['itemss'][billitem.item]
entry_item['quantity'] += quantity
entry_item['price'] += abs(price)
if price > 0:
total_earn += price
for extra in billitem.billitemextra_set.all():
entry_category[
'items_sold'] += extra.quantity * billitem.quantity
entry_category['total_price'] += extra.total_cost
entry_item = entry_category['itemss'][extra.item]
entry_item[
'quantity'] += extra.quantity * billitem.quantity
entry_item['price'] += extra.total_cost
total_earn += extra.total_cost
return render(
request,
'webpos/report.html',
{
'form': form,
'report': report_dict,
'total_earn': total_earn,
'total_cash': total_cash,
# 'qs_empty': False
})
else:
return render(
request,
'webpos/report.html',
{
'form': 'Form Error!',
# 'qs_empty': qs_empty
})
else:
form = ReportForm()
return render(
request,
'webpos/report.html',
{
'form': form,
# 'qs_empty': qs_empty
})
def report_home(request):
data = {}
systems = None
initial = {"system_type": ["SYSTEM"], "location": ["-1"], "system_status": ["-1"]}
if request.method == "POST":
form = ReportForm(request.POST)
if form.is_valid():
search_q = Q()
allocation = request.POST.get("allocation", "")
server_models = request.POST.get("server_models", "")
operating_system = request.POST.get("operating_system", "")
system_status = request.POST.getlist("system_status")
location = request.POST.get("location")
systems = System.objects.all()
if "SYSTEM" in request.POST.getlist("system_type"):
if location:
if "-1" not in request.POST.getlist("location"):
for location in request.POST.getlist("location"):
search_q |= Q(system_rack__location__id=location)
total_count = System.with_related.filter(search_q).count()
systems = systems.filter(search_q)
if allocation != "":
systems = systems.filter(Q(allocation=allocation))
if server_models != "":
systems = systems.filter(
Q(server_model__model__icontains=server_models)
| Q(server_model__vendor__icontains=server_models)
)
if operating_system != "":
systems = systems.filter(
Q(operating_system__name__icontains=operating_system)
| Q(operating_system__version__icontains=operating_system)
)
if "-1" not in system_status:
the_query = Q()
for ss in system_status:
the_query |= Q(system_status__id=ss)
systems = systems.filter(the_query)
total_count = systems.count()
if "UNMANAGED" in request.POST.getlist("system_type"):
pass
data["content"] = str(total_count)
if "CSV" == request.POST["output"]:
response = HttpResponse(mimetype="text/csv")
response["Content-Disposition"] = "attachment; filename=inventory_report.csv"
writer = csv.writer(response)
columns = [
"Hostname",
"Asset Tag",
"Purchase Date",
"Server Model",
"Serial",
"Status",
"Purchase Price",
"Operating System",
"Location",
]
writer.writerow(columns)
for system in systems:
writer.writerow(
[
system.hostname,
system.asset_tag,
system.purchase_date,
system.server_model,
system.serial,
system.system_status,
system.purchase_price,
system.operating_system if system.operating_system else "",
system.system_rack.location if system.system_rack else "",
]
)
return response
if "SCREEN" == request.POST["output"]:
template = "reports/index.html"
else:
form = ReportForm(request.POST)
data["form"] = form
template = "reports/index.html"
else:
form = ReportForm(initial=initial)
data["form"] = form
template = "reports/index.html"
return jinja_render_to_response(template, {"systems": systems, "form": form})
