def get_spawn_details_helper(self,
areaid,
eventid,
todayonly=False,
olderthanxdays=None,
sumonly=False,
index=0):
active_spawns: list = []
possible_fences = get_geofences(self._mapping_manager,
self._data_manager,
area_id_req=areaid)
fence = generate_coords_from_geofence(
self._mapping_manager, self._data_manager,
str(
list(possible_fences[int(areaid)]['include'].keys())[int(
index)]))
data = json.loads(
self._db.download_spawns(fence=str(fence),
eventid=int(eventid),
todayonly=bool(todayonly),
olderthanxdays=olderthanxdays))
if sumonly:
return len(data)
for spawn in data:
sp = data[spawn]
active_spawns.append({
'id': sp['id'],
'lat': sp['lat'],
'lon': sp['lon'],
'lastscan': sp['lastscan'],
'lastnonscan': sp['lastnonscan']
})
return active_spawns
def get_spawnpoints_from_id(self,
spawn_id,
eventid,
todayonly=False,
olderthanxdays=None,
index=0):
spawns = []
possible_fences = get_geofences(self._mapping_manager,
self._data_manager,
area_id_req=spawn_id)
fence = generate_coords_from_geofence(
self._mapping_manager, self._data_manager,
str(
list(possible_fences[int(spawn_id)]['include'].keys())[int(
index)]))
data = json.loads(
self._db.download_spawns(fence=str(fence),
eventid=int(eventid),
todayonly=bool(todayonly),
olderthanxdays=olderthanxdays))
for spawnid in data:
spawns.append(spawnid)
return spawns
def get_spawnpoints_stats_summary(self):
possible_fences = get_geofences(self._mapping_manager,
self._data_manager)
events = self._db.get_events()
spawnpoints_total = self._db_stats_reader.get_all_spawnpoints_count()
stats = {
'fences': possible_fences,
'events': events,
'spawnpoints_count': spawnpoints_total
}
return jsonify(stats)
def get_stop_quest_stats(self):
stats = []
stats_process = []
processed_fences = []
possible_fences = get_geofences(self._mapping_manager, self._data_manager, fence_type="pokestops")
wanted_fences = []
if self._args.quest_stats_fences != "":
wanted_fences = [item.lower().replace(" ", "") for item in self._args.quest_stats_fences.split(",")]
for possible_fence in possible_fences:
subfenceindex: int = 0
for subfence in possible_fences[possible_fence]['include']:
if subfence in processed_fences:
continue
if len(wanted_fences) > 0:
if str(subfence).lower() not in wanted_fences:
continue
processed_fences.append(subfence)
fence = generate_coords_from_geofence(self._mapping_manager, self._data_manager, subfence)
stops = len(self._db.stops_from_db(fence=fence))
quests = len(self._db.quests_from_db(fence=fence))
processed: int = 0
if int(stops) > 0:
processed: int = int(quests) * 100 / int(stops)
info = {
"fence": str(subfence),
'stops': int(stops),
'quests': int(quests),
'processed': str(int(processed)) + " %"
}
stats_process.append(info)
subfenceindex += 1
# Quest
quest: list = []
quest_db = self._db_stats_reader.get_quests_count(1)
for ts, count in quest_db:
quest_raw = (int(ts * 1000), count)
quest.append(quest_raw)
# Stop
stop = []
data = self._db_stats_reader.get_stop_quest()
for dat in data:
stop.append({'label': dat[0], 'data': dat[1]})
stats = {'stop_quest_stats': stats_process, 'quest': quest, 'stop': stop}
return jsonify(stats)
def get_geofence(self):
areas = self._mapping_manager.get_areas()
areas_sorted = sorted(areas, key=lambda x: areas[x]['name'])
geofences = get_geofences(self._mapping_manager, self._data_manager)
geofencexport = []
for area_id in areas_sorted:
fences = geofences[area_id]
coordinates = []
for fname, coords in fences.get('include').items():
coordinates.append(
[coords, fences.get('exclude').get(fname, [])])
geofencexport.append({
'name': areas[area_id]['name'],
'coordinates': coordinates
})
return jsonify(geofencexport)
def delete_unfenced_spawns(self):
processed_fences = []
spawns = []
possible_fences = get_geofences(self._mapping_manager,
self._data_manager)
for possible_fence in possible_fences:
for subfence in possible_fences[possible_fence]['include']:
if subfence in processed_fences:
continue
processed_fences.append(subfence)
fence = generate_coords_from_geofence(self._mapping_manager,
self._data_manager,
subfence)
data = json.loads(self._db.download_spawns(fence=fence))
for spawnid in data:
spawns.append(spawnid)
self._db.delete_spawnpoints(
[x for x in self._db.get_all_spawnpoints() if x not in spawns])
return jsonify({'status': 'success'})
def get_spawnpoints_stats(self):
coords = []
known = []
unknown = []
processed_fences = []
possible_fences = get_geofences(self._mapping_manager,
self._data_manager,
fence_type='mon_mitm')
for possible_fence in possible_fences:
for subfence in possible_fences[possible_fence]['include']:
if subfence in processed_fences:
continue
processed_fences.append(subfence)
fence = generate_coords_from_geofence(self._mapping_manager,
self._data_manager,
subfence)
known.clear()
unknown.clear()
data = json.loads(self._db.download_spawns(fence=fence))
for spawnid in data:
if data[str(spawnid)]["endtime"] is None:
unknown.append(spawnid)
else:
known.append(spawnid)
coords.append({
'fence': subfence,
'known': len(known),
'unknown': len(unknown),
'sum': len(known) + len(unknown)
})
stats = {'spawnpoints': coords}
return jsonify(stats)
def get_spawnpoints_stats(self):
geofence_type = request.args.get('type', 'mon_mitm')
geofence_id = int(request.args.get('fence', -1))
if geofence_type not in [
'idle', 'iv_mitm', 'mon_mitm', 'pokestops', 'raids_mitm'
]:
stats = {'spawnpoints': []}
return jsonify(stats)
coords = []
known = {}
unknown = {}
processed_fences = []
events = []
eventidhelper = {}
if geofence_id != -1:
possible_fences = get_geofences(self._mapping_manager,
self._data_manager,
area_id_req=geofence_id)
else:
possible_fences = get_geofences(self._mapping_manager,
self._data_manager,
fence_type=geofence_type)
for possible_fence in possible_fences:
mode = possible_fences[possible_fence]['mode']
area_id = possible_fences[possible_fence]['area_id']
subfenceindex: int = 0
for subfence in possible_fences[possible_fence]['include']:
if subfence in processed_fences:
continue
processed_fences.append(subfence)
fence = generate_coords_from_geofence(self._mapping_manager,
self._data_manager,
subfence)
known.clear()
unknown.clear()
events.clear()
data = json.loads(self._db.download_spawns(fence=fence))
for spawnid in data:
eventname: str = data[str(spawnid)]["event"]
eventid: str = data[str(spawnid)]["eventid"]
if eventname not in known:
known[eventname] = []
if eventname not in unknown:
unknown[eventname] = []
if eventname not in events:
events.append(eventname)
eventidhelper[eventname] = eventid
if data[str(spawnid)]["endtime"] is None:
unknown[eventname].append(spawnid)
else:
known[eventname].append(spawnid)
for event in events:
today: int = 0
outdate: int = 0
if event == "DEFAULT":
outdate = self.get_spawn_details_helper(
areaid=area_id,
eventid=eventidhelper[event],
olderthanxdays=self.outdatedays,
sumonly=True,
index=subfenceindex)
else:
today = self.get_spawn_details_helper(
areaid=area_id,
eventid=eventidhelper[event],
todayonly=True,
sumonly=True,
index=subfenceindex)
coords.append({
'fence':
subfence,
'known':
len(known[event]),
'unknown':
len(unknown[event]),
'sum':
len(known[event]) + len(unknown[event]),
'event':
event,
'mode':
mode,
'area_id':
area_id,
'eventid':
eventidhelper[event],
'todayspawns':
today,
'outdatedspawns':
outdate,
'index':
subfenceindex
})
subfenceindex += 1
stats = {'spawnpoints': coords}
return jsonify(stats)
