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)
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)