def get_report_data(self):
self.get_report_data_tables()
self.request_dt_from, self.request_dt_to = get_period(
self.input_data['date_begin'], self.input_data['date_end'])
cleanup_and_request_report(self.request.user,
self.report_template_id,
self.sess_id,
item_id=self.unit_id)
try:
r = exec_report(self.request.user,
self.report_template_id,
self.sess_id,
self.request_dt_from,
self.request_dt_to,
object_id=self.unit_id)
except ReportException as e:
raise WialonException(
'Не удалось получить в Wialon отчет о поездках: %s' % e)
for table_index, table_info in enumerate(r['reportResult']['tables']):
if table_info['name'] not in self.report_data:
continue
try:
rows = get_report_rows(self.sess_id,
table_index,
table_info['rows'],
level=1)
if table_info['name'] != 'unit_sensors_tracing':
self.report_data[table_info['name']] = rows
else:
for row in rows:
if isinstance(row['c'][0], dict):
key = row['c'][0]['v']
else:
key = parse_wialon_report_datetime(row['c'][0])
key = int(
local_to_utc_time(
key,
self.request.user.timezone).timestamp())
if key and row['c'][1]:
self.fuel_data[key] = parse_float(
row['c'][1]) or .0
except ReportException as e:
raise WialonException(
'Не удалось получить в Wialon отчет о поездках: %s' % e)
def exec_report(self):
template_id = get_wialon_report_template_id('taxiing', self.user,
self.sess_id)
cleanup_and_request_report(self.user, template_id, self.sess_id)
report = exec_report(self.user,
template_id,
self.sess_id,
self.utc_timestamp_from,
self.utc_timestamp_to,
object_id=self.object_id)
self.print_time_needed('Exec report')
for table_index, table_info in enumerate(
report['reportResult']['tables']):
label = table_info['label'].lower()
if label not in MOVING_SERVICE_MAPPING:
continue
mapping = MOVING_SERVICE_MAPPING[label]
name = mapping['name']
if name not in self.tables:
continue
level = mapping['level']
renderer = mapping['renderer']
rows = get_report_rows(self.sess_id,
table_index,
table_info['rows'],
level=level)
for row in rows:
unit_key = row['c'][0].strip()
if unit_key not in self.units_dict:
continue
unit_obj = self.report_data[unit_key]
params = {'tz': self.user.timezone}
data = renderer(
[row['c']] if level < 2 else [x['c'] for x in row['r']],
**params)
getattr(unit_obj, name).extend_source(data)
self.print_time_needed('Parse report')
def get_context_data(self, **kwargs):
kwargs = super(FaultsView, self).get_context_data(**kwargs)
form = kwargs['form']
kwargs['today'] = datetime.date.today()
if self.request.POST:
self.report_data = []
if form.is_valid():
self.sess_id = self.request.session.get('sid')
if not self.sess_id:
raise ReportException(WIALON_NOT_LOGINED)
self.user = User.objects.filter(is_active=True) \
.filter(wialon_username=self.request.session.get('user')).first()
if not self.user:
raise ReportException(WIALON_USER_NOT_FOUND)
report_date = form.cleaned_data['dt']
job_extra_offset = datetime.timedelta(
seconds=form.cleaned_data['job_extra_offset'] * 60 * 60)
units_list = get_units(self.sess_id)
units_cache = {u['id']: u['name'] for u in units_list}
dt_from_local = datetime.datetime.combine(
report_date, datetime.time(0, 0, 0))
dt_to_local = datetime.datetime.combine(
report_date, datetime.time(23, 59, 59))
dt_from_utc = local_to_utc_time(dt_from_local,
self.user.timezone)
dt_to_utc = local_to_utc_time(dt_to_local, self.user.timezone)
self.sensors_template_id = get_wialon_report_template_id(
'sensors', self.user, self.sess_id)
last_data_template_id = get_wialon_report_template_id(
'last_data', self.user, self.sess_id)
ura_user = self.user.ura_user if self.user.ura_user_id else self.user
jobs = Job.objects.filter(
user=ura_user,
date_begin__lt=dt_to_utc,
date_end__gt=dt_from_utc).order_by('unit_title')
if jobs:
dt_from, dt_to = get_period(dt_from_local, dt_to_local,
self.user.timezone)
cleanup_and_request_report(self.user,
last_data_template_id,
self.sess_id)
r = exec_report(self.user, last_data_template_id,
self.sess_id, dt_from, dt_to)
for table_index, table_info in enumerate(
r['reportResult']['tables']):
rows = get_report_rows(self.sess_id,
table_index,
table_info['rows'],
level=1)
if table_info['name'] == 'unit_group_location':
self.last_data = {
r['c'][0]: r['c'][1:]
for r in rows
}
break
jobs_count = len(jobs)
print('Всего ПЛ при анализе состояния оборудования: %s' %
jobs_count)
for i, job in enumerate(jobs):
try:
unit_name = units_cache.get(int(job.unit_id))
except (ValueError, AttributeError, TypeError):
unit_name = ''
if not unit_name:
print('ТС не найден! %s' % job.unit_id)
continue
print('%s/%s) %s' % (i + 1, jobs_count, unit_name))
self.stats['total'].add(unit_name)
job_local_date_begin = utc_to_local_time(
job.date_begin - job_extra_offset, self.user.timezone)
job_local_date_to = utc_to_local_time(
job.date_end + job_extra_offset, self.user.timezone)
dt_from, dt_to = get_period(job_local_date_begin,
job_local_date_to,
self.user.timezone)
cleanup_and_request_report(self.user,
self.sensors_template_id,
self.sess_id)
r = exec_report(self.user,
self.sensors_template_id,
self.sess_id,
dt_from,
dt_to,
object_id=int(job.unit_id))
report_tables = {}
for table_index, table_info in enumerate(
r['reportResult']['tables']):
label = table_info['label'].split('(')[0].strip()
if table_info['name'] != 'unit_sensors_tracing':
continue
report_tables[label] = {
'index': table_index,
'rows': table_info['rows']
}
if 'ВСЕ' not in report_tables:
self.add_report_row(job,
unit_name,
'Нет данных от блока мониторинга',
sensor=None)
continue
has_movings = False
for field in self.known_sensors:
if field not in report_tables and field != 'ВСЕ':
# проверим, возможно датчик и не настроен
unit_sensors = self.get_unit_sensors(
int(job.unit_id))
if field.lower() in unit_sensors:
self.add_report_row(
job,
unit_name,
'Нет данных по датчику "%s"' % field,
sensor=field)
continue
# перебираем сначала более маленькие выборки, с целью ускорения работы
attempts = (10, 100,
min(report_tables[field]['rows'], 10000))
for attempt, rows_limit in enumerate(attempts):
# таблицу ВСЕ придется взять целиком, для оценки движения
if field == 'ВСЕ' and attempt != len(attempts) - 1:
continue
rows = get_report_rows(
self.sess_id,
report_tables[field]['index'],
rows_limit,
level=1)
data = [r['c'] for r in rows]
if field == 'ВСЕ':
try:
# есть ли какое-нибудь изменение скорости?
has_movings = len(
set(map(lambda x: x[4], data))) > 1
except IndexError:
pass
analyze_result, values = self.analyze_sensor_data(
field, data)
if analyze_result in (None, True):
if analyze_result:
# все отлично, данные меняются и они есть
pass
elif analyze_result is None:
# данных никаких нет!
# Снова проверяем на наличие датчика в настройках
# проверим, возможно датчик и не настроен
unit_sensors = self.get_unit_sensors(
int(job.unit_id))
if field != 'ВСЕ' and field.lower(
) in unit_sensors:
self.add_report_row(
job,
unit_name,
'Нет данных по датчику "%s"' %
field,
sensor=field)
break
# если в последней попытке тоже не нашел различающиеся данные
elif not analyze_result and attempt == len(
attempts) - 1:
try:
value = float(list(values)[0])
except (ValueError, TypeError, IndexError,
AttributeError):
value = 0
if field in {
'Ближний свет фар', 'Ремень',
'Зажигание', 'GPS антенна'
}:
if value == 1.0:
value = 'Вкл'
elif value == 0.0:
value = 'Выкл'
# всегда включенный GPS - норма
if field == 'GPS антенна' and value == 'Вкл':
continue
# всегда выключенное зажигание или свет фар
# для стоящей техники - норма
elif not has_movings and field in {
'Зажигание', 'Ближний свет фар'
} and value == 'Выкл':
continue
# всегда один и тот же уровень топлива для стоящей техники - норма
elif not has_movings and field == 'Датчик уровня топлива':
continue
# всегда выключенный ремень для стоящей техники - норма
elif not has_movings and field == 'Ремень' and value == 'Выкл':
continue
else:
self.add_report_row(
job,
unit_name,
'Датчик "%s" отправляет одинаковое '
'значение (%s) в течение смены' %
(field, value),
sensor=field)
total_post_processing = len(self.report_data)
for i, report_row in enumerate(self.report_data):
if not report_row['sensor'] or not report_row['unit_id']:
continue
print('%s/%s) Последние данные сенсора "%s" %s' %
(i + 1, total_post_processing, report_row['sensor'],
report_row['unit_name']))
self.update_last_sensor_data(report_row)
self.stats['total'] = len(self.stats['total'])
self.stats['broken'] = len(self.stats['broken'])
kwargs.update(stats=self.stats, report_data=self.report_data)
return kwargs
def update_last_sensor_data(self, report_row, attempt=0):
date_slice_from = attempt * LAST_SIGNAL_STEP
date_slice_to = (attempt + 1) * LAST_SIGNAL_STEP
if date_slice_to > LAST_SIGNAL_UNTIL:
return report_row
now = local_date_to = utc_to_local_time(utcnow(), self.user.timezone)
if date_slice_from:
local_date_to = now - datetime.timedelta(days=date_slice_from)
local_date_from = now - datetime.timedelta(days=date_slice_to)
dt_from, dt_to = get_period(local_date_from, local_date_to,
self.user.timezone)
print('Пробуем период поиска последнего сигнала %s - %s (попытка %s)' %
(local_date_from, local_date_to, attempt + 1))
cleanup_and_request_report(self.user, self.sensors_template_id,
self.sess_id)
r = exec_report(self.user,
self.sensors_template_id,
self.sess_id,
dt_from,
dt_to,
object_id=report_row['unit_id'])
for table_index, table_info in enumerate(r['reportResult']['tables']):
label = table_info['label'].split('(')[0].strip()
if table_info[
'name'] != 'unit_sensors_tracing' or label != report_row[
'sensor']:
continue
if table_info['rows'] == 0:
return self.update_last_sensor_data(report_row,
attempt=attempt + 1)
rows = get_report_rows(self.sess_id, table_index, rows=1, level=1)
if not rows:
return self.update_last_sensor_data(report_row,
attempt=attempt + 1)
dt, place = rows[0]['c'][2], rows[0]['c'][4]
if isinstance(dt, dict):
dt = datetime.datetime.utcfromtimestamp(dt['v'])
dt = utc_to_local_time(dt, self.user.timezone)
else:
dt = parse_wialon_report_datetime(dt)
if isinstance(place, dict) and 't' in place:
place = place['t']
if place:
report_row['place'] = place
if dt:
report_row['dt'] = dt
report_row[
'sum_broken_work_time'] = self.get_sum_broken_work_time(
report_row['unit_id'],
local_to_utc_time(dt, self.user.timezone),
report_row['job_date_end'])
return report_row
return self.update_last_sensor_data(report_row, attempt=attempt + 1)
def get_context_data(self, **kwargs):
kwargs = super(DischargeView, self).get_context_data(**kwargs)
form = kwargs['form']
report_data = None
sess_id = self.request.session.get('sid')
if not sess_id:
raise ReportException(WIALON_NOT_LOGINED)
try:
units_list = get_units(sess_id, extra_fields=True)
except WialonException as e:
raise ReportException(str(e))
kwargs['units'] = units_list
if self.request.POST:
if form.is_valid():
report_data = OrderedDict()
self.user = User.objects.filter(is_active=True)\
.filter(wialon_username=self.request.session.get('user')).first()
if not self.user:
raise ReportException(WIALON_USER_NOT_FOUND)
normal_ratio = 1 + (
form.cleaned_data['overspanding_percentage'] / 100)
units_dict = OrderedDict((u['id'], u) for u in units_list)
selected_unit = form.cleaned_data.get('unit')
if selected_unit and selected_unit in units_dict:
units_dict = {selected_unit: units_dict[selected_unit]}
jobs_count = len(units_dict)
print('Всего ТС: %s' % jobs_count)
dt_from_utc = local_to_utc_time(form.cleaned_data['dt_from'],
self.user.timezone)
dt_to_utc = local_to_utc_time(
form.cleaned_data['dt_to'].replace(hour=23,
minute=59,
second=59),
self.user.timezone)
ura_user = self.user.ura_user if self.user.ura_user_id else self.user
jobs = Job.objects.filter(user=ura_user,
date_begin__lt=dt_to_utc,
date_end__gt=dt_from_utc).order_by(
'date_begin', 'date_end')
jobs_cache = defaultdict(list)
for job in jobs:
try:
jobs_cache[int(job.unit_id)].append(job)
except ValueError:
pass
template_id = get_wialon_report_template_id(
'discharge_individual', self.user, sess_id)
device_fields = defaultdict(lambda: {'extras': .0, 'idle': .0})
i = 0
for unit_id, unit in units_dict.items():
i += 1
unit_name = unit['name']
print('%s/%s) %s' % (i, jobs_count, unit_name))
# норматив потребления доп.оборудования, л / час
extras_values = [
x['v'] for x in unit.get('fields', [])
if x.get('n') == 'механизм'
]
# норматив потребления на холостом ходу, л / час
idle_values = [
x['v'] for x in unit.get('fields', [])
if x.get('n') == 'хх'
]
if extras_values:
try:
device_fields[unit_name]['extras'] = float(
extras_values[0])
except ValueError:
pass
if idle_values:
try:
device_fields[unit_name]['idle'] = float(
idle_values[0])
except ValueError:
pass
if unit_id not in report_data:
report_data[unit_id] = self.get_new_grouping()
report_row = report_data[unit_id]
report_row['unit_name'] = unit_name
report_row['unit_number'] = unit.get('number', '')
report_row['vehicle_type'] = unit.get('vehicle_type', '')
unit_jobs = jobs_cache.get(unit_id)
if not unit_jobs:
report_row['periods'].append(
self.get_new_period(dt_from_utc, dt_to_utc))
else:
if unit_jobs[0].date_begin > dt_from_utc:
# если начало периода не попадает на смену
report_row['periods'].append(
self.get_new_period(dt_from_utc,
unit_jobs[0].date_begin))
previous_job = None
for unit_job in unit_jobs:
# если между сменами есть перерыв, то тоже добавляем период
if previous_job and unit_job.date_begin > previous_job.date_end:
report_row['periods'].append(
self.get_new_period(
previous_job.date_end,
unit_job.date_begin))
report_row['periods'].append(
self.get_new_period(unit_job.date_begin,
unit_job.date_end,
unit_job))
previous_job = unit_job
if unit_jobs[-1].date_end < dt_to_utc:
# если смена закончилась до конца периода
report_row['periods'].append(
self.get_new_period(unit_jobs[-1].date_end,
dt_to_utc))
# получим полный диапазон запроса
dt_from = int(
time.mktime(
report_row['periods'][0]['dt_from'].timetuple()))
dt_to = int(
time.mktime(
report_row['periods'][-1]['dt_to'].timetuple()))
cleanup_and_request_report(self.user, template_id, sess_id)
r = exec_report(self.user,
template_id,
sess_id,
dt_from,
dt_to,
object_id=unit_id)
wialon_report_rows = {}
for table_index, table_info in enumerate(
r['reportResult']['tables']):
rows = get_report_rows(sess_id,
table_index,
table_info['rows'],
level=2 if table_info['name']
== 'unit_thefts' else 1)
wialon_report_rows[table_info['name']] = [
row['c'] for row in rows
]
for period in report_row['periods']:
for row in wialon_report_rows.get('unit_trips', []):
row_dt_from, row_dt_to = self.parse_wialon_report_datetime(
row)
if row_dt_to is None:
row_dt_to = period['dt_to']
if period['dt_from'] < row_dt_from and period[
'dt_to'] > row_dt_to:
delta = (min(row_dt_to, period['dt_to']) -
max(row_dt_from, period['dt_from'])
).total_seconds()
if not delta:
print('empty trip period')
continue
trip_ratio = 1
total_delta = (row_dt_to -
row_dt_from).total_seconds()
if total_delta > 0:
trip_ratio = delta / total_delta
period['mileage'] += parse_float(
row[3]) * trip_ratio
period['move_hours'] += parse_timedelta(row[4]).total_seconds()\
* trip_ratio
for row in wialon_report_rows.get(
'unit_digital_sensors', []):
row_dt_from, row_dt_to = self.parse_wialon_report_datetime(
row)
if row_dt_to is None:
row_dt_to = period['dt_to']
if period['dt_from'] < row_dt_from and period[
'dt_to'] > row_dt_to:
delta = min(row_dt_to, period['dt_to']) - \
max(row_dt_from, period['dt_from'])
period[
'extra_device_hours'] += delta.total_seconds(
)
for row in wialon_report_rows.get('unit_thefts', []):
dt = parse_wialon_report_datetime(
row[1]['t'] if isinstance(row[1], dict
) else row[1])
utc_dt = local_to_utc_time(dt, self.user.timezone)
if period['dt_from'] <= utc_dt <= period['dt_to']:
place = row[0]['t'] if isinstance(
row[0], dict) else (row[0] or '')
if place and not period['discharge']['place']:
period['discharge']['place'] = place
if not period['discharge']['dt']:
period['discharge']['dt'] = dt
try:
volume = float(
row[2].split(' ')[0] if row[2] else .0)
except ValueError:
volume = .0
period['discharge']['volume'] += volume
self.stats['discharge_total'] += volume
self.stats['overspanding_count'] += 1
period['details'].append({
'place': place,
'dt': dt,
'volume': volume
})
extras_value = device_fields.get(unit_name,
{}).get('extras', .0)
idle_value = device_fields.get(unit_name,
{}).get('idle', .0)
for row in wialon_report_rows.get(
'unit_engine_hours', []):
row_dt_from, row_dt_to = self.parse_wialon_report_datetime(
row)
if row_dt_to is None:
row_dt_to = period['dt_to']
if period['dt_from'] < row_dt_from and period[
'dt_to'] > row_dt_to:
delta = (min(row_dt_to, period['dt_to']) -
max(row_dt_from, period['dt_from'])
).total_seconds()
if not delta:
print('empty motohours period')
continue
total_delta = (row_dt_to -
row_dt_from).total_seconds()
period['moto_hours'] += delta
# доля моточасов в периоде и общих моточасов в строке
# данный множитель учтем в расчетах потребления
moto_ratio = 1
if total_delta > 0:
moto_ratio = delta / total_delta
try:
period['fact_dut'] += (float(
parse_float(row[3])) if row[3] else
.0) * moto_ratio
except ValueError:
pass
try:
period['fact_mileage'] += (float(
parse_float(row[4])) if row[4] else
.0) * moto_ratio
except ValueError:
pass
try:
period['idle_hours'] += (parse_timedelta(
row[6]).total_seconds() if row[6] else
.0) * moto_ratio
except ValueError:
pass
if idle_value:
period['fact_motohours'] = max(
period['moto_hours'] - period['move_hours'] -
period['extra_device_hours'],
.0) / 3600.0 * idle_value
if extras_value:
period['fact_extra_device'] = \
period['extra_device_hours'] / 3600.0 * extras_value
total_facts = period['fact_extra_device'] \
+ period['fact_motohours'] \
+ period['fact_mileage']
if total_facts:
ratio = period['fact_dut'] / total_facts
if ratio >= normal_ratio:
overspanding = period['fact_dut'] \
- total_facts
period['overspanding'] = overspanding
self.stats[
'overspanding_total'] += overspanding
period['dt_from'] = utc_to_local_time(
period['dt_from'], self.user.timezone)
period['dt_to'] = utc_to_local_time(
period['dt_to'], self.user.timezone)
if report_data:
for k, v in report_data.items():
v['periods'] = [
p for p in v['periods']
if p['discharge']['volume'] > .0
or p['overspanding'] > 0
]
report_data = OrderedDict(
(k, v) for k, v in report_data.items() if v['periods'])
kwargs.update(enumerate=enumerate,
report_data=report_data,
today=datetime.date.today(),
stats=self.stats)
return kwargs
def get_context_data(self, **kwargs):
kwargs = super(VchmDrivingStyleView, self).get_context_data(**kwargs)
self.is_total = bool(self.request.POST.get('total_report'))
total_report_data = []
form = kwargs['form']
sess_id = self.request.session.get('sid')
if not sess_id:
raise ReportException(WIALON_NOT_LOGINED)
try:
units_list = get_units(sess_id, extra_fields=True)
except WialonException as e:
raise ReportException(str(e))
kwargs['units'] = units_list
if not self.request.POST:
return kwargs
units_dict = {u['name']: u for u in units_list}
if form.is_valid():
if self.is_total:
user = User.objects.filter(
is_active=True,
username=self.request.session.get('user')
).first()
if not user:
raise ReportException(WIALON_USER_NOT_FOUND)
report_users = UserTotalReportUser.objects\
.published()\
.order_by('ordering')\
.filter(executor_user=user)\
.select_related('report_user', 'report_user__ura_user')
users = set(user.report_user for user in report_users)
else:
user = User.objects.filter(
is_active=True,
wialon_username=self.request.session.get('user')
).first()
if not user:
raise ReportException(WIALON_USER_NOT_FOUND)
users = {user}
dt_from = local_to_utc_time(datetime.datetime.combine(
form.cleaned_data['dt_from'],
datetime.time(0, 0, 0)
), user.timezone)
dt_to = local_to_utc_time(datetime.datetime.combine(
form.cleaned_data['dt_to'],
datetime.time(23, 59, 59)
), user.timezone)
for user in users:
report_data = []
print('Evaluating report for user %s' % user)
ura_user = user.ura_user if user.ura_user_id else user
print('URA user is %s' % ura_user)
if self.request.POST.get('total_report'):
sess_id = get_wialon_session_key(user)
if not sess_id:
raise ReportException(WIALON_NOT_LOGINED)
try:
units_list = get_units(sess_id, extra_fields=True)
except WialonException as e:
raise ReportException(str(e))
kwargs['units'] = units_list
units_dict = {u['name']: u for u in units_list}
jobs = Job.objects\
.filter(user=ura_user, date_begin__lt=dt_to, date_end__gt=dt_from)
if form.cleaned_data.get('unit'):
jobs = jobs.filter(unit_id=str(form.cleaned_data['unit']))
self.driver_cache = {
j.driver_id: j.driver_fio
for j in jobs
if j.driver_fio.lower() != 'нет в.а.'
}
self.driver_id_cache = {
int(j.unit_id): j.driver_id
for j in jobs
if j.driver_fio.lower() != 'нет в.а.'
}
template_id = get_wialon_report_template_id('driving_style', user, sess_id)
mobile_vehicle_types = set()
if user.wialon_mobile_vehicle_types:
mobile_vehicle_types = set(
x.strip() for x in user.wialon_mobile_vehicle_types.lower().split(',')
)
cleanup_and_request_report(user, template_id, sess_id)
report_kwargs = {}
if form.cleaned_data.get('unit'):
report_kwargs['object_id'] = form.cleaned_data['unit']
print('Executing report...')
r = exec_report(
user,
template_id,
sess_id,
int(time.mktime(dt_from.timetuple())),
int(time.mktime(dt_to.timetuple())),
**report_kwargs
)
wialon_report_rows = {}
for table_index, table_info in enumerate(r['reportResult']['tables']):
wialon_report_rows[table_info['name']] = get_report_rows(
sess_id,
table_index,
table_info['rows'],
level=2 if table_info['name'] == 'unit_group_ecodriving' else 1
)
self.mileage_cache = {
row['c'][0]: parse_float(row['c'][1], default=.0)
for row in wialon_report_rows.get('unit_group_trips', [])
}
self.duration_cache = {
row['c'][0]: parse_timedelta(row['c'][2]).total_seconds()
for row in wialon_report_rows.get('unit_group_trips', [])
}
i = 0
for row in wialon_report_rows.get('unit_group_ecodriving', []):
i += 1
violations = [
self.parse_report_row(x['c'], user, total=False)
for x in row['r']
]
row = self.parse_report_row(row['c'], user, total=True)
unit = units_dict.get(row.unit_name)
if not unit:
print('%s) Unit not found: %s' % (i, row.unit_name))
continue
vehicle_type = unit['vehicle_type'].lower()
if mobile_vehicle_types and vehicle_type \
and vehicle_type not in mobile_vehicle_types:
print('%s) Skip vehicle type "%s" of item %s' % (
i, vehicle_type, row.unit_name
))
continue
print('%s) Processing %s' % (i, row.unit_name))
ecodriving = get_drive_rank_settings(unit['id'], sess_id)
ecodriving = {k.lower(): v for k, v in ecodriving.items()}
report_row = self.new_grouping(row, unit)
# собственно расчеты метрик
for violation in violations:
verbose = violation.violation_name
violation_name = ''
violation_scope = 'violations_measures'
if 'превышение скорости' in verbose:
if 'cреднее' in verbose or 'среднее' in verbose:
violation_name = 'avg_overspeed'
elif 'опасное' in verbose:
violation_name = 'critical_overspeed'
elif 'ремень' in verbose or 'ремня' in verbose:
violation_name = 'belt'
elif 'фар' in verbose:
violation_name = 'lights'
elif 'кму' in verbose or 'стрел' in verbose:
violation_name = 'jib'
elif 'разгон' in verbose or 'ускорение' in verbose:
violation_scope = 'per_100km_count'
violation_name = 'accelerations'
elif 'торможение' in verbose:
violation_scope = 'per_100km_count'
violation_name = 'brakings'
elif 'поворот' in verbose:
violation_scope = 'per_100km_count'
violation_name = 'turns'
if not violation_name:
print(
'%s) %s: unknown violaton name %s' % (
i, row.unit_name, verbose
)
)
continue
scope = report_row[violation_scope][violation_name]
if violation_scope == 'per_100km_count':
scope['count'] += violation.violation_count / row.mileage * 100
scope['total_count'] += violation.violation_count
else:
scope['count'] += violation.violation_count
scope['total_time_percentage'] += (
violation.duration / row.duration * 100
)
scope['time_sec'] += violation.duration
# суммируем штрафы
rating_violation_name = violation_name
if 'overspeed' in violation_name:
rating_violation_name = 'overspeed'
# извлечем настройки объектов и узнаем, нужно ли рассчитывать
# относительно пробега
settings = ecodriving.get(verbose)
devider = 1
if settings and settings.get('flags', 0) in (2, 3, 7, 10):
devider = max(1.0, row.mileage)
fine = violation.fine / devider
report_row['rating'][rating_violation_name]['fine'] += fine
report_row['rating_total']['avg']['fine'] += fine
if rating_violation_name in ('belt', 'lights', 'jib', 'brakings'):
report_row['rating_total']['critical_avg']['fine'] += fine
# расчет статистики (рейтинга)
for key in report_row['rating']:
scope = report_row['rating'][key]
scope['rating'] = self.calculate_rating(scope['fine'])
report_row['rating_total']['avg']['rating'] = self.calculate_rating(
report_row['rating_total']['avg']['fine']
)
report_row['rating_total']['critical_avg']['rating'] = self.calculate_rating(
report_row['rating_total']['critical_avg']['fine']
)
report_data.append(report_row)
# группируем строки по нарушителям и сортируем, самых нарушающих наверх
groups = defaultdict(lambda: {
'rows': [],
'driver_id': '',
'driver_fio': '',
'company_name': ''
})
# сначала отсортируем без группировки,
# чтобы внутри групп была правильная сортировка
report_data = sorted(
report_data,
key=lambda x: x['rating_total']['critical_avg']['rating']
)
for row in report_data:
group = groups[row['driver_id']]
group['driver_id'] = row['driver_id']
group['driver_fio'] = self.driver_cache.get(row['driver_id'], DRIVER_NO_NAME)
group['company_name'] = user.company_name or user.wialon_resource_name or ''
group['stats'] = self.new_grouping()
group['rows'].append(row)
# собираем суммарную статистику по каждому водителю
report_data = list(groups.values())
for group in report_data:
for row in group['rows']:
group['stats']['total_mileage'] += row['total_mileage']
group['stats']['total_duration'] += row['total_duration']
for field in ('avg_overspeed', 'critical_overspeed', 'belt', 'lights', 'jib'):
for row in group['rows']:
group['stats']['violations_measures'][field]['count'] += \
row['violations_measures'][field]['count']
group['stats']['violations_measures'][field]['time_sec'] += \
row['violations_measures'][field]['time_sec']
group['stats']['violations_measures'][field]['total_time_percentage'] = \
group['stats']['violations_measures'][field]['time_sec'] \
/ group['stats']['total_duration'] * 100.0
for field in ('brakings', 'accelerations', 'turns'):
for row in group['rows']:
group['stats']['per_100km_count'][field]['total_count'] += \
row['per_100km_count'][field]['total_count']
group['stats']['per_100km_count'][field]['count'] = \
group['stats']['per_100km_count'][field]['total_count'] \
/ group['stats']['total_mileage'] * 100
for field in (
'overspeed', 'belt', 'lights', 'brakings', 'accelerations', 'turns', 'jib'
):
for row in group['rows']:
fine = row['rating'][field]['fine']
group['stats']['rating'][field]['fine'] += fine
group['stats']['rating_total']['avg']['fine'] += fine
if field in ('belt', 'lights', 'jib', 'brakings'):
group['stats']['rating_total']['critical_avg']['fine'] += fine
# расчет статистики (рейтинга)
for key in group['stats']['rating']:
scope = group['stats']['rating'][key]
scope['rating'] = self.calculate_rating(scope['fine'])
group['stats']['rating_total']['avg']['rating'] = self.calculate_rating(
group['stats']['rating_total']['avg']['fine']
)
group['stats']['rating_total']['critical_avg']['rating'] = \
self.calculate_rating(
group['stats']['rating_total']['critical_avg']['fine']
)
total_report_data.extend(report_data)
# финально отсортируем всю группу
total_report_data = sorted(
total_report_data,
key=lambda x: x['stats']['rating_total']['critical_avg']['rating']
)
kwargs['report_data'] = total_report_data
return kwargs
def get_context_data(self, **kwargs):
kwargs = super(DrivingStyleView, self).get_context_data(**kwargs)
self.form = kwargs['form']
kwargs['today'] = datetime.date.today()
errors = []
sess_id = self.request.session.get('sid')
if not sess_id:
raise ReportException(WIALON_NOT_LOGINED)
try:
units_list = get_units(sess_id, extra_fields=True)
except WialonException as e:
raise ReportException(str(e))
kwargs['units'] = units_list
if self.request.POST:
report_data = None
if self.form.is_valid():
report_data = OrderedDict()
self.user = User.objects.filter(is_active=True) \
.filter(wialon_username=self.request.session.get('user')).first()
if not self.user:
raise ReportException(WIALON_USER_NOT_FOUND)
units_dict = OrderedDict((u['id'], u) for u in units_list)
selected_unit = self.form.cleaned_data.get('unit')
if selected_unit and selected_unit in units_dict:
units_dict = {selected_unit: units_dict[selected_unit]}
dt_from_utc = local_to_utc_time(
self.form.cleaned_data['dt_from'], self.user.timezone)
dt_to_utc = local_to_utc_time(
self.form.cleaned_data['dt_to'].replace(second=59),
self.user.timezone)
ura_user = self.user.ura_user if self.user.ura_user_id else self.user
jobs = Job.objects.filter(user=ura_user,
date_begin__lt=dt_to_utc,
date_end__gt=dt_from_utc).order_by(
'date_begin', 'date_end')
jobs_cache = defaultdict(list)
for job in jobs:
try:
jobs_cache[int(job.unit_id)].append(job)
except ValueError:
pass
template_id = get_wialon_report_template_id(
'driving_style_individual', self.user, sess_id)
jobs_count = len(units_dict)
print('Всего ТС: %s' % jobs_count)
mobile_vehicle_types = set()
if self.user.wialon_mobile_vehicle_types:
mobile_vehicle_types = set(
x.strip()
for x in self.user.wialon_mobile_vehicle_types.lower(
).split(','))
i = 0
for unit_id, unit in units_dict.items():
i += 1
unit_name = unit['name']
print('%s/%s) %s' % (i, jobs_count, unit_name))
vehicle_type = unit.get('vehicle_type', '').lower().strip()
if not vehicle_type or (mobile_vehicle_types
and vehicle_type
not in mobile_vehicle_types):
print('%s) Skip vehicle type "%s" of item %s' %
(i, vehicle_type, unit_name))
continue
if unit_id not in report_data:
report_data[unit_id] = self.get_new_grouping()
report_row = report_data[unit_id]
report_row['unit_name'] = unit_name
report_row['unit_number'] = unit.get('number', '')
unit_jobs = jobs_cache.get(unit_id)
if not unit_jobs:
report_row['periods'].append(
self.get_new_period(dt_from_utc, dt_to_utc))
else:
if unit_jobs[0].date_begin > dt_from_utc:
# если начало периода не попадает на смену
report_row['periods'].append(
self.get_new_period(dt_from_utc,
unit_jobs[0].date_begin))
previous_job = None
for unit_job in unit_jobs:
# если между сменами есть перерыв, то тоже добавляем период
if previous_job and unit_job.date_begin > previous_job.date_end:
report_row['periods'].append(
self.get_new_period(
previous_job.date_end,
unit_job.date_begin))
report_row['periods'].append(
self.get_new_period(unit_job.date_begin,
unit_job.date_end,
unit_job))
previous_job = unit_job
if unit_jobs[-1].date_end < dt_to_utc:
# если смена закончилась до конца периода
report_row['periods'].append(
self.get_new_period(unit_jobs[-1].date_end,
dt_to_utc))
# получим полный диапазон запроса
dt_from = int(
time.mktime(
report_row['periods'][0]['dt_from'].timetuple()))
dt_to = int(
time.mktime(
report_row['periods'][-1]['dt_to'].timetuple()))
cleanup_and_request_report(self.user, template_id, sess_id)
r = exec_report(self.user,
template_id,
sess_id,
dt_from,
dt_to,
object_id=unit_id)
try:
wialon_report_rows = {}
for table_index, table_info in enumerate(
r['reportResult']['tables']):
wialon_report_rows[
table_info['name']] = get_report_rows(
sess_id,
table_index,
table_info['rows'],
level=1)
except ReportException as e:
print('%s) Skip vehicle %s due to error' %
(i, unit_name))
errors.append(
('%s %s' % (report_row['unit_name'],
report_row['unit_number']), str(e)))
continue
for period in report_row['periods']:
for row in wialon_report_rows.get('unit_trips', []):
row_dt_from, row_dt_to = self.parse_wialon_report_datetime(
row['c'])
if row_dt_to is None:
row_dt_to = period['dt_to']
# дальнейшие строки точно не совпадут (виалон все сортирует по дате):
if row_dt_from > period['dt_to']:
break
# если конец поездки меньше даты начала периода, значит еще не дошли
if row_dt_to < period['dt_from']:
continue
delta = (min(row_dt_to, period['dt_to']) -
max(row_dt_from,
period['dt_from'])).total_seconds()
if delta <= 0:
print('empty trips period')
continue
period['total_time'] += delta
if period['total_time']:
for row in wialon_report_rows.get(
'unit_ecodriving', []):
if period['t_from'] < row['t2'] and period[
't_to'] > row['t1']:
detail_data = {
'speed': {
'count': 0,
'seconds': .0
},
'lights': {
'count': 0,
'seconds': .0
},
'belt': {
'count': 0,
'seconds': .0
},
'devices': {
'count': 0,
'seconds': .0
},
'dt_from': '',
'dt_to': ''
}
violation = row['c'][1].lower(
) if row['c'][1] else ''
if 'свет' in violation or 'фар' in violation:
viol_key = 'lights'
elif 'скорост' in violation or 'превышен' in violation:
viol_key = 'speed'
elif 'ремн' in violation or 'ремен' in violation:
viol_key = 'belt'
elif 'кму' in violation:
viol_key = 'devices'
else:
viol_key = ''
if viol_key:
detail_data[
'dt_from'] = parse_wialon_report_datetime(
row['c'][2]['t'] if isinstance(
row['c'][2], dict
) else row['c'][2])
detail_data[
'dt_to'] = parse_wialon_report_datetime(
row['c'][3]['t'] if isinstance(
row['c'][3], dict
) else row['c'][3])
delta = min(row['t2'], period['t_to']) - \
max(row['t1'], period['t_from'])
detail_data[viol_key][
'seconds'] = delta
if self.form.cleaned_data[
'include_details']:
period['details'].append(
detail_data)
period['facts'][viol_key]['count'] += 1
period['facts'][viol_key][
'seconds'] += delta
for viol_key in ('speed', 'lights', 'belt',
'devices'):
percentage = min(
period['facts'][viol_key]['seconds'] /
period['total_time'], 1.0) * 100
period['percentage'][viol_key] = percentage
period['rating'] -= percentage
period['dt_from'] = utc_to_local_time(
period['dt_from'], self.user.timezone)
period['dt_to'] = utc_to_local_time(
period['dt_to'], self.user.timezone)
period['rating'] = max(period['rating'], .0)
for k, v in report_data.items():
v['periods'] = list(
filter(lambda p: p['total_time'], v.get('periods',
[])))
report_data = OrderedDict(
(k, v) for k, v in report_data.items() if v['periods'])
if errors:
messages.error(self.request,
'<br>'.join(['%s: %s' % x for x in errors]))
kwargs.update(messages=get_messages(self.request) or [])
kwargs.update(report_data=report_data,
render_background=self.render_background,
enumerate=enumerate)
return kwargs