def imei_batch_api(**kwargs):
"""
IMEI API POST method handler for IMEI-Batch request.
:param kwargs: input imei list
:return: json
"""
if bool(kwargs):
imeis = kwargs.get('imeis')
data = []
with get_db_connection() as db_conn, db_conn.cursor() as cursor:
for imei in imeis:
imei_norm = validate_imei(imei)
condition_results = get_conditions(cursor, imei_norm)
response = {
'imei_norm':
imei_norm,
'block_date':
block_date(cursor, imei_norm),
'classification_state': {
'blocking_conditions': [
dict({
'condition_name': key,
'condition_met': value['result']
}) for key, value in condition_results.items()
if value['blocking']
],
'informative_conditions': [
dict({
'condition_name': key,
'condition_met': value['result']
}) for key, value in condition_results.items()
if not value['blocking']
]
},
'realtime_checks': {
'ever_observed_on_network':
ever_observed_on_network(cursor, imei_norm),
'invalid_imei':
False if re.match(r'^\d{14}$', imei_norm) else True,
'is_paired':
is_paired(cursor, imei_norm),
'is_exempted_device':
is_exempted_device(cursor, imei_norm)
},
'registration_status':
registration_list_status(cursor, imei_norm),
'stolen_status':
stolen_list_status(cursor, imei_norm)
}
data.append(IMEI().dump(response).data)
return jsonify({'results': data})
abort(400, 'Bad Input format (args cannot be empty)')
def imei_subscribers_api(imei: str, **kwargs: dict) -> jsonify:
"""
IMEI-Subscribers API handler.
Arguments:
imei: IMEI value
kwargs: required arguments dictionary
Returns:
JSON response
"""
imei_norm = validate_imei(imei)
offset = kwargs.get('offset')
limit = kwargs.get('limit')
order = kwargs.get('order')
with get_db_connection() as db_conn, db_conn.cursor() as cursor:
query = """SELECT DISTINCT imsi, msisdn, last_seen, COUNT(*) OVER() AS total_count
FROM monthly_network_triplets_country_no_null_imeis
WHERE imei_norm = %(imei_norm)s
AND virt_imei_shard = calc_virt_imei_shard(%(imei_norm)s)
ORDER BY last_seen {order_type}
OFFSET {data_offset}
LIMIT {data_limit}""".format(order_type=order,
data_offset=offset,
data_limit=limit) # noqa Q447
cursor.execute(query, {'imei_norm': imei_norm})
if cursor is not None:
subscribers = [{
'imsi': x.imsi,
'msisdn': x.msisdn,
'last_seen': x.last_seen,
'total_count': x.total_count
} for x in cursor]
keys = {
'current_key':
offset,
'next_key':
offset + limit if subscribers else '',
'result_size':
subscribers[0].get('total_count') if subscribers else 0
}
return jsonify(IMEISubscribers().dump(
dict(imei_norm=imei_norm, subscribers=subscribers,
_keys=keys)).data)
keys = {'current_key': offset, 'next_key': '', 'result_size': 0}
return jsonify(IMEISubscribers().dump(
dict(imei_norm=imei_norm, subscribers=None, _keys=keys)))
def imei_api(imei: str, include_seen_with: bool = False, include_paired_with: bool = False) -> jsonify:
"""
IMEI API handler.
Arguments:
imei: IMEI number in format [15, 16] digits
include_seen_with: bool to include seen with information in response (default False)
include_paired_with: bool to include paired with information in response (default False)
Returns:
JSON response
"""
imei_norm = validate_imei(imei)
tac = imei_norm[:8]
with get_db_connection() as db_conn, db_conn.cursor() as cursor:
cursor.execute('SELECT NOT EXISTS (SELECT * FROM gsma_data WHERE tac = %s) AS not_in_gsma', [tac])
rt_gsma_not_found = cursor.fetchone()[0]
condition_results = get_conditions(cursor, imei_norm)
resp = {
'imei_norm': imei_norm,
'classification_state': {
'blocking_conditions': {k: v['result'] for k, v in condition_results.items() if v['blocking']},
'informative_conditions': {k: v['result'] for k, v in condition_results.items() if not v['blocking']}
},
'realtime_checks': {
'invalid_imei': False if re.match(r'^\d{14}$', imei_norm) else True,
'gsma_not_found': rt_gsma_not_found
}
}
# add a real-time check for the registration list
resp['realtime_checks']['in_registration_list'] = is_in_registration_list(db_conn, cursor, imei_norm)
# add a real-time check for if IMEI was ever observed on the network
resp['realtime_checks']['ever_observed_on_network'] = ever_observed_on_network(cursor, imei_norm)
resp['is_paired'] = is_paired(cursor, imei_norm)
if include_seen_with:
resp['seen_with'] = get_subscribers(cursor, imei_norm)
if include_paired_with:
cursor.execute("""SELECT imsi
FROM pairing_list
WHERE imei_norm = %(imei_norm)s
AND virt_imei_shard = calc_virt_imei_shard(%(imei_norm)s)""",
{'imei_norm': imei_norm})
resp['paired_with'] = [x.imsi for x in cursor]
return jsonify(IMEI().dump(resp).data)
def imei_api(imei):
"""
IMEI API handler.
:param imei: IMEI
:return: json
"""
imei_norm = validate_imei(imei)
with get_db_connection() as db_conn, db_conn.cursor() as cursor:
condition_results = get_conditions(cursor, imei_norm)
response = {
'imei_norm': imei_norm,
'block_date': block_date(cursor, imei_norm),
'classification_state': {
'blocking_conditions': [
dict({
'condition_name': key,
'condition_met': value['result']
}) for key, value in condition_results.items()
if value['blocking']
],
'informative_conditions': [
dict({
'condition_name': key,
'condition_met': value['result']
}) for key, value in condition_results.items()
if not value['blocking']
]
},
'realtime_checks': {
'ever_observed_on_network':
ever_observed_on_network(cursor, imei_norm),
'invalid_imei':
False if re.match(r'^\d{14}$', imei_norm) else True,
'is_paired':
is_paired(cursor, imei_norm),
'is_exempted_device':
is_exempted_device(cursor, imei_norm)
},
'registration_status': registration_list_status(cursor, imei_norm),
'stolen_status': stolen_list_status(cursor, imei_norm)
}
return jsonify(IMEI().dump(response).data)
def imei_info_api(imei):
"""
IMEI-Info API method handler.
:param imei: IMEI
:return: json
"""
imei_norm = validate_imei(imei)
with get_db_connection() as db_conn, db_conn.cursor() as cursor:
cursor.execute(
"""SELECT imei_norm, make, model, status, model_number, brand_name, device_type,
radio_interface
FROM registration_list
WHERE imei_norm = %(imei_norm)s
AND virt_imei_shard = calc_virt_imei_shard(%(imei_norm)s)""",
{'imei_norm': imei_norm})
rec = cursor.fetchone()
if rec is not None:
return jsonify(IMEIInfo().dump(rec._asdict()).data)
return {}
def imei_info_api(imei: str) -> jsonify:
"""
IMEI-Info API method handler.
Arguments:
imei: IMEI value to extract information
Returns:
JSON response if exists otherwise
"""
imei_norm = validate_imei(imei)
with get_db_connection() as db_conn, db_conn.cursor() as cursor:
cursor.execute(
"""SELECT imei_norm, make, model, status, model_number, brand_name, device_type,
radio_interface
FROM registration_list
WHERE imei_norm = %(imei_norm)s
AND virt_imei_shard = calc_virt_imei_shard(%(imei_norm)s)""",
{'imei_norm': imei_norm})
info_rec = cursor.fetchone()
cursor.execute(
"""SELECT imei_norm
FROM registration_list
WHERE device_id = (SELECT device_id
FROM registration_list
WHERE imei_norm = %(imei_norm)s
AND virt_imei_shard = calc_virt_imei_shard(%(imei_norm)s))
AND imei_norm NOT IN (%(imei_norm)s)""",
{'imei_norm': imei_norm})
if info_rec is not None:
response = info_rec._asdict()
response['associated_imeis'] = [rec.imei_norm for rec in cursor] \
if cursor is not None else []
return jsonify(IMEIInfo().dump(response).data)
return {}
def imei_pairings_api(imei, **kwargs):
"""
IMEI-Pairings API handler.
:param imei: IMEI
:param kwargs: extra input args
:return: json
"""
imei_norm = validate_imei(imei)
offset = kwargs.get('offset')
limit = kwargs.get('limit')
order = kwargs.get('order')
if offset is None:
offset = 1
if limit is None:
limit = 10
with get_db_connection() as db_conn, db_conn.cursor() as cursor:
cursor.execute("""SELECT pairing_list.imsi, network_triplets.last_seen
FROM pairing_list
LEFT JOIN monthly_network_triplets_country_no_null_imeis AS network_triplets
ON network_triplets.imsi = pairing_list.imsi
AND network_triplets.imei_norm = pairing_list.imei_norm
WHERE pairing_list.imei_norm = '{imei_norm}'""".
format(imei_norm=imei_norm))
if cursor is not None:
pairings = [{
'imsi': x.imsi,
'last_seen': x.last_seen
} for x in cursor]
paginated_data = Pagination.paginate(pairings, offset, limit)
if order == 'Ascending':
paginated_data.get('data').sort(
key=operator.itemgetter('last_seen'))
return jsonify(IMEIPairings().dump(
dict(imei_norm=imei_norm,
pairs=paginated_data.get('data'),
_keys=paginated_data.get('keys'))).data)
elif order == 'Descending':
paginated_data.get('data').sort(
key=operator.itemgetter('last_seen'), reverse=True)
return jsonify(IMEIPairings().dump(
dict(imei_norm=imei_norm,
pairs=paginated_data.get('data'),
_keys=paginated_data.get('keys'))).data)
return jsonify(IMEIPairings().dump(
dict(imei_norm=imei_norm,
pairs=paginated_data.get('data'),
_keys=paginated_data.get('keys'))).data)
keys = {
'offset': offset,
'limit': limit,
'current_key': offset,
'next_key': '',
'result_size': 0
}
return jsonify(IMEIPairings().dump(
dict(imei_norm=imei_norm, pairs=None, _keys=keys)))
def imei_subscribers_api(imei, **kwargs):
"""
IMEI-Subscribers API handler.
:param imei: IMEI
:param kwargs: extra input args
:return: json
"""
imei_norm = validate_imei(imei)
offset = kwargs.get('offset')
limit = kwargs.get('limit')
order = kwargs.get('order')
if offset is None:
offset = 1
if limit is None:
limit = 10
with get_db_connection() as db_conn, db_conn.cursor() as cursor:
cursor.execute(
"""SELECT DISTINCT imsi, msisdn, last_seen
FROM monthly_network_triplets_country_no_null_imeis
WHERE imei_norm = %(imei_norm)s
AND virt_imei_shard = calc_virt_imei_shard(%(imei_norm)s)""",
{'imei_norm': imei_norm})
if cursor is not None:
subscribers = [{
'imsi': x.imsi,
'msisdn': x.msisdn,
'last_seen': x.last_seen
} for x in cursor]
paginated_data = Pagination.paginate(subscribers, offset, limit)
if order == 'Ascending':
paginated_data.get('data').sort(
key=operator.itemgetter('last_seen'))
return jsonify(IMEISubscribers().dump(
dict(imei_norm=imei_norm,
subscribers=paginated_data.get('data'),
_keys=paginated_data.get('keys'))).data)
elif order == 'Descending':
paginated_data.get('data').sort(
key=operator.itemgetter('last_seen'), reverse=True)
return jsonify(IMEISubscribers().dump(
dict(imei_norm=imei_norm,
subscribers=paginated_data.get('data'),
_keys=paginated_data.get('keys'))).data)
return jsonify(IMEISubscribers().dump(
dict(imei_norm=imei_norm,
subscribers=paginated_data.get('data'),
_keys=paginated_data.get('keys'))).data)
keys = {
'offset': offset,
'limit': limit,
'current_key': offset,
'next_key': '',
'result_size': 0
}
return jsonify(IMEISubscribers().dump(
dict(imei_norm=imei_norm, subscribers=None, _keys=keys)))
def imei_batch_api(**kwargs: dict) -> jsonify:
"""
IMEI API POST method handler for IMEI-Batch request.
Arguments:
kwargs: required arguments (list of IMEIs)
Returns:
JSON response
"""
imeis = kwargs.get('imeis')
include_registration_status = kwargs.get('include_registration_status')
include_stolen_status = kwargs.get('include_stolen_status')
data = []
with get_db_connection() as db_conn, db_conn.cursor() as cursor:
for imei in imeis:
imei_norm = validate_imei(imei)
tac = imei_norm[:8]
condition_results = get_conditions(cursor, imei_norm)
first_seen_date = first_seen(cursor, imei_norm)
cursor.execute(
'SELECT NOT EXISTS (SELECT * FROM gsma_data WHERE tac = %s) AS not_in_gsma',
[tac])
rt_gsma_not_found = cursor.fetchone()[0]
response = {
'imei_norm': imei_norm,
'block_date': block_date(cursor, imei_norm),
'first_seen': first_seen_date,
'classification_state': {
'blocking_conditions': [
dict({
'condition_name': key,
'condition_met': value['result']
}) for key, value in condition_results.items()
if value['blocking']
],
'informative_conditions': [
dict({
'condition_name': key,
'condition_met': value['result']
}) for key, value in condition_results.items()
if not value['blocking']
]
},
'realtime_checks': {
'ever_observed_on_network':
True if first_seen_date else False,
'invalid_imei':
False if re.match(r'^\d{14}$', imei_norm) else True,
'is_paired':
is_paired(cursor, imei_norm),
'is_exempted_device':
is_exempted_device(cursor, imei_norm),
'gsma_not_found':
rt_gsma_not_found,
'in_registration_list':
is_in_registration_list(db_conn, cursor, imei_norm)
}
}
if include_registration_status:
response['registration_status'] = registration_list_status(
cursor, imei_norm)
if include_stolen_status:
response['stolen_status'] = stolen_list_status(
cursor, imei_norm)
data.append(IMEI().dump(response).data)
return jsonify({'results': data})
def imei_api(imei: str,
include_registration_status: bool = False,
include_stolen_status: bool = False) -> jsonify:
"""
IMEI API handler.
Arguments:
imei: value of the IMEI
include_registration_status: boolean weather to include reg status or not (default False)
include_stolen_status: boolean weather to include stolen status or not (default False)
Returns:
JSON response
"""
imei_norm = validate_imei(imei)
tac = imei_norm[:8]
tac = imei_norm[:8]
with get_db_connection() as db_conn, db_conn.cursor() as cursor:
cursor.execute(
'SELECT NOT EXISTS (SELECT * FROM gsma_data WHERE tac = %s) AS not_in_gsma',
[tac])
rt_gsma_not_found = cursor.fetchone()[0]
first_seen_date = first_seen(cursor, imei_norm)
condition_results = get_conditions(cursor, imei_norm)
response = {
'imei_norm': imei_norm,
'block_date': block_date(cursor, imei_norm),
'first_seen': first_seen_date,
'classification_state': {
'blocking_conditions': [
dict({
'condition_name': key,
'condition_met': value['result']
}) for key, value in condition_results.items()
if value['blocking']
],
'informative_conditions': [
dict({
'condition_name': key,
'condition_met': value['result']
}) for key, value in condition_results.items()
if not value['blocking']
]
},
'realtime_checks': {
'ever_observed_on_network':
True if first_seen_date else False,
'invalid_imei':
False if re.match(r'^\d{14}$', imei_norm) else True,
'is_paired':
is_paired(cursor, imei_norm),
'is_exempted_device':
is_exempted_device(cursor, imei_norm),
'in_registration_list':
is_in_registration_list(db_conn, cursor, imei_norm),
'gsma_not_found':
rt_gsma_not_found
}
}
if include_registration_status:
response['registration_status'] = registration_list_status(
cursor, imei_norm)
if include_stolen_status:
response['stolen_status'] = stolen_list_status(cursor, imei_norm)
return jsonify(IMEI().dump(response).data)
