def post(self, request):
serializer = MainReportSerializer(data=request.data)
if serializer.is_valid():
data_questions = serializer.data['questions']
data_stats = serializer.data['stats']
report = Report()
report.patient = self.request.user
report.has_headaches = data_questions['has_headaches']
report.mood_level = data_questions['mood_level']
report.other_diseases = data_questions['other_diseases']
report.save()
for group, group_data in data_stats.items():
for data_type, type_data in group_data.items():
for data in type_data:
ReportData.objects.save_data(
self.request.user,
data_type,
data['timestamp'],
data['value'],
group,
report
)
return Response(status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def attach_to_waste_deposit(report: Report) -> None:
"""
Try to find an existing waste deposit in 5 meters from the new report location
to attach report. If close waste deposit does not exist
the new one with report`s coordinates will be created.
"""
waste_deposits = WasteDeposit.objects.all()
close_waste_deposit = None
for waste_deposit in waste_deposits:
distance = geodesic(report.location, waste_deposit.location).meters
if distance <= settings.WASTE_DEPOSIT_DISTANCE_IN_METERS:
settings.LOGGER.info(
f'Attaching report {report.id} to the existing '
f'waste deposit {waste_deposit.id} in {round(distance, ndigits=2)} '
f'meters.'
)
close_waste_deposit = waste_deposit
break
if not close_waste_deposit:
settings.LOGGER.info(
f'Creating new waste deposit for the report {report.id}.'
)
close_waste_deposit = WasteDeposit.objects.create(
lat=report.lat, long=report.long
)
report.waste_deposit_id = close_waste_deposit
report.save()
def form_valid(self, form):
report_query = self.get_report_query(form)
report_dict = self.get_report_dict(form)
reports = Report.objects.filter(**report_query)
if reports.filter(status=ReportStatus.Ready).exists():
report = reports.filter(status=ReportStatus.Ready)[0]
messages.add_message(self.request, messages.INFO, u'Отчёт уже построен')
return HttpResponseRedirect(report.get_absolute_url())
elif reports.filter(status=ReportStatus.Pending).exists():
return self.render_to_response({
'form': form,
'pending': reports[0]
})
else:
report = Report(**report_dict)
report.save()
try:
report.process() #.delay(report)
except ConnectionError:
return self.render_to_response({
'form': form,
'error': u'Нет соединения с очередью задач'
})
return HttpResponseRedirect(report.get_absolute_url())
def mutate_and_get_payload(root, info, **kwargs):
kwargs = check_kwargs(kwargs, info)
projects = kwargs['projects']
del kwargs['projects']
report = Report()
report.user_added = info.context.user
# Если отчет добавляет ГИП, тогда отчет автоматически становится проверенным.
if Project.objects.get(id=projects[0]).gip == info.context.user:
report.checked_by = info.context.user
report.time_checked = timezone.now()
# Добавляем к полям модели полученные значения.
# "keys" - это глобальный список внешних ключей (имен полей).
[
setattr(report, f + '_id' if f in keys else f, kwargs.get(f))
for f in kwargs.keys()
]
report.save()
projects_states = Project.objects.filter(id__in=projects).values(
'id', 'state_id')
for ps in projects_states:
ProjectState.objects.create(project_id=ps['id'],
state_id=ps['state_id'],
report_id=report.id)
return CreateReport(report=report)
def report_scheduled_job():
consumer_key = settings.CONSUMER_KEY
consumer_secret = settings.CONSUMER_SECRET
access_token = settings.ACCESS_TOKEN
access_secret = settings.ACCESS_SECRET
max_tweets = settings.MAX_TWEETS
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_secret)
api = tweepy.API(auth)
non_bmp_map = dict.fromkeys(range(0x10000, sys.maxunicode + 1), 0xfffd)
sources = Source.objects.filter(status='ACTIVE', type='TWITTER')
for active_source in sources:
keywords = active_source.keywords.all()
for a_keyword in keywords:
query = a_keyword.keyword
searched_tweets = [
status for status in tweepy.Cursor(api.search, q=query).items(
max_tweets)
]
source = Reports_Source.objects.get(code='TWT')
for status in searched_tweets:
tweet_localcreatedtime = status.created_at + timedelta(hours=7)
diff = datetime.now() - tweet_localcreatedtime
diff_hours = diff.total_seconds() / 3600
if diff_hours <= 1:
note = status.text.translate(non_bmp_map)
note = "[{}] {}".format(active_source.disaster,
smart_str(note))
new_report = Report(note=note, source=source)
new_report.save()
def send(request):
# make request
# nombre doctor
# fecha consulta
# nombre paciente
# edo paciente
# observaciones
# sugerencias
doc_name = request.POST.get('nombre_dr', "")
patient_name = request.POST.get('nombre_pac', "")
consult_date = request.POST.get('fecha', "")
patient_state = request.POST.get('estado_pac', "")
observ = request.POST.get('comentarios', "")
suggest = request.POST.get('sugerencias', "")
rep = Report(doc_name=doc_name,
patient_name=patient_name,
consult_date=consult_date,
patient_state=patient_state,
observ=observ,
suggest=suggest)
rep.save()
url = 'https://android.googleapis.com/gcm/send'
headers = {
'Content-Type': 'application/json',
'Authorization': 'key=AIzaSyCH7B7qMMbLnQdj6WG1yuvPp3SlsLHtBds'
}
payload = {
"data": {
"fecha": consult_date,
"doctor": doc_name,
"paciente": patient_name,
"observaciones": observ,
"sugerencias": suggest
},
"registration_ids": [
"APA91bHDXfzISMoo6OfqhhODnU7TeNzqCxeE7lYZHhdI801wazh1e7vbITZVTqwKU5avNW0myInlZW3Aat3S8gzqawN9G5fQEkMVNvqkDHRRYt1IDsFrPuc"
]
}
try:
r = requests.post(url, data=json.dumps(payload))
#r = requests.post(url, headers=headers, data=json.dumps(payload))
except requests.exceptions.ConnectionError:
return render(request, 'reports/index.html', {
'error_message':
"No hay conexión a internet, intente más tarde",
})
else:
print >> sys.stderr, "POST request response: ", r.status_code
if r.status_code == 200:
code = 0
else:
code = 1
#print >>sys.stderr, consult_date
return HttpResponseRedirect(
reverse('reports:results', args=(rep.id, code)))
finally:
pass
def NewReport(request):
if request.method == 'POST':
com_name = request.POST.get("com_name")
acronym = request.POST.get("acronym")
wor_id = request.POST.get("wor_id")
creator_id = int(request.POST.get("creator_name"))
reviewer_id = int(request.POST.get("reviewer"))
time = request.POST.get("start_date")
print >> sys.stderr, 'End time: ' + str(time)
end_time = request.POST.get("end_date")
print >> sys.stderr, 'End time: ' + end_time
wapt = bool(request.POST.get("f_wapt"))
print >> sys.stderr, 'NewReport ' + str(wapt)
new_report = Report(company_name=com_name, comp_acronym=acronym,
wor_id=wor_id, creator_name_id=creator_id,
reviewer_name_id=reviewer_id, pub_date=time,
end_date=end_time, report_wapt=wapt)
#if request.POST.get("com_priority") is 'low':
#new_report.report_status = False
#print >> sys.stderr, 'NewReportx ' + str(new_report.report_status)
new_report.save()
return redirect("/reports/")
else:
new_report = 'new report here'
reviewer = UserProfile.objects.all()
print >> sys.stderr, str(reviewer)
form = CveForm()
return render(request, 'reports/new_report.html', { 'form' :form, 'reviewer': reviewer })
def report_scheduled_job():
consumer_key = settings.CONSUMER_KEY
consumer_secret = settings.CONSUMER_SECRET
access_token = settings.ACCESS_TOKEN
access_secret = settings.ACCESS_SECRET
max_tweets = settings.MAX_TWEETS
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_secret)
api = tweepy.API(auth)
non_bmp_map = dict.fromkeys(range(0x10000, sys.maxunicode + 1), 0xfffd)
sources = Source.objects.filter(status='ACTIVE', type='TWITTER')
for active_source in sources:
keywords = active_source.keywords.all()
for a_keyword in keywords:
query = a_keyword.keyword
searched_tweets = [status for status in tweepy.Cursor(api.search, q=query).items(max_tweets)]
source = Reports_Source.objects.get(code='TWT')
for status in searched_tweets:
tweet_localcreatedtime = status.created_at + timedelta(hours=7)
diff = datetime.now() - tweet_localcreatedtime
diff_hours = diff.total_seconds() / 3600
if diff_hours <= 1:
note = status.text.translate(non_bmp_map)
note = "[{}] {}".format(active_source.disaster, smart_str(note))
new_report = Report(
note=note,
source=source
)
new_report.save()
def generate_report(self):
self._create_directory()
report = Report()
report.save()
report.report = self._get_report_file(report.id)
report.neural_network = self.neural_network
report.save()
def test_should_raise_404_if_no_tracker(self):
report = Report()
report.save()
c = Client()
response = c.get(self.STATS_PATH)
self.assertEqual(response.status_code, 404)
def getReport():
today = date.today()
delta = datetime.timedelta(days=1)
yesterday = today - delta
trades = Trade.objects.filter(
Q(tradeDate__year=today.year) & Q(tradeDate__month=today.month) & Q(tradeDate__day=today.day)
)
for trade in trades:
try:
new_report = Report.objects.get(
Q(symbol=trade.symbol)
& Q(reportDate__year=today.year)
& Q(reportDate__month=today.month)
& Q(reportDate__day=today.day)
)
except Report.DoesNotExist: # today's new does not exist
try: # get yesterday's
old_report = Report.objects.get(
Q(symbol=trade.symbol)
& Q(reportDate__year=yesterday.year)
& Q(reportDate__month=yesterday.month)
& Q(reportDate__day=yesterday.day)
)
old_report.pk = None
old_report.save() # clone a new one
new_report = old_report
new_report.SOD = new_report.EOD # update SOD
except Report.DoesNotExist: # yesterday's old does not exist
new_report = Report()
new_report.symbol = trade.symbol
new_report.reportDate = today
# update report
if trade.side == "B":
total = new_report.buys * new_report.buyAve
total += trade.quantity * trade.price # new total
new_report.buys += trade.quantity # new buys
new_report.buyAve = total / new_report.buys # new buy ave
new_report.EOD = new_report.EOD + trade.quantity
elif trade.side == "S":
total = new_report.sells * new_report.sellAve
total += trade.quantity * trade.price # new total
new_report.sells += trade.quantity # new sells
new_report.sellAve = total / new_report.sells # new sell ave
new_report.EOD = new_report.EOD - trade.quantity
new_report.save() # save result
getPNLs(today) # calculate PNLS
getTotal(today) # get summary date
def handle(self, *args, **options):
report = Report(
title='Test runner from CLI',
description='Test runner from CLI',
runner=options['runner'],
frequency='on_demand')
if 'attributes' in options:
report.attributes = options['attributes']
report.save()
run = report.run()
self.stdout.write(run.result)
run.delete()
report.delete()
def send(request):
# make request
# nombre doctor
# fecha consulta
# nombre paciente
# edo paciente
# observaciones
# sugerencias
doc_name = request.POST.get('nombre_dr', "")
patient_name = request.POST.get('nombre_pac', "")
consult_date = request.POST.get('fecha', "")
patient_state = request.POST.get('estado_pac', "")
observ = request.POST.get('comentarios', "")
suggest = request.POST.get('sugerencias', "")
rep = Report(doc_name=doc_name, patient_name=patient_name, consult_date=consult_date, patient_state=patient_state, observ=observ, suggest=suggest)
rep.save()
url = 'https://android.googleapis.com/gcm/send'
headers = {'Content-Type': 'application/json',
'Authorization': 'key=AIzaSyCH7B7qMMbLnQdj6WG1yuvPp3SlsLHtBds'}
payload = {
"data": {
"fecha": consult_date,
"doctor": doc_name,
"paciente": patient_name,
"observaciones": observ,
"sugerencias": suggest
},
"registration_ids": [
"APA91bHDXfzISMoo6OfqhhODnU7TeNzqCxeE7lYZHhdI801wazh1e7vbITZVTqwKU5avNW0myInlZW3Aat3S8gzqawN9G5fQEkMVNvqkDHRRYt1IDsFrPuc"
]
}
try:
r = requests.post(url, data=json.dumps(payload))
#r = requests.post(url, headers=headers, data=json.dumps(payload))
except requests.exceptions.ConnectionError:
return render(request, 'reports/index.html', {
'error_message': "No hay conexión a internet, intente más tarde",
})
else:
print >>sys.stderr, "POST request response: ", r.status_code
if r.status_code == 200:
code = 0
else:
code = 1
#print >>sys.stderr, consult_date
return HttpResponseRedirect(reverse('reports:results', args=(rep.id, code)))
finally:
pass
def test_track_detail_app_removed_tracker(self):
tracker1 = Tracker(
id=1,
name='Teemo',
)
tracker1.save()
application_handle1 = "com.handle.one"
report1 = Report()
report1.save()
application1 = Application(
handle=application_handle1,
report=report1
)
application1.save()
report1.found_trackers = [tracker1.id]
report1.save()
report2 = Report()
report2.save()
application2 = Application(
handle=application_handle1,
report=report2
)
application2.save()
# Removing trackers in the version of the app
report2.found_trackers = []
report2.save()
c = Client()
url = self.TRACKER_DETAIL_PATH.format(tracker1.id)
response = c.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['tracker'].id, tracker1.id)
self.assertEqual(len(response.context['reports']), 0)
def add_report(request): #the user is able to select multiple files
if request.method == 'POST':
form = ReportForm(request.POST, request.FILES)
creator = request.user
name = request.POST.get('name')
keyword = request.POST.get('keyword')
description = request.POST.get('description')
encrypted = True if request.POST.get('encrypted') else False
longDescription = request.POST.get('longDescription')
private = True if request.POST.get('private') else False
ip = get_client_ip(request)
file = os.path.join(settings.GEOIP_PATH, 'GeoLiteCity.dat')
gi = pygeoip.GeoIP(file)
info=gi.record_by_addr(ip)
area_code = None
city = None
country = None
if info != None:
area_code = info['region_code']
city = info['city']
country = info['country_name']
report = Report(creator_id=creator.id,region_code=area_code,city=city,country=country,keyword=keyword, encrypted=encrypted, name=name, description=description,longDescription=longDescription,private =private)
#
report.save()
# file = File(report=report, path=paths) #pass variables to fields
paths = request.FILES.getlist('path')
#print(request.FILES)
for path in paths:
File(report=report, path=path).save() #pass variables to fields
return HttpResponseRedirect('/reports/$/')
else:
# This should never happen
return HttpResponse('Improper arrival at add_report, see reports.views')
def test_track_detail_app_multiple_reports(self):
tracker2 = Tracker(
id=2,
name='Exodus Super Tracker',
)
tracker2.save()
application_handle2 = "com.handle.two"
report2 = Report()
report2.save()
application2 = Application(
handle=application_handle2,
report=report2
)
application2.save()
report2.found_trackers = [tracker2.id]
report2.save()
report3 = Report()
report3.save()
application3 = Application(
handle=application_handle2,
report=report3
)
application3.save()
report3.found_trackers = [tracker2.id]
report3.save()
c = Client()
url = self.TRACKER_DETAIL_PATH.format(tracker2.id)
response = c.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['tracker'].id, tracker2.id)
self.assertEqual(len(response.context['reports']), 1)
self.assertEqual(response.context['reports'][0].application.handle, application_handle2)
self.assertEqual(response.context['reports'][0], report3)
def test_should_return_stats_with_1_tracker_not_found(self):
tracker = Tracker(name='Teemo')
tracker.save()
report = Report()
report.save()
c = Client()
response = c.get(self.STATS_PATH)
self.assertEqual(response.status_code, 200)
self.assertContains(response, tracker.name, 1)
self.assertEqual(response.context['trackers'][0].name, tracker.name)
self.assertEqual(response.context['trackers'][0].count, 0)
self.assertEqual(response.context['trackers'][0].score, 0)
def newReport(account, symbol, today):
try:
mainAccount = account[:5]
new_report = Report.objects.get(Q(account=mainAccount) & Q(symbol=symbol) & Q(reportDate=today))
except Report.DoesNotExist: # today's new does not exist
new_report = Report()
new_report.account = mainAccount
new_report.symbol = symbol
new_report.reportDate = today
new_report.save()
#new_report = Report.objects.create(symbol=symbol, reportDate=today)
return new_report
class ReportHandler(PatternHandler):
""" Handles the initialization of the reporting process. """
pattern = r"^\s*R(eport)?\s*$"
report = 0
def help(self):
# Create a new report in the DB
self.report = Report(identity=self.msg.connection.identity, state=1)
self.report.save()
logger.debug("New report created")
# Send initial response to user
self.respond("Hello. Please text a number for the incident you are reporting..." +
"1-Verbal Abuse, 2-Physical Abuse, 3-Sexual Assault, 4-Robbery, 5-Rape")
def handle(self, text):
self.help()
def getTotal(report_date):
total = Report()
total.symbol = "Total"
report_list = Report.objects.filter(Q(reportDate=report_date))
for report in report_list:
total.SOD += report.SOD
total.buys += report.buys
total.sells += report.sells
total.grossPNL += report.grossPNL
total.unrealizedPNL += report.unrealizedPNL
total.fees += report.fees
total.netPNL += report.netPNL
total.LMV += report.LMV
total.SMV += report.SMV
total.EOD += report.EOD
total.reportDate = report_date
total.save()
def test_report_delete(self):
report = Report(date_run=datetime.now(), table={"hello": "again"}, template=self.template)
report.save()
rid = report.id
try:
r = Report.objects.get(pk=rid)
exists = True
except ReportTemplate.DoesNotExist:
exists = False
self.assertTrue(exists)
r.delete()
try:
Report.objects.get(pk=rid)
exists = True
except Report.DoesNotExist:
exists = False
self.assertFalse(exists)
class ReportTest(TestCase):
fixtures = ["schemas.json", "graphs.json", "queries.json", "reports.json"]
def setUp(self):
self.graph = Graph.objects.get(pk=1)
self.template = ReportTemplate(name="test",
start_date=datetime.now(),
frequency="h",
last_run=datetime.now(),
layout={"hello": "world"},
description="Some",
graph=self.graph)
self.template.save()
self.template_id = self.template.id
self.datetime = datetime.now()
self.report = Report(date_run=self.datetime,
table={"hello": "again"},
template=self.template)
self.report.save()
def test_report_creation(self):
self.assertIsNotNone(self.report)
self.assertEqual(self.report.date_run, self.datetime)
def test_report_delete(self):
report = Report(date_run=datetime.now(),
table={"hello": "again"},
template=self.template)
report.save()
rid = report.id
try:
r = Report.objects.get(pk=rid)
exists = True
except ReportTemplate.DoesNotExist:
exists = False
self.assertTrue(exists)
r.delete()
try:
Report.objects.get(pk=rid)
exists = True
except Report.DoesNotExist:
exists = False
self.assertFalse(exists)
def test_report_delete(self):
report = Report(date_run=datetime.now(),
table={"hello": "again"},
template=self.template)
report.save()
rid = report.id
try:
r = Report.objects.get(pk=rid)
exists = True
except ReportTemplate.DoesNotExist:
exists = False
self.assertTrue(exists)
r.delete()
try:
Report.objects.get(pk=rid)
exists = True
except Report.DoesNotExist:
exists = False
self.assertFalse(exists)
class ReportTest(TestCase):
fixtures = ["schemas.json", "graphs.json", "queries.json", "reports.json"]
def setUp(self):
self.graph = Graph.objects.get(pk=1)
self.template = ReportTemplate(
name="test",
start_date=datetime.now(),
frequency="h",
last_run=datetime.now(),
layout={"hello": "world"},
description="Some",
graph=self.graph,
)
self.template.save()
self.template_id = self.template.id
self.datetime = datetime.now()
self.report = Report(date_run=self.datetime, table={"hello": "again"}, template=self.template)
self.report.save()
def test_report_creation(self):
self.assertIsNotNone(self.report)
self.assertEqual(self.report.date_run, self.datetime)
def test_report_delete(self):
report = Report(date_run=datetime.now(), table={"hello": "again"}, template=self.template)
report.save()
rid = report.id
try:
r = Report.objects.get(pk=rid)
exists = True
except ReportTemplate.DoesNotExist:
exists = False
self.assertTrue(exists)
r.delete()
try:
Report.objects.get(pk=rid)
exists = True
except Report.DoesNotExist:
exists = False
self.assertFalse(exists)
def post(self, request):
success_message = ''
report = Report()
report.school = request.POST.get('centro', '')
report.name = request.POST.get('name', '')
report.level = request.POST.get('level', '')
report.email = request.POST.get('email', '')
report.description = request.POST.get('description', '')
report.save()
"""
if form.is_valid():
form = ReportForm()
success_message = u'¡Guardado con éxito!'
context = {
'form': form,
'success_message': success_message
}
"""
url = request.GET.get('next', 'home')
return redirect(url)
def test_returns_applications_with_report_last_update(self):
report = Report()
report.save()
application = Application(name='app_name',
handle='handle',
report=report)
application.save()
client = APIClient()
response = client.get('/api/applications')
self.assertEqual(response.status_code, 200)
self.assertContains(response, application.name, 1)
report_updated_at = application.report.updated_at
response_application = response.json()['applications'][0]
self.assertEqual(response_application['name'], application.name)
self.assertEqual(response_application['handle'], application.handle)
self.assertEqual(response_application['report_updated_at'],
report_updated_at.timestamp())
def test_should_not_include_more_than_X_trackers(self):
tracker_limit = 21
for x in range(0, tracker_limit):
tracker = Tracker(name='Tracker{}.'.format(x))
tracker.save()
extra_tracker = Tracker(name='Exodus Super Tracker')
extra_tracker.save()
first_trackers = Tracker.objects.exclude(name=extra_tracker.name)
report = Report()
report.save()
report.found_trackers = [t.id for t in first_trackers]
report.save()
c = Client()
response = c.get(self.STATS_PATH)
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, extra_tracker.name)
for t in first_trackers:
self.assertContains(response, t.name, 1)
def submit(request):
if not request.GET.has_key("imei"):
return HttpResponse("Expected additional parameters")
imei = request.GET["imei"]
nmea_str = request.GET["rmc"]
nmea_list = nmea_str.split(",")
# Sanav sentence is of type GPRMC with a couple extra attributes for voltage and report type
# imei - first parameter before sentence, provides a unique id for the device
# NMEA type - $GPRMC
# UTC time - 095838.000 hhmmss.sss
# Status - A
# Lat - 2458.9733 ddmm.mmmm Degree Decimal Minute
# Lat dir - N
# Lon - 12125.6583 ddmm.mmmm Degree Decimal Minute
# Lon dir - E
# Speed knots - 0.41
# Course - 79.21
# UTC Date - 220905 ddmmyy
# Mag. deviation - blank
# Checksum - *30
# Voltage - 3777mv
# Report type - POLL
rep_time = nmea_list[1]
rep_lat = nmea_list[3]
rep_lat_dir = nmea_list[4]
rep_lon = nmea_list[5]
rep_lon_dir = nmea_list[6]
rep_date = nmea_list[9]
r = Report()
r.imei = imei
r.nmea_type = nmea_list[0][1:]
r.status = nmea_list[2]
r.speed = nmea_list[7]
r.course = nmea_list[8]
r.voltage = nmea_list[12][0:-2]
r.rep_type = nmea_list[13]
r.nmea_sentence = nmea_str
# parse and build location
lon_dd = float(rep_lon[:-7]) + float(rep_lon[-7:]) / 60.0
if rep_lon_dir == "W":
lon_dd *= -1
lat_dd = float(rep_lat[:-7]) + float(rep_lat[-7:]) / 60.0
if rep_lat_dir == "S":
lat_dd *= -1
r.loc = Point(lon_dd, lat_dd)
# parse and build timestamp
year = int(rep_date[4:6])
month = int(rep_date[2:4])
day = int(rep_date[0:2])
hour = int(rep_time[0:2])
minute = int(rep_time[2:4])
sec = int(rep_time[4:6])
ms = int(rep_time[7:])
r.timestamp = datetime.datetime(year, month, day, hour, minute, sec, ms)
r.save()
return HttpResponse("Report logged")
def submit(request):
if not request.GET.has_key('imei'):
return HttpResponse("Expected additional parameters")
imei = request.GET['imei']
nmea_str = request.GET['rmc']
nmea_list = nmea_str.split(",")
#Sanav sentence is of type GPRMC with a couple extra attributes for voltage and report type
#imei - first parameter before sentence, provides a unique id for the device
#NMEA type - $GPRMC
#UTC time - 095838.000 hhmmss.sss
#Status - A
#Lat - 2458.9733 ddmm.mmmm Degree Decimal Minute
#Lat dir - N
#Lon - 12125.6583 ddmm.mmmm Degree Decimal Minute
#Lon dir - E
#Speed knots - 0.41
#Course - 79.21
#UTC Date - 220905 ddmmyy
#Mag. deviation - blank
#Checksum - *30
#Voltage - 3777mv
#Report type - POLL
rep_time = nmea_list[1]
rep_lat = nmea_list[3]
rep_lat_dir = nmea_list[4]
rep_lon = nmea_list[5]
rep_lon_dir = nmea_list[6]
rep_date = nmea_list[9]
r = Report()
r.imei = imei
r.nmea_type = nmea_list[0][1:]
r.status = nmea_list[2]
r.speed = nmea_list[7]
r.course = nmea_list[8]
r.voltage = nmea_list[12][0:-2]
r.rep_type = nmea_list[13]
r.nmea_sentence = nmea_str
#parse and build location
lon_dd = float(rep_lon[:-7]) + float(rep_lon[-7:]) / 60.0
if rep_lon_dir == 'W':
lon_dd *= -1
lat_dd = float(rep_lat[:-7]) + float(rep_lat[-7:]) / 60.0
if rep_lat_dir == 'S':
lat_dd *= -1
r.loc = Point(lon_dd, lat_dd)
#parse and build timestamp
year = int(rep_date[4:6])
month = int(rep_date[2:4])
day = int(rep_date[0:2])
hour = int(rep_time[0:2])
minute = int(rep_time[2:4])
sec = int(rep_time[4:6])
ms = int(rep_time[7:])
r.timestamp = datetime.datetime(year, month, day, hour, minute, sec, ms)
r.save()
return HttpResponse("Report logged")
def send(request):
# Obtenemos los campos comunes entre reportes
report_type = request.POST.get("form_type", "")
doc_name = request.POST.get("nombre_dr", "")
patient_name = request.POST.get("nombre_pac", "")
consult_date = request.POST.get("fecha", "")
observ = request.POST.get("observaciones", "")
# Variables comunes
url = "https://android.googleapis.com/gcm/send"
headers = {"Content-Type": "application/json", "Authorization": "key=AIzaSyCH7B7qMMbLnQdj6WG1yuvPp3SlsLHtBds"}
# Creamos un objeto del tipo reporte del que heredará la info el reporte específico
rep = Report(
doc_name=doc_name, patient_name=patient_name, consult_date=consult_date, report_type=report_type, observ=observ
)
rep.save()
if report_type == "psicologico":
# Obtenemos campos únicos de reporte psicologico
patient_state = request.POST.get("estado_pac", "")
suggest = request.POST.get("sugerencias", "")
psy = PsyReport(report=rep, patient_state=patient_state, suggest=suggest)
psy.save()
print >>sys.stderr, psy.report
# Payload del reporte psicologico
payload = {
"data": {
"id": psy.report.id,
"tipo": report_type,
"fecha": consult_date,
"doctor": doc_name,
"paciente": patient_name,
"observaciones": observ,
"sugerencias": suggest,
},
"registration_ids": [
"APA91bHDXfzISMoo6OfqhhODnU7TeNzqCxeE7lYZHhdI801wazh1e7vbITZVTqwKU5avNW0myInlZW3Aat3S8gzqawN9G5fQEkMVNvqkDHRRYt1IDsFrPuc"
],
}
elif report_type == "nutricional":
# Obtenemos campos únicos de reporte nutricional
weight = request.POST.get("peso", "")
height = request.POST.get("talla", "")
pressure = request.POST.get("presion", "")
risk_factors = request.POST.get("fac_riesgo", "")
appetite = request.POST.get("est_apetito", "")
diet = request.POST.get("dieta", "")
nut = NutReport(
report=rep,
weight=weight,
height=height,
pressure=pressure,
risk_factors=risk_factors,
appetite=appetite,
diet=diet,
)
nut.save()
# Payload del reporte psicologico
payload = {
"data": {
"id": nut.report.id,
"tipo": report_type,
"fecha": consult_date,
"doctor": doc_name,
"paciente": patient_name,
"observaciones": observ,
"peso": weight,
"talla": height,
"presion": pressure,
"fac_riesgo": risk_factors,
"est_apetito": appetite,
"dieta": diet,
},
"registration_ids": [
"APA91bHDXfzISMoo6OfqhhODnU7TeNzqCxeE7lYZHhdI801wazh1e7vbITZVTqwKU5avNW0myInlZW3Aat3S8gzqawN9G5fQEkMVNvqkDHRRYt1IDsFrPuc"
],
}
# El envío de la notificación es común para los reportes
try:
# r = requests.post(url, data=json.dumps(payload))
r = requests.post(url, headers=headers, data=json.dumps(payload))
except requests.exceptions.ConnectionError:
if report_type == "psicologico":
return render(
request,
"reports/psychological.html",
{"error_message": "No hay conexión a internet, intente más tarde"},
)
elif report_type == "nutricional":
return render(
request, "reports/nutritional.html", {"error_message": "No hay conexión a internet, intente más tarde"}
)
else:
print >>sys.stderr, "POST request response: ", r.status_code
if r.status_code == 200:
code = 0
else:
code = 1
return HttpResponseRedirect(reverse("reports:results", args=(rep.id, code)))
pass
def test_should_return_stats_with_multiple_trackers_found(self):
tracker1 = Tracker(
id=1,
name='Teemo',
)
tracker1.save()
tracker2 = Tracker(
id=2,
name='Exodus Super Tracker',
)
tracker2.save()
report1 = Report()
report1.save()
report1.found_trackers = [tracker2.id]
report1.save()
report2 = Report()
report2.save()
report2.found_trackers = []
report2.save()
report3 = Report()
report3.save()
report3.found_trackers = [tracker1.id, tracker2.id]
report3.save()
c = Client()
response = c.get(self.STATS_PATH)
self.assertEqual(response.status_code, 200)
self.assertContains(response, tracker1.name, 1)
self.assertContains(response, tracker2.name, 1)
self.assertEqual(response.context['trackers'][0].name, tracker2.name)
self.assertEqual(response.context['trackers'][0].count, 2)
self.assertEqual(response.context['trackers'][0].score, 66)
self.assertEqual(response.context['trackers'][1].name, tracker1.name)
self.assertEqual(response.context['trackers'][1].count, 1)
self.assertEqual(response.context['trackers'][1].score, 33)
def process_element(elem):
report = Report()
print elem.xpath('safetyreportid/text()')[0]
try:
report.safetyreportid = elem.xpath('safetyreportid/text()')[0]
except:
pass
try:
report.safetyreportversion = int_validator(elem.xpath('safetyreportversion/text()')[0])
except:
pass
report.importedfilename = filename
try:
report.primarysourcecountry = str(elem.xpath('primarysourcecountry/text()')[0])
except:
pass
try:
report.occurcountry = str(elem.xpath('occurcountry/text()')[0])
except:
pass
try:
report.transmissiondateformat = str(elem.xpath('transmissiondateformat/text()')[0])
report.transmissiondate = datetime_validator(str(elem.xpath('transmissiondateformat/text()')[0]), str(elem.xpath('transmissiondate/text()')[0]))
except:
pass
try:
report.reporttype = int_validator(elem.xpath('reporttype/text()')[0])
except:
pass
try:
report.serious = boolean_validator(str(elem.xpath('serious/text()')[0]))
except:
pass
try:
report.seriousnessdeath = boolean_validator(str(elem.xpath('seriousnessdeath/text()')[0]))
except:
pass
try:
report.seriousnesslifethreatening = boolean_validator(str(elem.xpath('seriousnesslifethreatening/text()')[0]))
except:
pass
try:
report.seriousnesshospitalization = boolean_validator(str(elem.xpath('seriousnesshospitalization/text()')[0]))
except:
pass
try:
report.seriousnessdisabling = boolean_validator(str(elem.xpath('seriousnessdisabling/text()')[0]))
except:
pass
try:
report.seriousnesscongenitalanomali = boolean_validator(str(elem.xpath('seriousnesscongenitalanomali/text()')[0]))
except:
pass
try:
report.seriousnessother = boolean_validator(str(elem.xpath('seriousnessother/text()')[0]))
except:
pass
try:
report.receivedateformat = str(elem.xpath('receivedateformat/text()')[0])
report.receivedate = datetime_validator(str(elem.xpath('receivedateformat/text()')[0]), str(elem.xpath('receivedate/text()')[0]))
except:
pass
try:
report.recieptdateformat = str(elem.xpath('receiptdateformat/text()')[0])
report.recieptdate = datetime_validator(str(elem.xpath('receiptdateformat/text()')[0]), str(elem.xpath('receiptdate/text()')[0]))
except:
pass
try:
report.fullfillexpeditecriteria = boolean_validator(str(elem.xpath('fulfillexpeditecriteria/text()')[0]))
except:
pass
try:
report.companynumb = str(elem.xpath('companynumb/text()')[0])
except:
pass
try:
report.reportercountry = str(elem.xpath('primarysource/reportercountry/text()')[0])
except:
pass
try:
report.duplicate = null_boolean_validator(str(elem.xpath('duplicate/text()')[0]))
except:
pass
try:
report.qualification = int_validator(elem.xpath('primarysource/qualification/text()')[0])
except:
pass
try:
report.sendertype = int_validator(elem.xpath('sender/sendertype/text()')[0])
except:
pass
try:
report.senderorganization = str(elem.xpath('sender/senderorganization/text()')[0])
except:
pass
try:
report.receivertype = int_validator(elem.xpath('receiver/receivertype/text()')[0])
except:
pass
try:
report.receiverorganization = str(elem.xpath('receiver/receiverorganization/text()')[0])
except:
pass
try:
report.patientonsetage = float(elem.xpath('patient/patientonsetage/text()')[0])
except:
pass
try:
report.patientonsetageunit = int_validator(elem.xpath('patient/patientonsetageunit/text()')[0])
except:
pass
try:
report.patientweight = float(elem.xpath('patient/patientweight/text()')[0])
except:
pass
try:
report.patientsex = int_validator(elem.xpath('patient/patientsex/text()')[0])
except:
pass
report.save()
reportduplicates = elem.xpath('reportduplicate')
# We delete any existing reportduplicates
ReportDuplicate.objects.get(report=safetyreportid).delete()
for item in reportduplicates:
duplicate = ReportDuplicate()
duplicate.report = Report.objects.get(safetyreportid=report.safetyreportid)
try:
duplicate.duplicatesource = str(item.xpath('duplicatesource/text()')[0])
except:
pass
try:
duplicate.duplicatenumb = str(item.xpath('duplicatenumb/text()')[0])
except:
pass
duplicate.save()
reactions = elem.xpath('patient/reaction')
# We delete any existing reactions
Reaction.objects.get(report=safetyreportid).delete()
for item in reactions:
reaction = Reaction()
reaction.report = Report.objects.get(safetyreportid=report.safetyreportid)
try:
reaction.reactionmeddrapt = str(item.xpath('reactionmeddrapt/text()')[0])
except:
pass
try:
reaction.reactionmeddraversionpt = str(item.xpath('reactionmeddraversionpt/text()')[0])
except:
pass
try:
reaction.reactionoutcome = int_validator(item.xpath('reactionoutcome/text()')[0])
except:
pass
reaction.save()
drugs = elem.xpath('patient/drug')
# We delete any existing drugs
Drug.objects.get(report=safetyreportid).delete()
for item in drugs:
drug = Drug()
drug.report = Report.objects.get(safetyreportid=report.safetyreportid)
try:
drug.drugcharacterization = int_validator(item.xpath('drugcharacterization/text()')[0])
except:
pass
try:
drug.medicinalproduct = str(item.xpath('medicinalproduct/text()')[0])
except:
pass
try:
drug.drugbatchnumb = str(item.xpath('drugbatchnumb/text()')[0])
except:
pass
try:
drug.drugauthorizationnumb = str(item.xpath('drugauthorizationnumb/text()')[0])
except:
pass
try:
drug.drugstructuredosagenumb = str(item.xpath('drugstructuredosagenumb/text()')[0])
except:
pass
try:
drug.drugstructureddosageunit = int_validator(item.xpath('drugstructureddosageunit/text()')[0])
except:
pass
try:
drug.drugseparatedosagenumb = float(item.xpath('drugseparatedosagenumb/text()')[0])
except:
pass
try:
drug.drugintervaldosageunitnumb = float(item.xpath('drugintervaldosageunitnumb/text()')[0])
except:
pass
try:
drug.drugintervaldosagedefinition = int_validator(item.xpath('drugintervaldosagedefinition/text()')[0])
except:
pass
try:
drug.drugcumulativedosagenumb = float(item.xpath('drugcumulativedosagenumb/text()')[0])
except:
pass
try:
drug.drugcumulativedosageunit = int_validator(item.xpath('drugcumulativedosageunit/text()')[0])
except:
pass
try:
drug.drugdosagetext = str(item.xpath('drugdosagetext/text()')[0])
except:
pass
try:
drug.drugdosageform = str(item.xpath('drugdosageform/text()')[0])
except:
pass
try:
drug.drugadministrationroute = int_validator(item.xpath('drugadministrationroute/text()')[0])
except:
pass
try:
drug.drugindication = str(item.xpath('drugindication/text()')[0])
except:
pass
try:
drug.drugstartdateformat = str(item.xpath('drugstartdateformat/text()')[0])
drug.drugstartdate = datetime_validator(str(item.xpath('drugstartdateformat/text()')[0]), str(item.xpath('drugstartdate/text()')[0]))
except:
pass
try:
drug.drugenddateformat = str(item.xpath('drugenddateformat/text()')[0])
drug.drugenddate = datetime_validator(str(item.xpath('drugenddateformat/text()')[0]), str(item.xpath('drugenddate/text()')[0]))
except:
pass
try:
drug.drugtreatmentduration = float(item.xpath('drugtreatmentduration/text()')[0])
except:
pass
try:
drug.drugtreatmentdurationunit = int_validator(item.xpath('drugtreatmentdurationunit/text()')[0])
except:
pass
try:
drug.actiondrug = int_validator(item.xpath('actiondrug/text()')[0])
except:
pass
try:
drug.drugrecurreadministration = null_boolean_validator(str(item.xpath('drugrecurreadministration/text()')[0]))
except:
pass
try:
drug.drugadditional = null_boolean_validator(str(item.xpath('drugadditional/text()')[0]))
except:
pass
drug.save()
def test_should_return_stats_with_single_report_one_application(self):
tracker1 = Tracker(
id=1,
name='Teemo',
)
tracker1.save()
tracker2 = Tracker(
id=2,
name='Exodus Super Tracker',
)
tracker2.save()
application_handle = "com.exodus.one"
report1 = Report()
report1.save()
application1 = Application(
handle=application_handle,
report=report1
)
application1.save()
report1.found_trackers = [tracker2.id]
report1.save()
report2 = Report()
report2.save()
application2 = Application(
handle=application_handle,
report=report2
)
application2.save()
report2.found_trackers = []
report2.save()
report3 = Report()
report3.save()
application3 = Application(
handle=application_handle,
report=report3
)
application3.save()
report3.found_trackers = [tracker1.id, tracker2.id]
report3.save()
c = Client()
response = c.get(self.STATS_PATH)
self.assertEqual(response.status_code, 200)
self.assertContains(response, tracker1.name, 1)
self.assertContains(response, tracker2.name, 1)
self.assertEqual(response.context['trackers'][0].name, tracker2.name)
# Only recent for an application is considered
self.assertEqual(response.context['trackers'][0].count, 1)
self.assertEqual(response.context['trackers'][0].score, 100)
self.assertEqual(response.context['trackers'][1].name, tracker1.name)
self.assertEqual(response.context['trackers'][1].count, 1)
self.assertEqual(response.context['trackers'][1].score, 100)
def send(request):
# Obtenemos los campos comunes entre reportes
report_type = request.POST.get('form_type', "")
doc_name = request.POST.get('nombre_dr', "")
patient_name = request.POST.get('nombre_pac', "")
consult_date = request.POST.get('fecha', "")
observ = request.POST.get('observaciones', "")
# Variables comunes
url = 'https://android.googleapis.com/gcm/send'
headers = {
'Content-Type': 'application/json',
'Authorization': 'key=AIzaSyCH7B7qMMbLnQdj6WG1yuvPp3SlsLHtBds'
}
# Creamos un objeto del tipo reporte del que heredará la info el reporte específico
rep = Report(doc_name=doc_name,
patient_name=patient_name,
consult_date=consult_date,
report_type=report_type,
observ=observ)
rep.save()
if report_type == "psicologico":
# Obtenemos campos únicos de reporte psicologico
patient_state = request.POST.get('estado_pac', "")
suggest = request.POST.get('sugerencias', "")
psy = PsyReport(report=rep,
patient_state=patient_state,
suggest=suggest)
psy.save()
print >> sys.stderr, psy.report
# Payload del reporte psicologico
payload = {
"data": {
"id": psy.report.id,
"tipo": report_type,
"fecha": consult_date,
"doctor": doc_name,
"paciente": patient_name,
"observaciones": observ,
"sugerencias": suggest
},
"registration_ids": [
"APA91bHDXfzISMoo6OfqhhODnU7TeNzqCxeE7lYZHhdI801wazh1e7vbITZVTqwKU5avNW0myInlZW3Aat3S8gzqawN9G5fQEkMVNvqkDHRRYt1IDsFrPuc"
]
}
elif report_type == "nutricional":
# Obtenemos campos únicos de reporte nutricional
weight = request.POST.get('peso', "")
height = request.POST.get('talla', "")
pressure = request.POST.get('presion', "")
risk_factors = request.POST.get('fac_riesgo', "")
appetite = request.POST.get('est_apetito', "")
diet = request.POST.get('dieta', "")
nut = NutReport(report=rep,
weight=weight,
height=height,
pressure=pressure,
risk_factors=risk_factors,
appetite=appetite,
diet=diet)
nut.save()
# Payload del reporte psicologico
payload = {
"data": {
"id": nut.report.id,
"tipo": report_type,
"fecha": consult_date,
"doctor": doc_name,
"paciente": patient_name,
"observaciones": observ,
"peso": weight,
"talla": height,
"presion": pressure,
"fac_riesgo": risk_factors,
"est_apetito": appetite,
"dieta": diet
},
"registration_ids": [
"APA91bHDXfzISMoo6OfqhhODnU7TeNzqCxeE7lYZHhdI801wazh1e7vbITZVTqwKU5avNW0myInlZW3Aat3S8gzqawN9G5fQEkMVNvqkDHRRYt1IDsFrPuc"
]
}
# El envío de la notificación es común para los reportes
try:
#r = requests.post(url, data=json.dumps(payload))
r = requests.post(url, headers=headers, data=json.dumps(payload))
except requests.exceptions.ConnectionError:
if report_type == "psicologico":
return render(request, 'reports/psychological.html', {
'error_message':
"No hay conexión a internet, intente más tarde",
})
elif report_type == "nutricional":
return render(request, 'reports/nutritional.html', {
'error_message':
"No hay conexión a internet, intente más tarde",
})
else:
print >> sys.stderr, "POST request response: ", r.status_code
if r.status_code == 200:
code = 0
else:
code = 1
return HttpResponseRedirect(
reverse('reports:results', args=(rep.id, code)))
pass
for row in range(data.shape[0]):
report = Report()
report.alert_type = data.iloc[row]['Alert_Type']
report.alert_name = data.iloc[row]['Alert_Name']
report.priorty = data.iloc[row]['Priorty']
report.malaware_family = data.iloc[row]['Malaware_family']
report.http_hostname = data.iloc[row]['HTTP_Hostname']
report.attack_reference = data.iloc[row]['Attack_reference']
report.src_hostname = data.iloc[row]['Src_hostname']
report.src_ip = data.iloc[row]['Src_ip']
report.dst_ip = data.iloc[row]['Dst_ip']
report.dst_country = data.iloc[row]['Dst_country']
report.time = data.iloc[row]['time']
report.reference_url = data.iloc[row]['reference_URL']
report.src_country = data.iloc[row]['src_Country']
report.dst_hostname = data.iloc[row]['Dst_Hostname']
report.recommendation = data.iloc[row]['Recommendation']
report.description = data.iloc[row]['description']
report.other_tls_subject = data.iloc[row]['Other_TLS_Subject']
report.other_tls_fingerprint = data.iloc[row]['Other_TLS_Fingerprint']
report.other_username = data.iloc[row]['Other_Username']
report.other_source_nt_domain = data.iloc[row]['Other_SOURCE_NT_DOMAIN']
report.other_destination_asset = data.iloc[row]['Other_DESTINATION_ASSET']
report.other = data.iloc[row]['OTHER']
report.save()
print('Record saved ', row)
def details(request, user, project, id):
project = Project.objects.filter(slug=project).first()
model = Model.objects.filter(id=id).first()
model_access_choices = ['PU', 'PR', 'LI']
model_access_choices.remove(model.access)
deployments = DeploymentInstance.objects.filter(model=model)
report_generators = ReportGenerator.objects.filter(project=project)
unfinished_reports = Report.objects.filter(status='P').order_by('created_at')
for report in unfinished_reports:
populate_report_by_id(report.id)
reports = Report.objects.filter(model__id=id, status='C').order_by('-created_at')
report_dtos = []
for report in reports:
report_dtos.append({
'id': report.id,
'description': report.description,
'created_at': report.created_at,
'filename': get_download_link(project.pk, 'report_{}.json'.format(report.id))
})
if request.method == 'POST':
file_path = None
form = GenerateReportForm(request.POST)
if form.is_valid():
generator_id = int(form.cleaned_data['generator_file'])
generator_object = ReportGenerator.objects.filter(pk=generator_id).first()
file_path = 'reports/{}'.format(generator_object.generator)
instance = {
'id': str(uuid.uuid4()),
'path_to_file': file_path,
'model_uid': model.uid,
'project_name': project.slug
}
new_report = Report(model=model, report="", job_id=instance['id'], generator=generator_object, status='P')
new_report.save()
l = ProjectLog(project=project, module='MO', headline='Model - {name}'.format(name=model.name),
description='Newly generated Metrics #{id}'.format(id=new_report.pk))
l.save()
from reports.jobs import run_job
run_job(instance)
return HttpResponseRedirect('/{}/{}/models/'.format(user, project.slug))
else:
form = GenerateReportForm()
filename = None
readme = None
import requests as r
url = 'http://{}-file-controller/models/{}/readme'.format(project.slug, model.name)
try:
response = r.get(url)
if response.status_code == 200 or response.status_code == 203:
payload = response.json()
if payload['status'] == 'OK':
filename = payload['filename']
md = markdown.Markdown(extensions=['extra'])
readme = md.convert(payload['readme'])
except Exception as e:
logger.error("Failed to get response from {} with error: {}".format(url, e))
return render(request, 'models_details.html', locals())
def start_static_analysis(analysis):
"""
Compute the entire static analysis
:param analysis: a StaticAnalysis instance
"""
request = AnalysisRequest.objects.get(pk=analysis.query.id)
request.description = _('Your request is running')
request.save()
storage_helper = RemoteStorageHelper(analysis.bucket)
# Download APK and put it on Minio storage
dl_r = download_apk(storage_helper, request.handle, analysis.tmp_dir, analysis.apk_name, analysis.apk_tmp)
if not dl_r:
msg = _('Unable to download the APK')
exit_code = save_error(storage_helper, analysis, request, msg)
return exit_code
change_description(request, _('Download APK: success'))
# Decode the APK file
try:
static_analysis = StaticAnalysis(analysis.apk_tmp)
static_analysis.load_apk()
except Exception as e:
logging.info(e)
msg = _('Unable to decode the APK')
exit_code = save_error(storage_helper, analysis, request, msg)
return exit_code
change_description(request, _('Decode APK: success'))
# List and save embedded classes
try:
with tempfile.NamedTemporaryFile(delete=True) as fp:
static_analysis.save_embedded_classes_in_file(fp.name)
storage_helper.put_file(fp.name, analysis.class_list_file)
except Exception as e:
logging.info(e)
msg = _('Unable to compute the class list')
exit_code = save_error(storage_helper, analysis, request, msg)
return exit_code
change_description(request, _('List embedded classes: success'))
# APK
shasum = static_analysis.get_sha256()
# Application
handle = static_analysis.get_package()
version = static_analysis.get_version()
version_code = static_analysis.get_version_code()
# If a report exists for the same handle, version & version_code, return it
existing_report = Report.objects.filter(
application__handle=handle,
application__version=version,
application__version_code=version_code
).order_by('-creation_date').first()
if existing_report is not None:
clear_analysis_files(storage_helper, analysis.tmp_dir, analysis.bucket, True)
request.description = _('A report already exists for this application version')
request.processed = True
request.report_id = existing_report.id
request.save()
return existing_report.id
# APK
try:
certificates = static_analysis.get_certificates()
except Exception as e:
logging.info(e)
msg = _('Unable to get certificates')
exit_code = save_error(storage_helper, analysis, request, msg)
return exit_code
# Fingerprint
try:
perms = static_analysis.get_permissions()
app_uid = static_analysis.get_application_universal_id()
if len(app_uid) < 16:
raise Exception('Unable to compute the Universal Application ID')
icon_file, icon_phash = static_analysis.get_icon_and_phash(storage_helper, analysis.icon_name)
if len(str(icon_phash)) < 16:
raise Exception('Unable to compute the icon perceptual hash')
except Exception as e:
logging.info(e)
msg = _('Unable to compute APK fingerprint')
exit_code = save_error(storage_helper, analysis, request, msg)
return exit_code
# Application details
try:
app_info = static_analysis.get_app_info()
except Exception as e:
logging.info(e)
msg = _('Unable to get application details from Google Play')
exit_code = save_error(storage_helper, analysis, request, msg)
return exit_code
change_description(request, _('Get application details: success'))
# Find trackers
trackers = static_analysis.detect_trackers()
change_description(request, _('Tracker analysis: success'))
report = Report(
apk_file=analysis.apk_name,
storage_path='',
bucket=request.bucket,
class_list_file=analysis.class_list_file
)
report.save()
net_analysis = NetworkAnalysis(report=report)
net_analysis.save()
app = Application(
report=report,
handle=handle,
version=version,
version_code=version_code,
name=static_analysis.get_app_name(),
icon_phash=icon_phash,
app_uid=app_uid
)
if app_info is not None:
app.name = app_info['title']
app.creator = app_info['creator']
app.downloads = app_info['downloads']
if icon_file != '':
app.icon_path = analysis.icon_name
app.save(force_insert=True)
apk = Apk(
application=app,
name=analysis.apk_name,
sum=shasum
)
apk.save(force_insert=True)
for certificate in certificates:
c = Certificate(
apk=apk,
issuer=certificate.issuer,
fingerprint=certificate.fingerprint,
subject=certificate.subject,
serial_number=certificate.serial
)
c.save(force_insert=True)
for perm in perms:
p = Permission(
application=app,
name=perm
)
p.save(force_insert=True)
report.found_trackers = trackers
report.save()
change_description(request, _('Static analysis complete'))
clear_analysis_files(storage_helper, analysis.tmp_dir, analysis.bucket, False)
request.processed = True
request.report_id = report.id
request.save()
return report.id
def start_static_analysis(params):
"""
Compute the entire static analysis
:param params: a StaticAnalysisParameters instance
"""
request = AnalysisRequest.objects.get(pk=params.query.id)
request.description = _('Your request is running')
request.save()
storage_helper = RemoteStorageHelper(params.bucket)
if request.apk:
if not os.path.exists(params.tmp_dir):
os.mkdir(params.tmp_dir)
with open(params.apk_tmp, 'wb') as out:
out.write(request.apk.read())
storage_helper.put_file(params.apk_tmp, params.apk_name)
request.apk.delete()
else:
if params.source == "google":
if is_paid_app(request.handle):
logging.warn("'{}' is a paid application".format(
request.handle))
msg = _('εxodus cannot scan paid applications')
save_error(storage_helper, params, request, msg)
return EXIT_CODE_PAID_APP_ERROR
# Download APK and put it on Minio storage
dl_r = download_apk(storage_helper, request.handle, params.tmp_dir,
params.apk_name, params.apk_tmp, params.source)
if not dl_r:
logging.error("Could not download '{}'".format(request.handle))
msg = _('Unable to download the APK')
save_error(storage_helper, params, request, msg)
return EXIT_CODE_DOWNLOAD_APK_ERROR
change_description(request, _('Download APK: success'))
# Decode the APK file
try:
static_analysis = StaticAnalysis(params.apk_tmp)
static_analysis.load_apk()
except Exception as e:
logging.info(e)
msg = _('Unable to decode the APK')
save_error(storage_helper, params, request, msg)
return EXIT_CODE_DECODE_APK_ERROR
change_description(request, _('Decode APK: success'))
# List and save embedded classes
try:
with tempfile.NamedTemporaryFile(delete=True) as fp:
static_analysis.save_embedded_classes_in_file(fp.name)
storage_helper.put_file(fp.name, params.class_list_file)
except Exception as e:
logging.info(e)
msg = _('Unable to compute the class list')
save_error(storage_helper, params, request, msg)
return EXIT_CODE_COMPUTE_CLASS_LIST_ERROR
change_description(request, _('List embedded classes: success'))
# APK
shasum = static_analysis.get_sha256()
# Application
handle = static_analysis.get_package()
version = static_analysis.get_version()
version_code = static_analysis.get_version_code()
app_name = static_analysis.get_app_name()
# TODO: increase character limit in DB (see #300)
if not version or not version_code or not app_name or \
len(version) > 50 or len(version_code) > 50 or len(app_name) > 200:
msg = _('Unable to create the analysis report')
save_error(storage_helper, params, request, msg)
return EXIT_CODE_CREATE_REPORT_ERROR
# If a report exists for the same handle, version & version_code, return it
existing_report = Report.objects.filter(
application__handle=handle,
application__source=params.source,
application__version=version,
application__version_code=version_code).order_by(
'-creation_date').first()
if existing_report is not None:
clear_analysis_files(storage_helper, params.tmp_dir, params.bucket,
True)
request.description = _(
'A report already exists for this application version')
request.processed = True
request.report_id = existing_report.id
request.save()
return existing_report.id
# APK
try:
certificates = static_analysis.get_certificates()
except Exception as e:
logging.info(e)
msg = _('Unable to get certificates')
save_error(storage_helper, params, request, msg)
return EXIT_CODE_GET_CERTFICATES_ERROR
# Fingerprint
try:
perms = static_analysis.get_permissions()
app_uid = static_analysis.get_application_universal_id()
if len(app_uid) < 16:
raise Exception('Unable to compute the Universal Application ID')
icon_phash = static_analysis.get_icon_and_phash(
storage_helper, params.icon_name, params.source)
if len(str(icon_phash)) < 16 and not request.apk:
raise Exception('Unable to compute the icon perceptual hash')
except Exception as e:
logging.info(e)
msg = _('Unable to compute APK fingerprint')
save_error(storage_helper, params, request, msg)
return EXIT_CODE_COMPUTE_APK_FINGERPRINT_ERROR
# Application details
try:
app_info = static_analysis.get_app_info()
except Exception as e:
logging.info(e)
msg = _('Unable to get application details from Google Play')
save_error(storage_helper, params, request, msg)
return EXIT_CODE_GET_DETAILS_APP_ERROR
change_description(request, _('Get application details: success'))
# Find trackers
trackers = static_analysis.detect_trackers()
change_description(request, _('Tracker analysis: success'))
report = Report(apk_file=params.apk_name,
storage_path='',
bucket=request.bucket,
class_list_file=params.class_list_file)
report.save()
app = Application(
report=report,
handle=handle,
version=version,
version_code=version_code,
name=app_name,
icon_phash=icon_phash,
app_uid=app_uid,
source=params.source,
icon_path=params.icon_name,
)
if app_info is not None:
app.name = app_info['title']
app.creator = app_info['creator']
app.downloads = app_info['downloads']
app.save(force_insert=True)
apk = Apk(application=app, name=params.apk_name, sum=shasum)
apk.save(force_insert=True)
for certificate in certificates:
c = Certificate(apk=apk,
issuer=certificate.issuer,
fingerprint=certificate.fingerprint,
subject=certificate.subject,
serial_number=certificate.serial)
c.save(force_insert=True)
for perm in perms:
p = Permission(application=app, name=perm)
p.save(force_insert=True)
report.found_trackers.set(trackers)
change_description(request, _('Static analysis complete'))
clear_analysis_files(storage_helper, params.tmp_dir, params.bucket, False)
request.processed = True
request.report_id = report.id
request.save()
return report.id
class ReportPopulator():
"""
Class to handle the population of report records from the submission endpoints.
"""
def __init__(self, submission, agency, user):
self.submission = submission
self.agency = agency
self.user = user
self.report = None
def populate(self):
self.get_report_if_exists()
self._report_upsert()
self._report_link_upsert()
self._report_file_upsert()
def get_report_if_exists(self):
"""
Checks if there is a record existing with the submitted report_id or local identifier.
"""
report = self.submission.get('report_id', None)
if report:
self.report = report
return
local_identifier = self.submission.get('local_identifier', None)
if local_identifier is not None:
try:
self.report = Report.objects.get(
agency=self.agency, local_identifier=local_identifier)
except ObjectDoesNotExist:
self.report = None
def _report_upsert(self):
"""
Create or update a Report record.
"""
activity = self.submission.get('esg_activity', None)
report_name = activity.activity + ' (by ' + self.agency.acronym_primary + ')'
# Update report
if self.report is not None:
self.report.name = report_name
self.report.agency = self.agency
self.report.local_identifier = self.submission.get(
'local_identifier', None)
self.report.agency_esg_activity = activity
self.report.status = self.submission.get('status', None)
self.report.decision = self.submission.get('decision', None)
self.report.valid_from = self.submission.get('valid_from', None)
self.report.valid_to = self.submission.get('valid_to', None)
self.report.updated_by = self.user
self.report.updated_at = datetime.now()
self.report.other_comment = self.submission.get(
'other_comment', None)
Report.contributing_agencies.through.objects.all().delete()
# Create report
else:
self.report = Report(
name=report_name,
agency=self.agency,
local_identifier=self.submission.get('local_identifier', None),
agency_esg_activity=self.submission.get('esg_activity', None),
status=self.submission.get('status', None),
decision=self.submission.get('decision', None),
valid_from=self.submission.get('valid_from', None),
valid_to=self.submission.get('valid_to', None),
created_by=self.user,
other_comment=self.submission.get('other_comment', None))
# Assign contributing agencies
contributing_agencies = self.submission.get('contributing_agencies',
[])
for contributing_agency in contributing_agencies:
self.report.contributing_agencies.add(contributing_agency)
self.report.save()
def _report_link_upsert(self):
"""
Create or update a ReportLink object.
"""
report_links = self.submission.get('report_links', None)
if report_links is not None:
# Remove existing report links
self.report.reportlink_set.all().delete()
for report_link in report_links:
self.report.reportlink_set.create(
link_display_name=report_link.get(
'link_display_name',
"View report record on agency site"),
link=report_link.get('link', None))
def _report_file_upsert(self):
"""
Create or update a ReportFile instance.
"""
report_files = self.submission.get('report_files', None)
if report_files is not None or report_files != '' or report_files != []:
# Remove existing report files
self.report.reportfile_set.all().delete()
for report_file in report_files:
languages = report_file.get('report_language', [])
file_display_name = report_file.get('display_name', None)
if file_display_name is None:
url = report_file.get('original_location', "")
file_display_name = url[url.rfind("/") + 1:]
original_location = report_file.get('original_location', "")
rf = self.report.reportfile_set.create(
file_display_name=file_display_name,
file_original_location=original_location)
# Async file download with celery
if original_location != "":
download_file.delay(original_location, rf.id,
self.agency.acronym_primary)
for lang in languages:
rf.languages.add(lang)
