def process_file(filename):
with open(filename) as f:
init_db_pool(settings.DATABASE)
line = f.readline()
while line:
data = {}
advdm_msgs = []
while True:
_, extra_msg, advdm_msg = line.split('\\')
info = extract_extra_info(extra_msg)
data.update(info)
advdm_msgs.append(advdm_msg)
if 'total' in info and info['index'] < info['total']:
line = f.readline()
else:
break
data['ais_pos'] = extract_advdm_info(advdm_msgs, 1)
if len(advdm_msgs) > 1:
data['ais_ship'] = extract_advdm_info(advdm_msgs, 5)
with get_conn() as conn:
try:
save_vessel_data(conn, data)
except Exception, e:
conn.rollback()
raise
# next
line = f.readline()
def setUp(self):
super(TestCoupon, self).setUp()
self.id_brand = 1000001
self.bo_user = 1000002
self.id_coupon = None
with db_utils.get_conn() as conn:
db_utils.update(conn, "coupons", values={'valid': False})
def get_telephone_id(self, users_id):
sql = """SELECT id
FROM users_phone_num
WHERE users_id = %s
"""
with db_utils.get_conn() as conn:
phone_id = db_utils.query(conn, sql, (users_id, ))
return phone_id
def get_addr_id(self, users_id):
sql = """SELECT id, addr_type
FROM users_address
WHERE users_id = %s
"""
with db_utils.get_conn() as conn:
addrs = db_utils.query(conn, sql, (users_id, ))
return addrs
def _shipping_list_item(self, id_shipment):
sql = """SELECT id
FROM shipping_list
WHERE id_shipment=%s
"""
with db_utils.get_conn() as conn:
results = db_utils.query(conn, sql, (id_shipment, ))
return [item[0] for item in results]
def _order_item(self, id_order):
sql = """SELECT id_item
FROM order_details
WHERE id_order=%s
"""
with db_utils.get_conn() as conn:
results = db_utils.query(conn, sql, (id_order, ))
return [item[0] for item in results]
def update_account_address(self, id_user, country, province, city):
with db_utils.get_conn() as conn:
db_utils.update(conn,
"users_address",
values={
"country_code": country,
"province_code": province,
"city": city
},
where={'users_id': id_user})
def test_expired_session(self):
auth_cookie = self.login()
data = _parse_auth_cookie(auth_cookie.value.strip('"'))
with db_utils.get_conn() as conn:
db_utils.update(conn,
"users_logins",
{"cookie_expiry": datetime.datetime.utcnow()},
where={"users_id": data["users_id"]})
self.fail_auth_verification("LOGIN_REQUIRED_ERR_INVALID_USER")
def gen_bought_history(users_id, id_sales):
try:
with db_utils.get_conn() as conn:
for id_sale in id_sales:
insert(conn,
'bought_history',
values={'id_sale': id_sale,
'users_id': users_id})
conn.commit()
except Exception, e:
logging.error('gen_bought_history_err: %s', e)
def _shipmentsCountCheck(self, id_order, expected_count):
sql = """SELECT id
FROM shipments
WHERE id_order=%s
ORDER BY id
"""
with db_utils.get_conn() as conn:
results = db_utils.query(conn, sql, (id_order, ))
shipments_index = [item[0] for item in results]
self.assertEqual(
len(shipments_index), expected_count,
"Shipments count is not as expected:"
"%s-%s" % (shipments_index, expected_count))
return shipments_index
def process_kml(kml_content):
root = parser.fromstring(kml_content)
pmark = root.Document.Folder.Placemark
while pmark is not None:
mmsi = pmark.name.text
lon, lat = pmark.Point.coordinates.text.split(',')
detail_html = pmark.description.text
with get_conn() as conn:
try:
save_vessel_data(conn, mmsi, lat, lon, detail_html)
except Exception, e:
conn.rollback()
raise
# next
pmark = pmark.getnext()
def _freeShippingCheck(self, id_shipment, expecte_shipping_fee):
sql = """SELECT fee
FROM free_shipping_fee
WHERE id_shipment =%s
"""
with db_utils.get_conn() as conn:
results = db_utils.query(conn, sql, (id_shipment, ))
self.assertTrue(
len(results) > 0, 'No free shipping fee record '
'found for shipment: %s' % id_shipment)
self.assertEqual(
results[0][0], expecte_shipping_fee,
'Free shipping fee for: %s is '
'not as expected: %s - %s' %
(id_shipment, results[0][0], expecte_shipping_fee))
def expect_one_item_result(self, id_order, exp_amount_due):
sql = """SELECT amount_due
FROM invoices
WHERE id_order = %s
"""
with db_utils.get_conn() as conn:
amount_due = db_utils.query(conn, sql, (id_order, ))
self.assertEqual(
len(amount_due), 1,
"There should have one invoice record for order %s" % id_order)
amount_due = amount_due[0][0]
self.assertAlmostEqual(
float(amount_due),
float(exp_amount_due),
msg="order(%s) amount_due %s is not same with expected: %s" %
(id_order, amount_due, exp_amount_due))
def send_container_arrival_notif(container, last_pod):
logging.info("Sending container arrival notif for %s" % container)
with db_utils.get_conn() as conn:
msg = "Container(%s) is arriving in %s" % (container, last_pod)
notifs = db_utils.select(conn, "container_arrival_notif",
columns=("id", "email"),
where={'container': container,
'done': False})
for _id, _email in notifs:
send_html_email(_email,
msg,
msg)
db_utils.update(conn, "container_arrival_notif",
values={'done': True},
where={'id': _id})
conn.commit()
def msg_handler(self, method_name, req, resp, **kwargs):
with db_utils.get_conn() as conn:
self.conn = conn
try:
method = getattr(self, '_on_' + method_name)
data = method(req, resp, conn, **kwargs)
except ValidationError, e:
logging.error('Validation Error: %s', (e, ), exc_info=True)
data = {'res': RESP_RESULT.F, 'err': str(e)}
conn.rollback()
except DatabaseError, e:
logging.error('Server DB Error: %s', (e, ), exc_info=True)
data = {
"res": RESP_RESULT.F,
"err": "DB_ERR",
"ERR_SQLDB": str(e)
}
conn.rollback()
def __support_services_check():
if expect_supported_services is None:
return
columns = ["id_shipment", "id_postage", "supported_services"]
sql = """SELECT %s
FROM shipping_supported_services
WHERE id_shipment=%%s
""" % ", ".join(columns)
with db_utils.get_conn() as conn:
results = db_utils.query(conn, sql, (id_shipment, ))
self.assert_(
len(results),
'There is no supported services for shipment: %s' %
id_shipment)
r = results[0]
if expect_supported_services is not None:
self.assertEqual(
r['supported_services'], expect_supported_services,
'shipment(supported_services) is not as expected: %s-%s' %
(r['supported_services'], expect_supported_services))
def send_vessel_arrival_notif(detail_vessel_obj):
logging.info("Sending vessel arrival notif for %s" % detail_vessel_obj.name)
msg = "Vessel %s is arriving in %s" % (
detail_vessel_obj.name,
detail_vessel_obj.departure_portname
or detail_vessel_obj.departure_locode)
with db_utils.get_conn() as conn:
notifs = db_utils.select(conn, "vessel_arrival_notif",
columns=("id", "email"),
where={'mmsi': str(detail_vessel_obj.mmsi),
'done': False})
for _id, _email in notifs:
send_html_email(_email,
msg,
msg)
db_utils.update(conn, "vessel_arrival_notif",
values={'done': True},
where={'id': _id})
conn.commit()
def main():
size = settings.HMAC_KEY_SIZE
path = settings.HMAC_KEY_FILE_PATH
hmac_key = os.urandom(size)
with open(path, 'w') as f:
f.write(hmac_key)
f.close()
logging.info('HMAC key updated at %s UTC: %s' %
(datetime.utcnow(), hmac_key))
with db_utils.get_conn(settings.DATABASE) as conn:
result = db_utils.delete(
conn,
'users_logins',
where={'cookie_expiry__lt': datetime.utcnow()},
returning='*')
if result:
logging.info('Delete expiry login sessions at %s UTC: %s' %
(datetime.utcnow(), result))
else:
logging.info('No sessions expired')
def msg_handler(self, method_name, req, resp, **kwargs):
with db_utils.get_conn() as conn:
self.conn = conn
try:
if self.login_required.get(method_name):
self._auth(conn, req, resp, **kwargs)
kwargs['users_id'] = self.users_id
self.language = detect_locale(
req.headers.get('accept-language', ''))
method = getattr(self, '_on_' + method_name)
data = method(req, resp, conn, **kwargs)
except ValidationError, e:
logging.error('Validation Error: %s', (e,), exc_info=True)
data = {'res': RESP_RESULT.F,
'err': str(e)}
conn.rollback()
except DatabaseError, e:
logging.error('Server DB Error: %s', (e,), exc_info=True)
data = {"res": RESP_RESULT.F,
"err": "DB_ERR",
"ERR_SQLDB": str(e)}
conn.rollback()
def __shipment_check():
columns = ["id_order", "status"]
sql = """SELECT %s
FROM shipments
WHERE id=%%s
""" % ", ".join(columns)
with db_utils.get_conn() as conn:
results = db_utils.query(conn, sql, (id_shipment, ))
self.assertTrue(
len(results) > 0, 'Shipment-%s not exist' % id_shipment)
r = dict(zip(tuple(columns), tuple(results[0])))
if expect_order is not None:
self.assertEqual(
r['id_order'], expect_order,
'shipment(id_order) is not as expected: %s-%s' %
(r['id_order'], expect_order))
if expect_status is not None:
self.assertEqual(
r['status'], expect_status,
'shipment(status) is not as expected: %s-%s' %
(r['status'], expect_status))
def __shipping_fee_check():
columns = ["id_shipment", "handling_fee", "shipping_fee"]
sql = """SELECT %s
FROM shipping_fee
WHERE id_shipment=%%s
""" % ", ".join(columns)
with db_utils.get_conn() as conn:
results = db_utils.query(conn, sql, (id_shipment, ))
if (expect_handling_fee is not None
or expect_shipping_fee is not None):
self.assert_(len(results),
'There is no fee for shipment: %s' % id_shipment)
r = results and results[0] or None
if expect_none_shipping_fee:
self.assert_(
r is None or r['shipping_fee'] is None,
'shipment(shipping_fee) is not as expected: %s-%s' %
(r and r['shipping_fee'] or None, None))
if expect_none_handling_fee:
self.assert_(
r is None or r['shipping_fee'] is None,
'shipment(handling_fee) is not as expected: %s-%s' %
(r and r['handling_fee'] or None, None))
if expect_shipping_fee is not None:
self.assertEqual(
r['shipping_fee'], expect_shipping_fee,
'shipment(shipping_fee) is not as expected: %s-%s' %
(r['shipping_fee'], expect_shipping_fee))
if expect_handling_fee is not None:
self.assertEqual(
r['handling_fee'], expect_handling_fee,
'shipment(handling_fee) is not as expected: %s-%s' %
(r['handling_fee'], expect_handling_fee))
def _success_check(self, id_shipment, resp_content, exp_postage=None,
exp_fee=None, exp_free_fee=None):
self.assertEqual(resp_content, SUCCESS)
conn = db_utils.get_conn()
if exp_postage is not None:
query_str = ("SELECT id_postage "
"FROM shipping_supported_services "
"WHERE id_shipment=%s")
r = db_utils.query(conn, query_str, (id_shipment,))
self.assert_(len(r),
"No supported service record for shipment: %s"
% id_shipment)
self.assertEqual(int(r[0][0]), int(exp_postage))
if exp_fee is not None:
query_str = ("SELECT shipping_fee "
"FROM shipping_fee "
"WHERE id_shipment=%s")
r = db_utils.query(conn, query_str, (id_shipment,))
self.assert_(len(r),
"No shipping fee record for shipment: %s"
% id_shipment)
self.assertEqual(float(r[0][0]), float(exp_fee))
if exp_free_fee is not None:
query_str = ("SELECT fee "
"FROM free_shipping_fee "
"WHERE id_shipment=%s")
r = db_utils.query(conn, query_str, (id_shipment,))
self.assert_(len(r),
"No free shipping fee record for shipment: %s"
% id_shipment)
self.assertEqual(float(r[0][0]), float(exp_free_fee))
def run(self):
with db_utils.get_conn() as conn:
self.fetch(conn)
gevent.spawn_later(settings.FETCH_VESSEL_MIN_INTERVAL, self.run)
def on_post(self, req, resp, **kwargs):
try:
logging.info('Shipping_fee_request: %s' % req.stream)
data = decrypt_json_resp(
req.stream, settings.SERVER_APIKEY_URI_MAP[SERVICES.ADM],
settings.PRIVATE_KEY_PATH)
logging.info("Received shipping fee %s" % data)
data = ujson.loads(data)
except Exception, e:
logging.error("Got exceptions when decrypting shipping fee %s" % e,
exc_info=True)
self.gen_resp(resp, {'res': RESP_RESULT.F})
else:
self.gen_resp(resp, {'res': RESP_RESULT.S})
with db_utils.get_conn() as conn:
gevent.spawn(update_shipping_fee, conn, data['id_shipment'],
data['id_postage'], data['shipping_fee'])
def gen_resp(self, resp, data_dict):
resp.content_type = "application/json"
resp.body = gen_encrypt_json_context(
ujson.dumps(data_dict),
settings.SERVER_APIKEY_URI_MAP[SERVICES.ADM],
settings.PRIVATE_KEY_PATH)
return resp
class OrderListResource(BaseOrderResource):
def _on_get(self, req, resp, conn, **kwargs):
brand_id = req.get_param('brand_id', None)