def postReport(request):
if request.method == 'POST':
# print request.POST
# print request.POST.get('additionalComments')
categoryObject = Category.objects.get(
animal_type=request.POST.get('animalType'))
latitude = request.POST.get('latitude')
longitude = request.POST.get('longitude')
mobile_number = request.POST.get('mobileNumber')
image_path = request.POST.get('imagePath')
additional_comments = request.POST.get('additionalComments')
webUrl = (
"http://maps.googleapis.com/maps/api/geocode/json?latlng=%s,%s" %
(latitude, longitude))
urlstream = urllib2.urlopen(webUrl, timeout=1)
data = json.loads(urlstream.read())
location = data['results'][0]["formatted_address"]
reportObject = Report(animal_type_id=categoryObject.id,
latitude=latitude,
longitude=longitude,
mobile_number=mobile_number,
image_path=image_path,
location=location,
additional_comments=additional_comments)
reportObject.save()
return HttpResponse(reportObject.id)
def test_parse_report(self):
response = '''
{"response":[
{"clicks":"103","money":"1000.00","day":"2010-10-08","campaign_id":123,"client_id":123,"client_name":"Ford","campaign_name":"Campaign1","ctr":"0.199","impressions":"51635"}
]}
'''
account = Account.objects.create(remote_id=1)
Campaign.objects.create(account=account, remote_id=123, fetched=datetime.now())
Client.objects.create(account=account, remote_id=123, fetched=datetime.now())
instance = Report(time_from=datetime.now(), time_to=datetime.now())
instance.parse(json.loads(response)['response'][0])
instance.save()
self.assertTrue(isinstance(instance.campaign, Campaign))
self.assertEqual(instance.campaign.remote_id, 123)
self.assertTrue(isinstance(instance.client, Client))
self.assertEqual(instance.client.remote_id, 123)
self.assertEqual(instance.clicks, 103)
self.assertEqual(instance.impressions, 51635)
self.assertEqual(instance.day, date(2010,10,8))
self.assertEqual(instance.client_name, "Ford")
self.assertEqual(instance.campaign_name, "Campaign1")
self.assertEqual(instance.money, '1000.00')
self.assertEqual(instance.ctr, '0.199')
def _save_report(report_type, member, team, message):
standup = team.todays_standup()
if standup is None:
standup = Standup(team_id=team.id)
standup.created_at = datetime.now()
standup.save()
report = member.todays_report(standup)
if report is None:
report = Report(member_id=member.id, standup_id=standup.id)
report.created_at = datetime.now()
report.save()
if report_type == 'today':
report.today = message
elif report_type == 'yesterday':
report.yesterday = message
elif report_type == 'problem':
report.problem = message
report.updated_at = datetime.now()
report.save()
standup.update_at = datetime.now()
standup.save()
return 'Rapportert til `{}`'.format(team.name)
def test_create_report(self):
r = Report(author=Account.objects.first(),
start_period=self.today,
end_period=self.today,
scope="maintenance_review")
r.save()
self.assertEqual(Report.objects.all().count(), 2)
def mutate(self, info, report_data=None):
report = Report(reported_id_type=report_data.reported_id_type,
reported_id=report_data.reported_id,
user_id=report_data.user_id,
reason=report_data.reason,
description=report_data.description)
report.save()
return CreateReportMutation(report=report)
def test_model_chart(self):
"Test Chart Model"
report = Report(name='test')
report.save()
obj = Chart(name='test', report=report)
obj.save()
self.assertEquals('test', obj.name)
self.assertNotEquals(obj.id, None)
obj.delete()
def user_report(request):
'''
report handle
'''
if request.method == "POST":
rep_id = request.POST.get("rep_id","")
rep_type = request.POST.get("rep_type","")
reason = request.POST.get("reason","")
if rep_id == '' or rep_type == '' or reason == '':
return HttpResponse(-3)
report = Report(rep_type=int(rep_type),beReported=rep_id,reason=reason)
report.save()
return HttpResponse(0)
def user_report(request):
'''
report handle
'''
if request.method == "POST":
rep_id = request.POST.get("rep_id", "")
rep_type = request.POST.get("rep_type", "")
reason = request.POST.get("reason", "")
if rep_id == '' or rep_type == '' or reason == '':
return HttpResponse(-3)
report = Report(rep_type=int(rep_type), beReported=rep_id, reason=reason)
report.save()
return HttpResponse(0)
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 add_report(desc, user_id, user_informed):
report = Report(description=desc,
user=user_id,
user_informed=user_informed,
status='new',
date_created=datetime.datetime.now())
return report.save()
def add_report(request):
"""
Adds a report filled by a user to the site's reports record
:param request: Request
:return: HttpResponse
"""
if request.method == 'POST' and request.is_ajax:
deq = request.POST.get('description')
idq = request.POST.get('idq')
quest = Question.objects.get(id=idq)
report = Report(report_description=deq)
report.question = quest
report.save()
return HttpResponse("OK")
else:
return HttpResponse("Something went wrong")
def save_b(self):
''' add operation '''
# entete de la facture
if not self.table_buy.isvalid:
return False
owner = Owner.get(Owner.islog == True)
date = str(self.date.text())
values_t = self.table_buy.get_table_items()
buy = Buy()
# buy.date = datetime_
buy.provd_or_clt = \
ProviderOrClient.get_or_create(
"Fournisseur", 000000, ProviderOrClient.FSEUR)
buy.owner = owner
try:
buy.save()
err = False
except:
raise
raise_error("Erreur",
u"Impossible d'enregistrer l'entête de la facture")
return False
for name, qty, cost_buying, selling_price in values_t:
rep = Report()
rep.buy = buy
rep.type_ = Report.E
rep.store = 1
rep.date = date_to_datetime(date)
rep.product = Product.get(name=name)
rep.qty = int(qty)
rep.cost_buying = int(cost_buying)
rep.selling_price = int(selling_price)
try:
rep.save()
except Exception as e:
print(e)
err = True
if err:
buy.delete_instance()
raise_error(
"Erreur", u"Ce mouvement n'a pas pu etre "
u"enregistré dans les rapports")
return False
else:
self.parent.Notify(u"L'entrée des articles avec succès", "success")
self.change_main_context(BuyShowViewWidget, buy=buy)
def save_b(self):
''' add operation '''
# entete de la facture
if not self.table_buy.isvalid:
return False
owner = Owner.get(Owner.islog == True)
date = str(self.date.text())
values_t = self.table_buy.get_table_items()
buy = Buy()
# buy.date = datetime_
buy.provd_or_clt = \
ProviderOrClient.get_or_create(
"Fournisseur", 000000, ProviderOrClient.FSEUR)
buy.owner = owner
try:
buy.save()
err = False
except:
raise
raise_error(
"Erreur", u"Impossible d'enregistrer l'entête de la facture")
return False
for name, qty, cost_buying, selling_price in values_t:
rep = Report()
rep.buy = buy
rep.type_ = Report.E
rep.store = 1
rep.date = date_to_datetime(date)
rep.product = Product.get(name=name)
rep.qty = int(qty)
rep.cost_buying = int(cost_buying)
rep.selling_price = int(selling_price)
try:
rep.save()
except Exception as e:
print(e)
err = True
if err:
buy.delete_instance()
raise_error("Erreur", u"Ce mouvement n'a pas pu etre "
u"enregistré dans les rapports")
return False
else:
self.parent.Notify(u"L'entrée des articles avec succès", "success")
self.change_main_context(BuyShowViewWidget, buy=buy)
def report(request):
if request.method == 'POST':
errors = []
try:
patientId = int(request.POST.get('patientId'))
name = request.POST.get('name')
latitude = float(request.POST.get('latitude'))
longitude = float(request.POST.get('longitude'))
dt = request.POST.get('datetime')
datetime = datetime.strptime(dt,"%Y-%m-%d %H:%M:%S")
incomingReport = Report(patientId=patientId, name=name, \
latitude=latitude, longitude=longitude, datetime=datetime)
incomingReport.save()
return HttpResponse("Report successfully added to database")
except ValueError:
return HttpResponse("Report not added properly")
else:
raise Http404
def autoreport(request):
"""
Generates a report automatically for a denounced question as repeated in
an exam
:param request: Request
:return: HttpResponse
"""
if request.method == 'POST' and request.is_ajax:
txt = Question.objects.get(id=request.POST.get('id1')).question_text
deq = "Esta pregunta esta duplicada con la pregunta con \"" + txt + \
"\""
idq = request.POST.get('id2')
quest = Question.objects.get(id=idq)
report = Report(report_description=deq)
report.question = quest
report.save()
return HttpResponse("OK")
else:
return HttpResponse("Something went wrong")
def post(self):
"""Create new report"""
student = request.get_json()['student']
labname = request.get_json()['labname']
assessmentid = request.get_json()['assessmentid']
answers = request.get_json()['answers']
starttime = request.get_json()['starttime']
endtime = request.get_json()['endtime']
attempt_num = request.get_json()['attemptNum']
new_report = Report(student=student,
labname=labname,
assessmentid=assessmentid,
answers=answers,
starttime=starttime,
endtime=endtime,
attempt_num=attempt_num)
try:
new_report.save()
except UniqueViolatedError:
return jsonify(error=""), 409
return jsonify(message="ok")
def log_report(uri, data):
parts = data.strip().split("&")
form = {}
for part in parts:
if len(part) == 0:
continue
key, val = map(urllib.unquote_plus, part.split("="))
form[key] = form.get(key, '') + val
r = Report()
r.uri = uri
r.additional = form.get('a', '')
r.site_specific = form.get('site', '')
r.screen = form.get('s', '')
r.remote_ip = request.access_route[0]
r.headers = "\r\n".join(["%s: %s" % x for x in request.headers.to_list()])
r.url = form.get('u', '')
r.cookie = form.get('c', '')
r.useragent = form.get('ua', '')
r.save()
logging.error("Logged %s" % r)
def delete_post(board_name):
current_user = get_current_user(request)
board = Board.get(Board.name == board_name)
form = dict(request.forms)
if bool(form.get('report')):
reason = form.get('report')
report_reasons = loads(config['reports.reasons'])
if reason not in report_reasons:
return redirect(f'{basename}/{board_name}/')
for refnum in list(form)[:-1]:
report = Report(reason=reason,
refnum=refnum,
board=board,
date=datetime.now().replace(microsecond=0))
report.save()
else:
for refnum in form:
thread = board.posts.where(Post.refnum == refnum).get()
if (thread.author == current_user
or f':{board_name}:' in current_user.mod):
remove_textual_refs(board, thread)
if thread.image: remove_media(thread.image)
if not thread.is_reply:
for reply in board.posts.where(
Post.replyrefnum == thread.refnum):
if reply.image: remove_media(reply.image)
reply.delete_instance()
thread.delete_instance()
Report.delete().where(refnum == thread.refnum).execute()
redirect(f'{basename}/{board_name}/')
def main():
# Get current day - 1
logger.info('Calculating yesterday\'s day')
yesterday = get_yesterday_date()
# Get yesterday's measurement
logger.info(f'Getting measurement for {get_formatted_date(yesterday)}')
measurement = Measurement.objects(
created=get_formatted_date(yesterday)).first()
if measurement is None:
raise Exception(
f'Measurement for date={get_formatted_date(yesterday)} was not found'
)
# Compute the period for that measurment
logger.info(f'Calculating period for {get_formatted_date(yesterday)}')
period = get_period(yesterday)
# Get the report by period
logger.info(f'Getting report for {period}')
report = Report.objects(period=period).first()
if report is None:
logger.info(f'Report not found, creating a new report for {period}')
report = Report(
period=period,
values=[],
user=User.objects(email='*****@*****.**').first())
report.save()
logger.info(
f'Adding a new measurement for {measurement.created} in period {period}'
)
report_item = MeasurementValue(sys=measurement.sys,
dia=measurement.dia,
pul=measurement.pul,
date=measurement.created,
ok=measurement.is_ok())
report.values.append(report_item)
report.save()
logger.info('Done')
def add_report_to_cracker(cracker, client_ip, when=None):
if when is None:
when = time.time()
reports = yield Report.find(
where=["cracker_id=? AND ip_address=?", cracker.id, client_ip],
orderby='latest_report_time ASC'
)
if len(reports) == 0:
report = Report(ip_address=client_ip, first_report_time=when, latest_report_time=when)
yield report.save()
cracker.current_reports += 1
yield report.cracker.set(cracker)
elif len(reports) == 1:
report = reports[0]
# Add second report after 24 hours
if when > report.latest_report_time + 24*3600:
report = Report(ip_address=client_ip, first_report_time=when, latest_report_time=when)
yield report.save()
yield report.cracker.set(cracker)
elif len(reports) == 2:
latest_report = reports[1]
# Add third report after again 24 hours
if when > latest_report.latest_report_time + 24*3600:
report = Report(ip_address=client_ip, first_report_time=when, latest_report_time=when)
yield report.save()
yield report.cracker.set(cracker)
else:
latest_report = reports[-1]
latest_report.latest_report_time = when
yield latest_report.save()
cracker.total_reports += 1
cracker.latest_time = when
cracker.resiliency = when - cracker.first_time
yield cracker.save()
def save_b(self):
''' add operation '''
# entete de la facture
print("save")
if not self.is_valide():
return
invoice_date = unicode(self.invoice_date.text())
num_invoice = int(self.num_invoice.text())
invoice_type = self.liste_type_invoice[
self.box_type_inv.currentIndex()]
lis_error = []
invoice = Invoice()
try:
self.owner = Owner.get(Owner.islog == True)
except:
lis_error.append("Aucun utilisateur est connecté <br/>")
paid_amount = int(self.table_invoice.paid_amount_field.text())
try:
clt = ProviderOrClient.get_or_create(
self.name_client, int(self.phone.replace(" ", "")),
ProviderOrClient.CLT)
except ValueError:
field_error(self.name_client_field,
"Nom, numéro de téléphone du client")
invoice.number = num_invoice
invoice.owner = self.owner
invoice.client = clt
invoice.location = "Bamako"
invoice.type_ = invoice_type
invoice.subject = ""
invoice.paid_amount = paid_amount
invoice.tax = False
try:
invoice.save()
if int(paid_amount) != 0 or invoice_type == Invoice.TYPE_BON:
Refund(type_=Refund.DT,
owner=self.owner,
amount=paid_amount,
date=date_to_datetime(invoice_date),
provider_client=clt,
invoice=Invoice.get(number=num_invoice)).save()
except Exception as e:
invoice.deletes_data()
lis_error.append(
"Erreur sur l'enregistrement d'entête de facture<br/>")
return False
# Save invoiceitems
invoice = Invoice.get(Invoice.number == num_invoice)
for name, qty, price in self.table_invoice.get_table_items():
rep = Report()
product = Product.get(Product.name == name)
rep.store = 1
rep.product = product
rep.invoice = invoice
rep.type_ = Report.S
rep.cost_buying = int(product.last_report.cost_buying)
rep.date = date_to_datetime(invoice_date)
rep.qty = int(qty)
rep.selling_price = int(price)
try:
rep.save()
except Exception as e:
lis_error.append(e)
if lis_error != []:
invoice.delete_instance()
self.parent.Notify(lis_error, "error")
return False
else:
self.parent.Notify("Facture Enregistrée avec succès", "success")
self.table_invoice._reset()
try:
self.parent.open_dialog(ShowInvoiceViewWidget,
modal=True,
opacity=100,
table_p=self,
invoice_num=invoice.number)
except Exception as e:
print(e)
else:
value = (s[l / 2 - 1] + s[l / 2]) / 2
metric['value'] = value
report = Report(system=system, date=date)
filename = system_name + "-" + date.strftime("%Y%m%d-%H%M%S") + ".gz"
str_io = StringIO()
gz = GzipFile(filename, mode="wb", fileobj=str_io)
gz.write(reportContents.encode("UTF-8"))
gz.close()
# so just compress into a memory buffer and save that.
report.upload.save(filename, ContentFile(str_io.getvalue()))
report.save()
for name in metrics:
metric = metrics[name]
description = metric['description']
units = metric['units']
value = metric['value']
storedMetric = Metric(name=name,
description=description,
units=units,
report=report,
value=value)
storedMetric.save()
return HttpResponse("Report upload succeeded",
value = (s[l/2 - 1] + s[l/2]) / 2
metric['value'] = value
report = Report(system=system, date=date)
filename = system_name + "-" + date.strftime("%Y%m%d-%H%M%S") + ".gz"
str_io = StringIO()
gz = GzipFile(filename, mode="wb", fileobj=str_io)
gz.write(reportContents.encode("UTF-8"))
gz.close()
# so just compress into a memory buffer and save that.
report.upload.save(filename,
ContentFile(str_io.getvalue()))
report.save()
for name in metrics:
metric = metrics[name]
description = metric['description']
units = metric['units']
value = metric['value']
storedMetric = Metric(name=name,
description=description,
units=units,
report=report,
value=value)
storedMetric.save()
def report_add(request, response_format='html'):
"Create new report based on user choice"
if 'report' in request.POST:
report_id = request.POST['report']
return HttpResponseRedirect(reverse('reports_report_edit', args=[report_id]))
# FIRST TIME AN OBJECT IS CHOSEN
if 'choice' in request.POST:
form = None
object = request.POST['choice']
object = str(
object.replace("{'object_type': u'", '').replace("'}", ''))
full_object = object
object = object.split('.', 3)
module_name = object[0] + '.' + object[1] + '.' + object[2]
import_name = object[3]
module = __import__(
module_name, globals(), locals(), [import_name], -1)
classobj = getattr(module, import_name)
obj = classobj()
names = obj.get_field_names()
fields = []
for name in names:
fields.append(Field(name=name, display=True))
model = Model(full_object, fields)
report = Report()
report.name = "Untitled {0!s} Report".format((obj._meta.object_name))
report.model = dumps(model)
report.creator = request.user.profile
report.save()
return HttpResponseRedirect(reverse('reports_report_edit', args=[report.id]))
# Initial Object Type Choice
user_modules = [mod.name for mod in request.user.profile.get_perspective().get_modules()]
modules = [mod.name for mod in Module.objects.all()]
query = Q(object_type__contains="core")
for module in modules:
if module not in user_modules:
query = query | Q(object_type__contains=module)
object_types = list(Object.objects.all().exclude(query).values(
'object_type').distinct().order_by('object_type'))
object_names = []
for object_type in object_types:
module_name = _get_module_name(object_type['object_type'])
human_type = Object.objects.filter(
object_type=object_type['object_type'])[0].get_human_type()
object_names.append("{0!s}: {1!s}".format(module_name, human_type))
form = ObjChoiceForm(request.user, object_types=object_types, object_names=object_names)
return render_to_response('reports/report_add', {'form': form}, context_instance=RequestContext(request),
response_format=response_format)
def upload_csv(request, report_id):
'''
Take data (a list of payroll object in json format) sent by request.
Create the Report object with report_id.
If the report_id already in Report table, send error message.
Else:
Create Payroll objects for each object in data.
Create Payroll_Report.
'''
report_count = Report.objects.filter(report_id=report_id).count()
if report_count == 0: #report with report_id doesn't exist
data = json.loads(request.body)
# create a new Report
new_report = Report(report_id=report_id)
new_report.save()
for obj in data:
temp_date = [int(t) for t in obj['date'].split('/')]
(day, month, year) = (temp_date[0], temp_date[1],
temp_date[2])
date = datetime(year=year, month=month, day=day)
# create a Payroll for the current obj
payroll = Payroll(date=date,
hours_worked=float(obj['hours worked']),
employee_id=int(obj['employee id']),
job_group=obj['job group'],
report_id=report_id)
# 1 -> 1st half month, 16 -> 2nd half month
start_day = (1 if day <= 15 else 16)
# get the end day of the given month
end_day = (15 if day <= 15 else calendar.monthrange(year,
month)[1])
start_date_ts = 10000 * year + 100 * month + start_day
# group A $20/h, group B $30/h
if payroll.job_group == 'A':
amount = 20 * payroll.hours_worked
else:
amount = 30 * payroll.hours_worked
#check if the report with same pay period already existed
payroll_report = \
Payroll_Report.objects.filter(employee_id=payroll.employee_id,
period_start_date_ts=start_date_ts)
if not payroll_report:
# if report does not exists, create a new report
period = str(start_day) + '/' + str(month) + '/' \
+ str(year) + ' - ' + str(end_day) + '/' \
+ str(month) + '/' + str(year)
payroll_report = \
Payroll_Report(employee_id=payroll.employee_id,
period_start_date_ts=start_date_ts,
period=period, amount=amount)
else:
# if report exists, increment the amount of money
payroll_report = payroll_report[0]
payroll_report.amount += amount
payroll_report.save()
payroll.save()
return HttpResponse(json.dumps({'status': 'success'}))
else:
return HttpResponse(json.dumps({'status': 'error',
'error_message': 'This report is already been uploaded before'
}))
def cpanel_submit(request):
# The user adding the request
user = request.user
name = request.POST['name']
phone = request.POST['phone']
email = request.POST['email']
type = request.POST['device']
os = request.POST['os']
problem = request.POST['problem']
description = request.POST['description']
deviceObj = Device()
report = Report()
usersWithSameEmail = User.objects.filter(email=email)
reportUser = User()
userFound = False
for u in usersWithSameEmail:
# If user exists, don't create a new one
if u.email == email:
reportUser = u
userFound = True
if not userFound:
reportUser.email = email
reportUser.username = name
reportUser.password = '******'
reportUser.save()
# Get the devices the user has
usersDevices = Device.objects.filter(owner=reportUser)
deviceFound = False
for d in usersDevices:
# If the device exists recognize it, and use it
if d.os == os and d.type == type:
deviceObj = d
deviceFound = True
if not deviceFound:
# Generate device object
deviceObj.owner = reportUser
deviceObj.os = os
deviceObj.type = type
deviceObj.save()
# Generate Report
report.owner = reportUser
report.device = deviceObj
report.description = description
report.problem = problem
report.completed = False
report.save()
# Generate initial status
status = Status()
status.report = report
# Checked in message
status.message = 'c'
status.tech = user
status.save()
return cpanel(request, True)
class ReportsViewsTest(TestCase):
username = "******"
password = "******"
def setUp(self):
self.group, created = Group.objects.get_or_create(name='test')
self.user, created = DjangoUser.objects.get_or_create(username=self.username)
self.user.set_password(self.password)
self.user.save()
perspective, created = Perspective.objects.get_or_create(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.report = Report(name='test')
self.report.set_default_user()
self.report.save()
self.chart = Chart(name='test_chart', report=self.report)
self.chart.set_default_user()
self.chart.save()
######################################
# Testing views when user is logged in
######################################
def test_reports_login(self):
"""Testing /reports/"""
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('reports'))
self.assertEquals(response.status_code, 200)
def test_index_login(self):
"Testing /reports/index/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('reports_index'))
self.assertEquals(response.status_code, 200)
def test_index_owned(self):
"Testing /reports/owned/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('reports_index'))
self.assertEquals(response.status_code, 200)
# Charts
def test_chart_add(self):
"Testing /reports/chart/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('reports_chart_add'))
self.assertEquals(response.status_code, 200)
def test_chart_delete_login(self):
"Testing /reports/chart/delete/<chart_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('reports_chart_delete', args=[self.chart.id]))
self.assertEquals(response.status_code, 200)
# Reports
def test_report_add(self):
"Testing /reports/report/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('reports_report_add'))
self.assertEquals(response.status_code, 200)
def test_report_delete_login(self):
"Testing /reports/report/delete/<report_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('reports_report_delete', args=[self.report.id]))
self.assertEquals(response.status_code, 200)
######################################
# Testing views when user is not logged in
######################################
def test_reports_out(self):
"Testing /reports/"
response = self.client.get(reverse('reports'))
self.assertRedirects(response, reverse('user_login'))
def test_index_out(self):
"Testing /reports/index/"
response = self.client.get(reverse('reports_index'))
self.assertRedirects(response, reverse('user_login'))
def test_index_owned_out(self):
"Testing /reports/owned/"
response = self.client.get(reverse('reports_index'))
self.assertRedirects(response, reverse('user_login'))
# Charts
def test_chart_add_out(self):
"Testing /reports/chart/add/"
response = self.client.get(reverse('reports_chart_add'))
self.assertRedirects(response, reverse('user_login'))
def test_chart_add_typed_out(self):
"Testing /reports/chart/add/<report_id>"
response = self.client.get(
reverse('reports_chart_add', args=[self.report.id]))
self.assertRedirects(response, reverse('user_login'))
def test_chart_edit_out(self):
"Testing /reports/chart/edit/<chart_id>"
response = self.client.get(
reverse('reports_chart_edit', args=[self.chart.id]))
self.assertRedirects(response, reverse('user_login'))
def test_chart_delete_out(self):
"Testing /reports/chart/delete/<chart_id>"
response = self.client.get(
reverse('reports_chart_delete', args=[self.chart.id]))
self.assertRedirects(response, reverse('user_login'))
# Reports
def test_report_add_out(self):
"Testing /reports/report/add/"
response = self.client.get(reverse('reports_report_add'))
self.assertRedirects(response, reverse('user_login'))
def test_report_view_out(self):
"Testing /reports/report/view/<report_id>"
response = self.client.get(
reverse('reports_report_view', args=[self.report.id]))
self.assertRedirects(response, reverse('user_login'))
def test_report_edit_out(self):
"Testing /reports/report/edit/<report_id>"
response = self.client.get(
reverse('reports_report_edit', args=[self.report.id]))
self.assertRedirects(response, reverse('user_login'))
def test_report_delete_out(self):
"Testing /reports/report/delete/<report_id>"
response = self.client.get(
reverse('reports_report_delete', args=[self.report.id]))
self.assertRedirects(response, reverse('user_login'))
def cpanel_submit(request): # The user adding the request user = request.user name = request.POST['name'] phone = request.POST['phone'] email = request.POST['email'] type = request.POST['device'] os = request.POST['os'] problem = request.POST['problem'] description = request.POST['description'] deviceObj = Device() report = Report() usersWithSameEmail = User.objects.filter(email=email) reportUser = User() userFound = False for u in usersWithSameEmail: # If user exists, don't create a new one if u.email == email: reportUser = u userFound = True if not userFound: reportUser.email = email reportUser.username = name reportUser.password = '******' reportUser.save() # Get the devices the user has usersDevices = Device.objects.filter(owner=reportUser) deviceFound = False for d in usersDevices: # If the device exists recognize it, and use it if d.os == os and d.type == type: deviceObj = d deviceFound = True if not deviceFound: # Generate device object deviceObj.owner = reportUser deviceObj.os = os deviceObj.type = type deviceObj.save() # Generate Report report.owner = reportUser report.device = deviceObj report.description = description report.problem = problem report.completed = False report.save() # Generate initial status status = Status() status.report = report # Checked in message status.message = 'c' status.tech = user status.save() return cpanel(request, True)
def test_model_report(self):
obj = Report(name='test')
obj.save()
self.assertEquals('test', obj.name)
self.assertNotEquals(obj.id, None)
obj.delete()
def save_b(self):
''' add operation '''
# entete de la facture
print("save")
if not self.is_valide():
return
invoice_date = unicode(self.invoice_date.text())
num_invoice = int(self.num_invoice.text())
invoice_type = self.liste_type_invoice[
self.box_type_inv.currentIndex()]
lis_error = []
invoice = Invoice()
try:
self.owner = Owner.get(Owner.islog == True)
except:
lis_error.append("Aucun utilisateur est connecté <br/>")
paid_amount = int(self.table_invoice.paid_amount_field.text())
try:
clt = ProviderOrClient.get_or_create(
self.name_client, int(self.phone.replace(" ", "")), ProviderOrClient.CLT)
except ValueError:
field_error(
self.name_client_field, "Nom, numéro de téléphone du client")
invoice.number = num_invoice
invoice.owner = self.owner
invoice.client = clt
invoice.location = "Bamako"
invoice.type_ = invoice_type
invoice.subject = ""
invoice.paid_amount = paid_amount
invoice.tax = False
try:
invoice.save()
if int(paid_amount) != 0 or invoice_type == Invoice.TYPE_BON:
Refund(type_=Refund.DT, owner=self.owner, amount=paid_amount,
date=date_to_datetime(invoice_date), provider_client=clt,
invoice=Invoice.get(number=num_invoice)).save()
except Exception as e:
invoice.deletes_data()
lis_error.append(
"Erreur sur l'enregistrement d'entête de facture<br/>")
return False
# Save invoiceitems
invoice = Invoice.get(Invoice.number == num_invoice)
for name, qty, price in self.table_invoice.get_table_items():
rep = Report()
product = Product.get(Product.name == name)
rep.store = 1
rep.product = product
rep.invoice = invoice
rep.type_ = Report.S
rep.cost_buying = int(product.last_report.cost_buying)
rep.date = date_to_datetime(invoice_date)
rep.qty = int(qty)
rep.selling_price = int(price)
try:
rep.save()
except Exception as e:
lis_error.append(e)
if lis_error != []:
invoice.delete_instance()
self.parent.Notify(lis_error, "error")
return False
else:
self.parent.Notify("Facture Enregistrée avec succès", "success")
self.change_main_context(ShowInvoiceViewWidget,
invoice_num=invoice.number)
def default(request):
applicationFolder = getApplicationFolder()
#if the request is POST -> file is being uploaded
if str(request.method).lower() == 'post':
form = UploadFileForm(request.POST, request.FILES)
#if there is file for uploading
if form.is_valid():
#uplaod the file on the server
tarPath = handle_uploaded_file(request.FILES['file'])
reportMetaData = {}
#here check it could be zip or tar.gz
isTar = (tarPath.endswith('tar.gz') or tarPath.endswith('tgz'))
isZip = tarPath.endswith('.zip')
#get metadata depending on the archive
if isTar:
reportMetaData = getReportMetadataTar(tarPath)
elif isZip:
reportMetaData = getReportMetadataZip(tarPath)
#create new Report object set its metadata and save it
report = Report()
report.username = reportMetaData['user']
report.ganga_version = reportMetaData['version']
report.job_uuid = reportMetaData['uuid']
report.date_uploaded = datetime.now()
report.save()
#save the report's mon links
monlinks = reportMetaData['monlinks']
for key, value in monlinks.items():
monlink = MonitoringLink()
monlink.report = report
monlink.monitoring_link_name = key
monlink.monitoring_link_path = value
monlink.save()
#rename the uploaded file on the server with the report id
if isTar:
rename_file(tarPath, report.id, 'tar')
elif isZip:
rename_file(tarPath, report.id, 'zip')
#sets the download path that will be shown to the user
serverDownloadPath = os.path.join(settings.SERVER_DOWNLOAD_PATH, str(report.id))
community, debug = getCommunityAndDebugMode()[0], getCommunityAndDebugMode()[1]
if community == 'CMS' and debug == False :
#because for CMS there is different DNS
serverDownloadPath = os.path.join(settings_HOST+"cmserrorreports/download", str(report.id))
elif community == 'CMS':
serverDownloadPath = serverDownloadPath.replace('errorreports', 'cmserrorreports')
renderToResponse = render_to_response('%s/upload.html' % applicationFolder, {'form': form, 'path': serverDownloadPath }, context_instance = RequestContext(request))
logServerResponse(str(renderToResponse))
return renderToResponse
else:
errors=""
for key, value in form.errors.iteritems():
errors += str(key) + ": "
for i in value:
errors += str(i) + ", "
errors += " "
return render_to_response('%s/upload.html' % applicationFolder, {'form': form, 'path' : 'invalid form: %s' % errors }, context_instance = RequestContext(request))
else:
#user = User.objects.create_user('gosho', '*****@*****.**', 'gosho')
#user.save()
form = UploadFileForm()
return render_to_response('%s/upload.html' % applicationFolder, { 'form' : form, 'path' : 'Method: %s' % request.method }, context_instance = RequestContext(request))
