def process_data(self, received_timestamp, data, origin):
type = data.get("type", None)
raw = data.get("raw", False)
if raw:
logger.debug5("Received raw payload: {}", data["payload"])
if type and not raw:
self.__mitm_mapper.run_stats_collector(origin)
logger.debug4("Received payload: {}", data["payload"])
if type == 106:
# process GetMapObject
logger.success(
"Processing GMO received from {}. Received at {}",
str(origin),
str(datetime.fromtimestamp(received_timestamp)))
if self.__application_args.weather:
self.__db_wrapper.submit_weather_map_proto(
origin, data["payload"], received_timestamp)
self.__db_wrapper.submit_pokestops_map_proto(
origin, data["payload"])
self.__db_wrapper.submit_gyms_map_proto(
origin, data["payload"])
self.__db_wrapper.submit_raids_map_proto(
origin, data["payload"], self.__mitm_mapper)
self.__db_wrapper.submit_spawnpoints_map_proto(
origin, data["payload"])
mon_ids_iv = self.__mitm_mapper.get_mon_ids_iv(origin)
self.__db_wrapper.submit_mons_map_proto(
origin, data["payload"], mon_ids_iv, self.__mitm_mapper)
elif type == 102:
playerlevel = self.__mitm_mapper.get_playerlevel(origin)
if playerlevel >= 30:
logger.info("Processing Encounter received from {} at {}",
str(origin), str(received_timestamp))
self.__db_wrapper.submit_mon_iv(origin, received_timestamp,
data["payload"],
self.__mitm_mapper)
else:
logger.debug(
'Playerlevel lower than 30 - not processing encounter Data'
)
elif type == 101:
self.__db_wrapper.submit_quest_proto(origin, data["payload"],
self.__mitm_mapper)
elif type == 104:
self.__db_wrapper.submit_pokestops_details_map_proto(
data["payload"])
elif type == 4:
self.__mitm_mapper.generate_player_stats(
origin, data["payload"])
def get_version(self):
try:
# checking mappings.json
convert_mappings()
with open('version.json') as f:
versio = json.load(f)
self._version = int(versio['version'])
if int(self._version) < int(current_version):
logger.success('Performing update now')
self.start_update()
logger.success('Updates finished')
except FileNotFoundError:
self.set_version(0)
self.start_update()
def process_data(self, received_timestamp, data, origin):
global application_args
if origin not in self.__mitm_mapper.playerstats:
logger.warning("Not processing data of {} since origin is unknown",
str(origin))
return
type = data.get("type", None)
if type:
if type == 106:
# process GetMapObject
logger.success(
"Processing GMO received from {}. Received at {}",
str(origin),
str(datetime.fromtimestamp(received_timestamp)))
if application_args.weather:
self._db_wrapper.submit_weather_map_proto(
origin, data["payload"], received_timestamp)
self._db_wrapper.submit_pokestops_map_proto(
origin, data["payload"])
self._db_wrapper.submit_gyms_map_proto(origin, data["payload"])
self._db_wrapper.submit_raids_map_proto(
origin, data["payload"])
self._db_wrapper.submit_spawnpoints_map_proto(
origin, data["payload"])
mon_ids_iv = self.__mitm_mapper.get_mon_ids_iv(origin)
self._db_wrapper.submit_mons_map_proto(origin, data["payload"],
mon_ids_iv)
elif type == 102:
playerlevel = self.__mitm_mapper.playerstats[origin].get_level(
)
if playerlevel >= 30:
logger.info("Processing Encounter received from {} at {}",
str(origin), str(received_timestamp))
self._db_wrapper.submit_mon_iv(origin, received_timestamp,
data["payload"])
else:
logger.debug(
'Playerlevel lower than 30 - not processing encounter Data'
)
elif type == 101:
self._db_wrapper.submit_quest_proto(data["payload"])
elif type == 104:
self._db_wrapper.submit_pokestops_details_map_proto(
data["payload"])
elif type == 4:
self.__mitm_mapper.playerstats[origin].gen_player_stats(
data["payload"])
t_madmin = Thread(name="madmin",
target=madmin_start,
args=(args, db_wrapper, ws_server, mapping_manager,
device_Updater, jobstatus))
t_madmin.daemon = True
t_madmin.start()
logger.info("Running.....")
try:
while True:
time.sleep(10)
except KeyboardInterrupt or Exception:
logger.info("Shutdown signal received")
finally:
db_wrapper = None
logger.success("Stop called")
terminate_mad.set()
# mitm_mapper.shutdown()
# now cleanup all threads...
# TODO: check against args or init variables to None...
if t_whw is not None:
t_whw.join()
if ws_server is not None:
ws_server.stop_server()
t_ws.join()
if mitm_receiver_process is not None:
# mitm_receiver_thread.kill()
logger.info("Trying to stop receiver")
mitm_receiver_process.shutdown()
mitm_receiver_process.terminate()
mapping_manager_manager = MappingManagerManager()
mapping_manager_manager.start()
mapping_manager_stop_event = mapping_manager_manager.Event()
mapping_manager: MappingManager = mapping_manager_manager.MappingManager(
db_wrapper, args, data_manager, True)
ws_server = WebsocketServer(args,
None,
db_wrapper,
mapping_manager,
None,
data_manager,
configmode=True)
t_ws = Thread(name='scanner', target=ws_server.start_server)
t_ws.daemon = False
t_ws.start()
jobstatus: dict = {}
device_Updater = deviceUpdater(ws_server, args, jobstatus)
logger.success(
'Starting MADmin on port {} - Open a browser, visit MADmin and go to "Settings"',
int(args.madmin_port))
t_flask = Thread(name='madmin',
target=start_madmin,
args=(args, db_wrapper, ws_server, mapping_manager,
data_manager, device_Updater, jobstatus))
t_flask.daemon = False
t_flask.start()
def process_data(self, received_timestamp, data, origin):
data_type = data.get("type", None)
raw = data.get("raw", False)
logger.debug2("Processing data of {}".format(origin))
if raw:
logger.debug5("Received raw payload: {}", data["payload"])
if data_type and not raw:
logger.debug2("Running stats collector of {}".format(origin))
if self.__application_args.game_stats:
self.__mitm_mapper.run_stats_collector(origin)
logger.debug4("Received payload: {}", data["payload"])
if data_type == 106:
# process GetMapObject
logger.success(
"Processing GMO received from {}. Received at {}",
str(origin),
str(datetime.fromtimestamp(received_timestamp)))
if self.__application_args.weather:
self.__db_submit.weather(origin, data["payload"],
received_timestamp)
self.__db_submit.stops(origin, data["payload"])
self.__db_submit.gyms(origin, data["payload"])
self.__db_submit.raids(origin, data["payload"],
self.__mitm_mapper)
self.__db_submit.spawnpoints(origin, data["payload"])
mon_ids_iv = self.__mitm_mapper.get_mon_ids_iv(origin)
self.__db_submit.mons(origin, data["payload"], mon_ids_iv,
self.__mitm_mapper)
self.__db_submit.cells(origin, data["payload"])
self.__mitm_mapper.submit_gmo_for_location(
origin, data["payload"])
logger.debug2("Done processing GMO of {}".format(origin))
elif data_type == 102:
playerlevel = self.__mitm_mapper.get_playerlevel(origin)
if playerlevel >= 30:
logger.info("Processing Encounter received from {} at {}",
str(origin), str(received_timestamp))
self.__db_submit.mon_iv(origin, received_timestamp,
data["payload"],
self.__mitm_mapper)
logger.debug2(
"Done processing encounter of {}".format(origin))
else:
logger.debug(
'Playerlevel lower than 30 - not processing encounter Data'
)
elif data_type == 101:
logger.debug2("Processing proto 101 of {}".format(origin))
self.__db_submit.quest(origin, data["payload"],
self.__mitm_mapper)
logger.debug2("Done processing proto 101 of {}".format(origin))
elif data_type == 104:
logger.debug2("Processing proto 104 of {}".format(origin))
self.__db_submit.stop_details(data["payload"])
logger.debug2("Done processing proto 104 of {}".format(origin))
elif data_type == 4:
logger.debug2("Processing proto 4 of {}".format(origin))
self.__mitm_mapper.generate_player_stats(
origin, data["payload"])
logger.debug2("Done processing proto 4 of {}".format(origin))
elif data_type == 156:
logger.debug2("Processing proto 156 of {}".format(origin))
self.__db_submit.gym(origin, data["payload"])
logger.debug2("Done processing proto 156 of {}".format(origin))
def main():
args = Args()
initLogging(args)
if len(sys.argv) != 2:
logger.error("usage: remove_all_spawns_within_geofence.py GEOFENCE_FILENAME")
sys.exit(1)
LocationWithID = collections.namedtuple('Location', ['lat', 'lng', 'spawnpoint'])
geofence_filename = sys.argv[1]
#print("Argument: '%s'" % (geofence_filename))
# no .txt, add it
if ".txt" not in geofence_filename:
geofence_filename = geofence_filename+".txt"
# no / in filename, probably not an absolute path, append standard MAD path
if "/" not in geofence_filename:
geofence_filename = "../configs/geofences/" + geofence_filename
logger.info("Trying to use file: {}", geofence_filename)
if not os.path.isfile(geofence_filename):
logger.error("Geofence file {} not found, exit", geofence_filename)
sys.exit(1)
geofence_helper = GeofenceHelper(geofence_filename, None)
minLat, minLon, maxLat, maxLon = geofence_helper.get_polygon_from_fence()
query = (
"SELECT latitude, longitude, spawnpoint "
"FROM trs_spawn "
"WHERE (latitude >= {} AND longitude >= {} "
"AND latitude <= {} AND longitude <= {}) "
).format(minLat, minLon, maxLat, maxLon)
delete_query = (
"DELETE FROM trs_spawn "
"WHERE spawnpoint = {} "
)
list_of_coords: List[LocationWithID] = []
dbip = get_value_for(r'\s+dbip:\s+([^\s]+)')
dbport = get_value_for(r'\s+dbport:\s+([^.\s]*)', False)
if dbport is None: # if dbport is not set, use default
dbport = '3306'
dbusername = get_value_for(r'\s+dbusername:\s+([^.\s]*)')
dbpassword = get_value_for(r'\s+dbpassword:\s+([^.\s]*)')
dbname = get_value_for(r'\s+dbname:\s+([^.\s]*)')
#print("Successfully parsed config.ini, using values:")
#print("dbport: %s" % dbport)
#print("dbusername: %s" % dbusername)
#print("dbname: %s" % dbname)
#print("dbip: %s" % dbip)
connection = mysql.connector.connect(
host = dbip,
port = dbport,
user = dbusername,
passwd = dbpassword,
database = dbname)
cursor = connection.cursor()
cursor.execute(query)
res = cursor.fetchall()
for (latitude, longitude, spawnpoint) in res:
list_of_coords.append(LocationWithID(latitude, longitude, spawnpoint))
geofenced_coords = geofence_helper.get_geofenced_coordinates(list_of_coords)
spawnpointcount = len(geofenced_coords)
for coords in geofenced_coords:
sql = delete_query.format(coords.spawnpoint)
cursor.execute(sql)
#print(sql)
connection.commit()
cursor.close()
connection.close()
logger.success("Done, deleted {} spawnpoints", spawnpointcount)
def __send_webhook(self, payload):
if len(payload) == 0:
logger.debug("Payload empty. Skip sending to webhook.")
return
# get list of urls
webhooks = self.__args.webhook_url.replace(" ", "").split(",")
webhook_count = len(webhooks)
current_wh_num = 1
for webhook in webhooks:
payloadToSend = []
subTypes = "all"
url = webhook.strip()
if url.startswith("["):
endIndex = webhook.rindex("]")
endIndex += 1
subTypes = webhook[:endIndex]
url = url[endIndex:]
for payloadData in payload:
if payloadData["type"] in subTypes:
payloadToSend.append(payloadData)
else:
payloadToSend = payload
if len(payloadToSend) == 0:
logger.debug("Payload empty. Skip sending to: {} (Filter: {})",
url, subTypes)
continue
else:
logger.debug("Sending to webhook url: {} (Filter: {})", url,
subTypes)
payload_list = self.__payload_chunk(
payloadToSend, self.__args.webhook_max_payload_size)
current_pl_num = 1
for payload_chunk in payload_list:
logger.debug("Payload: {}", str(json.dumps(payload_chunk)))
try:
response = requests.post(
url,
data=json.dumps(payload_chunk),
headers={"Content-Type": "application/json"},
timeout=5,
)
if response.status_code != 200:
logger.warning(
"Got status code other than 200 OK from webhook destination: {}",
str(response.status_code))
else:
if webhook_count > 1:
whcount_text = " [wh {}/{}]".format(
current_wh_num, webhook_count)
else:
whcount_text = ""
if len(payload_list) > 1:
whchunk_text = " [pl {}/{}]".format(
current_pl_num, len(payload_list))
else:
whchunk_text = ""
logger.success(
"Successfully sent payload to webhook{}{}. Stats: {}",
whchunk_text, whcount_text,
json.dumps(
self.__payload_type_count(payload_chunk)))
except Exception as e:
logger.warning(
"Exception occured while sending webhook: {}", str(e))
current_pl_num += 1
current_wh_num += 1
db_wrapper.create_status_database_if_not_exists()
db_wrapper.create_usage_database_if_not_exists()
version = MADVersion(args, db_wrapper)
version.get_version()
try:
(device_mappings, routemanagers, auths) = load_mappings(db_wrapper)
except KeyError as e:
logger.error(
"Could not parse mappings. Please check those. Reason: {}", str(e))
sys.exit(1)
except RuntimeError as e:
logger.error("There is something wrong with your mappings. Reason: {}",
str(e))
sys.exit(1)
ws_server = WebsocketServer(args, None, db_wrapper, routemanagers,
device_mappings, auths, None, True)
t_ws = Thread(name='scanner', target=ws_server.start_server)
t_ws.daemon = False
t_ws.start()
logger.success(
'Starting MADmin on port {} - open browser and click "Mapping Editor"',
int(args.madmin_port))
t_flask = Thread(name='madmin',
target=start_madmin,
args=(args, db_wrapper, ws_server))
t_flask.daemon = False
t_flask.start()
