def on_success_login(self, req, resp, conn, users_id, auth_token):
ip_address = get_client_ip(req)
headers = get_hashed_headers(req)
csrf_token = gen_csrf_token()
delta = timedelta(seconds=settings.USER_AUTH_COOKIE_EXPIRES)
utc_expiry = datetime.utcnow() + delta
values = {
"users_id": users_id,
"ip_address": ip_address,
"headers": headers,
"csrf_token": csrf_token,
"cookie_expiry": utc_expiry
}
db_utils.update(conn,
"users_logins",
values={"cookie_expiry": datetime.utcnow()},
where={
"users_id": users_id,
"ip_address": ip_address,
"headers": headers,
"cookie_expiry__gt": datetime.utcnow()
})
db_utils.insert(conn, "users_logins", values=values)
# set cookie
expiry = gen_cookie_expiry(utc_expiry)
auth_cookie = make_auth_cookie(expiry, csrf_token, auth_token,
users_id)
set_cookie(resp, USER_AUTH_COOKIE_NAME, auth_cookie, expiry=expiry)
self._set_basket_data(req, resp, users_id)
def _update_phone_num(self, conn, req, users_id):
number_dict = {}
for p in req._params:
if p.startswith('country_num_'):
number_dict[p.replace('country_num_', '')] = {}
columns = ('country_num', 'phone_num', 'phone_num_desp')
for num_id in number_dict:
number_dict[num_id]['users_id'] = users_id
for c in columns:
p = req.get_param('%s_%s' % (c, num_id)) or ''
if c == 'phone_num' and not re.match(phone_num_reexp, p):
raise ValidationError('INVALID_PHONE_NUMBER')
number_dict[num_id][c] = p
num_changed = self._item_changed(conn, users_id, columns,
"users_phone_num", num_id,
number_dict[num_id])
if num_changed:
num_referenced = self._is_filed_referenced(
conn, users_id, 'id_phone', 'users_phone_num', num_id)
else:
num_referenced = False
if num_id.isdigit() and int(num_id) == 0 \
or num_changed and num_referenced:
db_utils.insert(conn,
"users_phone_num",
values=number_dict[num_id])
else:
db_utils.update(conn,
"users_phone_num",
values=number_dict[num_id],
where={'id': num_id})
def update_invoice(conn, id_iv, values, iv=None):
where = {'id': id_iv}
values['update_time'] = datetime.now()
if iv is None or iv['id'] != int(id_iv):
iv = get_invoice_by_id(conn, id_iv)
if iv is None:
logging.error('iv_update_err: invoice %s not exist',
id_iv)
return
r = update(conn,
"invoices",
values=values,
where=where,
returning='id')
if (values.get('status') and
int(values.get('status') != iv['status'])):
insert(conn,
'invoice_status',
values={'id_invoice': id_iv,
'status': iv['status'],
'amount_paid': iv['amount_paid'],
'timestamp': iv['update_time']})
seller = get_seller(conn, iv['id_shipment'])
from models.order import up_order_log
up_order_log(conn, iv['id_order'], seller)
if int(values.get('status')) == INVOICE_STATUS.INVOICE_PAID:
from models.coupon import redeem_coupon_for_shipment
redeem_coupon_for_shipment(conn, iv['id_order'], iv['id_shipment'], id_iv)
logging.info("invoice_%s updated: %s", id_iv, values)
return r and r[0] or None
def _coupon_redeemed(conn, id_coupon, id_order, id_invoice):
results = db_utils.select(conn,
'coupon_redeemed',
where={
'id_coupon': id_coupon,
'id_order': id_order,
})
if not results:
return
update_values = {
'id_invoice': id_invoice,
'order_status': ORDER_STATUS_FOR_COUPON.PAID,
}
if len(results) == 1 and results[0]['id_invoice'] is None:
db_utils.update(conn,
'coupon_redeemed',
values=update_values,
where={'id': results[0]['id']})
else:
values = {
'id_coupon': results[0]['id_coupon'],
'id_user': results[0]['id_user'],
'id_order': results[0]['id_order'],
'redeemed_time': results[0]['redeemed_item'],
'account_address': results[0]['account_address'],
'account_phone': results[0]['account_phone'],
'user_agent': results[0]['user_agent'],
}
values.update(update_values)
db_utils.insert(conn, 'coupon_redeemed', values=values)
def _create_order_details(conn, id_order, id_item, quantity):
details_value = {
'id_order': id_order,
'id_item': id_item,
'quantity': quantity
}
insert(conn, 'order_details', values=details_value)
logging.info('order_details create: %s', details_value)
def _update_address(self, conn, req, users_id):
addr_dict = {}
for p in req._params:
if p.startswith('country_code_'):
addr_dict[p.replace('country_code_', '')] = {}
columns = ('addr_type', 'address', 'city', 'postal_code',
'country_code', 'province_code', 'address_desp', 'address2',
'full_name')
for addr_id in addr_dict:
addr_dict[addr_id]['users_id'] = users_id
for c in columns:
p = req.get_param('%s_%s' % (c, addr_id)) or ''
if c == 'addr_type' and p.isdigit() \
and int(p) not in ADDR_TYPE.toDict().values():
raise ValidationError('INVALID_ADDR_TYPE')
if c == 'address' and not re.match(addr_reexp, p):
raise ValidationError('INVALID_ADDRESS')
if c == 'city' and not re.match(city_reexp, p):
raise ValidationError('INVALID_CITY')
if c == 'postal_code' and not re.match(postal_code_reexp, p):
raise ValidationError('INVALID_POSTAL_CODE')
addr_dict[addr_id][c] = p
if int(addr_id) > 0 and \
int(addr_dict[addr_id]['addr_type']) == ADDR_TYPE.Both:
raise ValidationError('INVALID_ADDR_TYPE')
addr_changed = self._item_changed(conn, users_id, columns,
"users_address", addr_id,
addr_dict[addr_id])
if addr_changed:
addr_referenced = self._is_filed_referenced(
conn, users_id, 'id_shipaddr', 'users_address', addr_id) \
or self._is_filed_referenced(
conn, users_id, 'id_billaddr', 'users_address', addr_id)
else:
addr_referenced = False
if (addr_id.isdigit() and int(addr_id) == 0 and int(
addr_dict[addr_id]['addr_type']) == ADDR_TYPE.Both):
# insert two address records if add type is ADDR_TYPE.Both
for t in (ADDR_TYPE.Shipping, ADDR_TYPE.Billing):
addr_dict[addr_id]['addr_type'] = t
db_utils.insert(conn,
"users_address",
values=addr_dict[addr_id])
elif (addr_id.isdigit() and int(addr_id) == 0
or addr_changed and addr_referenced):
db_utils.insert(conn,
"users_address",
values=addr_dict[addr_id])
else:
db_utils.update(conn,
"users_address",
values=addr_dict[addr_id],
where={'id': addr_id})
def _log_order(conn, users_id, id_order, sellers):
for id_brand, shops in sellers.iteritems():
for id_shop in shops:
values = {
'users_id': users_id,
'id_order': id_order,
'id_brand': id_brand,
'id_shop': id_shop
}
insert(conn, 'orders_log', values=values)
def save_vessel_data(conn, mmsi, lat, lon, detail_html):
soup = BeautifulSoup(detail_html)
if soup.find(name='td'):
time = soup.find(name='p').text
nav_status = soup.find(name='td', text='Navigation Status').find_next().text
heading = soup.find(name='td', text='True Heading').find_next().text
speed = soup.find(name='td', text='Speed Over Ground').find_next().text
else:
info = soup.find(name='p').text.split('\n')
time = info[0]
nav_status = ''
m = re.match(
r'.* (?P<speed>\d+(\.\d+)?) heading (?P<heading>\d+(\.\d+)?) .*',
info[1])
if m:
heading = m.groupdict()['heading']
speed = m.groupdict()['speed']
else:
heading = None
speed = None
vessels = db_utils.select(conn, "vessel",
columns=("id", ),
where={'mmsi': mmsi},
limit=1)
if len(vessels) > 0:
id_vessel = vessels[0][0]
else:
vessel_values = {
'mmsi': mmsi,
}
id_vessel = db_utils.insert(conn, "vessel",
values=vessel_values, returning='id')[0]
pos_values = {
'id_vessel': id_vessel,
'location': '',
'longitude': lon,
'latitude': lat,
'heading': format_number(heading),
'speed': format_number(speed),
'time': format_text(time),
'status': nav_status,
}
existings = db_utils.select(conn, "vessel_position",
columns=("id", ),
where={'id_vessel': id_vessel,
'time': format_text(time)},
limit=1)
if len(existings) == 0:
print "inserting: ", pos_values
db_utils.insert(conn, "vessel_position", values=pos_values)
else:
print "existing: ", pos_values
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 _create_order_shipment_detail(conn, id_order, id_shipaddr, id_billaddr,
id_phone):
values = {
'id_order': id_order,
'id_shipaddr': id_shipaddr,
'id_billaddr': id_billaddr,
'id_phone': id_phone,
}
insert(conn, 'order_shipment_details', values=values)
logging.info('order_shipment_details item created:' 'values: %s' % values)
def _shippingListForFreeShippingSalesGroup(self, free_sales_group, spm_id,
fee):
for sale in free_sales_group:
id_order_item = sale.order_props['id_order_item']
quantity = sale.order_props['quantity']
create_shipping_list(self.conn,
id_order_item,
quantity,
quantity,
id_shipment=spm_id,
free_shipping=True)
values = {'id_shipment': spm_id, 'fee': fee}
insert(self.conn, 'free_shipping_fee', values=values)
def _update_portname(self, conn, port_name, locode):
if not port_name: return
existing_name = self._query_portname(conn, locode)
values = {'locode': locode, 'name': port_name}
if existing_name is None:
db_utils.insert(conn, "port", values=values)
else:
if existing_name != port_name:
db_utils.update(conn,
"port",
values=values,
where={'locode': locode})
def add_card(self, conn, data):
# validation
for param in ['id_user', 'pan', 'cvc', 'expiration_date']:
if not data.get(param):
raise ValidationError('Missing param %s' % param)
id_user = data['id_user']
cardholder_name = data.get('cardholder_name', '')
pan = data['pan']
cvc = data['cvc']
expire = data['expiration_date']
repeat = data.get('repeat')
if not is_valid_cc_num(pan):
raise ValidationError('Invalid param pan')
if not is_valid_cvc(cvc):
raise ValidationError('Invalid param cvc')
try:
datetime.strptime(expire, '%m%y')
except:
raise ValidationError('Invalid param expiration_date')
results = db_utils.select(conn,
'credit_card',
where={
'id_user': id_user,
'cc_num': mask_cc_num(pan),
'expiration_date': expire,
'valid': True,
})
if results:
raise ValidationError('Duplicated Card')
values = {
'id_user': id_user,
'cardholder_name': cardholder_name,
'cc_num': mask_cc_num(pan),
'expiration_date': expire,
'repeat': bool(repeat),
'valid': False,
}
id_card = db_utils.insert(conn,
'credit_card',
values=values,
returning='id')[0]
cli = Paybox()
token = cli.register_card(id_card,
id_user,
pan,
cvc,
expire,
repeat=bool(repeat))
db_utils.update(conn,
'credit_card',
values={
'paybox_token': token,
'valid': True
},
where={'id': id_card})
return id_card
def _add_shipping_supported_services(conn, id_shipment, supported_services):
values = {"id_shipment": id_shipment}
if isinstance(supported_services, str):
supported_services = ujson.loads(supported_services)
if (supported_services and len(supported_services) == 1):
values['id_postage'] = supported_services.keys()[0]
carrier_services_map = defaultdict(list)
for id_service, id_carrier in supported_services.iteritems():
carrier_services_map[id_carrier].append(id_service)
supported_services_details = remote_xml_shipping_services(
carrier_services_map.items())
values['supported_services_details'] = supported_services_details
if isinstance(supported_services, dict):
supported_services = ujson.dumps(supported_services)
values['supported_services'] = supported_services
id = insert(conn,
'shipping_supported_services',
values=values,
returning='id')
logging.info('shipment supported services added: id: %s, values: %s',
id[0], values)
def create_trans(conn, id_order, id_invoices,
amount_due, cookie,
status=TRANS_STATUS.TRANS_OPEN,
create_time=None,
update_time=None):
if isinstance(id_invoices, list):
id_invoices = ujson.dumps(id_invoices)
if (create_time == None):
create_time = datetime.now()
if (update_time == None):
update_time = datetime.now()
values = {
'id_order': id_order,
'id_invoices': id_invoices,
'status': status,
'create_time': create_time,
'update_time': update_time,
'amount_due': amount_due,
'cookie': cookie
}
trans_id = insert(conn, 'transactions', values=values, returning='id')
logging.info('transaction created: id: %s, values: %s',
trans_id[0], values)
return trans_id[0]
def _create_shipping_list(conn, id_item, orig_id_item, quantity=1):
shipping_value = db_utils.select_dict(conn,
'shipping_list',
'id',
where={
'id_item': orig_id_item
}).values()[0]
db_utils.insert(conn,
'shipping_list',
values={
'id_item': id_item,
'id_shipment': shipping_value['id_shipment'],
'quantity': quantity,
'packing_quantity': quantity,
'free_shipping': shipping_value['free_shipping'],
})
def apply_password_coupon(conn, pwd_coupon, all_order_items, match_order_items,
id_user, id_order, user_info, chosen_gifts):
assert pwd_coupon['coupon_type'] != COUPON_REWARD_TYPE.COUPON_CURRENCY
_calc_discount_result(conn, pwd_coupon['id'], pwd_coupon, id_order,
chosen_gifts, all_order_items, match_order_items)
db_utils.insert(conn,
'coupon_redeemed',
values={
'id_coupon': pwd_coupon['id'],
'id_user': id_user,
'id_order': id_order,
'order_status': ORDER_STATUS_FOR_COUPON.PENDING,
'account_address': user_info['fo_user_addr'],
'account_phone': user_info['fo_user_phone'],
'user_agent': user_info['user_agent'],
})
def _add_shipping_fee(conn, id_shipment, handling_fee, shipping_fee):
values = {
"id_shipment": id_shipment,
'handling_fee': to_round(handling_fee),
'shipping_fee': to_round(shipping_fee)
}
id = insert(conn, 'shipping_fee', values=values, returning='id')
logging.info('shipment fee added: id: %s, values: %s', id[0], values)
def _store_credit_redeemed(conn, id_coupon, id_order, id_invoice, amount):
results = db_utils.select(conn,
'store_credit_redeemed',
where={
'id_coupon': id_coupon,
'id_order': id_order,
},
order=('-id_invoice', ))
if not results or results[0]['id_invoice']:
return
update_values = {
'id_invoice': id_invoice,
'order_status': ORDER_STATUS_FOR_COUPON.PAID,
}
total = to_round(results[0]['redeemed_amount'])
if total <= amount:
db_utils.update(conn,
'store_credit_redeemed',
values=update_values,
where={'id': results[0]['id']})
else:
values = {
'id_coupon': results[0]['id_coupon'],
'id_user': results[0]['id_user'],
'id_order': results[0]['id_order'],
'currency': results[0]['currency'],
'redeemed_amount': amount,
}
values.update(update_values)
db_utils.insert(conn, 'store_credit_redeemed', values=values)
db_utils.update(conn,
'store_credit_redeemed',
values={'redeemed_amount': to_round(total - amount)},
where={'id': results[0]['id']})
# check if need to mark redeemed_in_full
credit_value = _get_store_credit(conn, id_coupon)
redeemed_amount = _get_store_redeemed_amount(conn, id_coupon)
if credit_value and credit_value['amount'] <= to_round(redeemed_amount):
db_utils.update(conn,
'store_credit',
values={'redeemed_in_full': True},
where={'id_coupon': id_coupon})
def create_trans(conn,
id_order,
id_user,
id_invoices,
iv_numbers,
amount_due,
currency,
invoices_data,
status=TRANS_STATUS.TRANS_OPEN,
create_time=None,
update_time=None,
cookie=None):
if isinstance(id_invoices, list):
id_invoices = ujson.dumps(id_invoices)
# if there is an existing open transaction for this order and invoices,
# return it directly to avoid creating duplicate transactions
sql = """
SELECT id, cookie
FROM transactions
WHERE id_order = %(id_order)s AND id_invoices = '%(id_invoices)s' AND status != %(status)s ;
""" % ({
'id_order': id_order,
'id_invoices': id_invoices,
'status': TRANS_STATUS.TRANS_FAIL,
})
check = query(conn, sql)
if len(check) > 0:
return check[0][0]
if (create_time == None):
create_time = datetime.now()
if (update_time == None):
update_time = datetime.now()
values = {
'id_order': id_order,
'id_user': id_user,
'id_invoices': id_invoices,
'iv_numbers': iv_numbers,
'status': status,
'create_time': create_time,
'update_time': update_time,
'amount_due': amount_due,
'currency': currency,
'invoices_data': invoices_data
}
if cookie is not None:
values['cookie'] = cookie
trans_id = insert(conn, 'transactions', values=values, returning='id')
logging.info('transaction created: id: %s, values: %s', trans_id[0],
values)
return trans_id[0]
def create_shipment(conn,
id_order,
id_brand,
id_shop,
status=SHIPMENT_STATUS.PACKING,
handling_fee=None,
shipping_fee=None,
supported_services=None,
shipping_date=None,
shipping_carrier=None,
tracking_name=None,
tracking_num=None,
calculation_method=None):
sm_values = {
'id_order': id_order,
'id_brand': id_brand,
'id_shop': id_shop,
'status': status,
'create_time': datetime.utcnow(),
'update_time': datetime.utcnow(),
}
if calculation_method is not None:
sm_values['calculation_method'] = calculation_method
if tracking_name is not None:
sm_values['tracking_name'] = tracking_name
if tracking_num is not None:
sm_values['mail_tracking_number'] = tracking_num
if isinstance(supported_services, str):
supported_services = ujson.loads(supported_services)
if supported_services and len(supported_services) == 1:
sm_values['shipping_carrier'] = int(supported_services.values()[0])
elif shipping_carrier is not None:
sm_values['shipping_carrier'] = shipping_carrier
if (status == SHIPMENT_STATUS.FETCHED or calculation_method
== SHIPPING_CALCULATION_METHODS.FREE_SHIPPING):
sm_values['shipping_carrier'] = FREE_SHIPPING_CARRIER
shipping_fee = 0
handling_fee = 0
if shipping_date is not None:
sm_values['shipping_date'] = shipping_date
sm_id = insert(conn, 'shipments', values=sm_values, returning='id')
logging.info('shipment created: id: %s, values: %s', sm_id[0], sm_values)
if handling_fee is not None or shipping_fee is not None:
_add_shipping_fee(conn, sm_id[0], handling_fee, shipping_fee)
if supported_services is not None:
_add_shipping_supported_services(conn, sm_id[0], supported_services)
return sm_id[0]
def _on_post(self, req, resp, conn, **kwargs):
try:
sid = req.get_param('sid')
users_id = req.get_param('users_id') or None
where = {'sid': sid}
v_log = select(conn, 'visitors_log', where=where)
if len(v_log) > 0:
update(conn,
'visitors_log', {'users_id': users_id},
where={'sid': sid})
else:
values = {'sid': sid, 'users_id': users_id}
insert(conn, 'visitors_log', values=values)
return {'result': RESP_RESULT.S}
except Exception, e:
logging.error('visitors_log_err: %s', e, exc_info=True)
return {'result': RESP_RESULT.F}
def _create_fake_order_item(conn,
id_order,
orig_id_item,
item_value,
quantity=1):
id_item = db_utils.insert(conn,
'order_items',
values=item_value,
returning='id')[0]
logging.info('order_item create: item id: %s, values: %s', id_item,
item_value)
details_value = {
'id_order': id_order,
'id_item': id_item,
'quantity': quantity
}
db_utils.insert(conn, 'order_details', values=details_value)
logging.info('order_details create: %s', details_value)
_create_shipping_list(conn, id_item, orig_id_item, quantity=quantity)
def _on_post(self, req, resp, conn, **kwargs):
f = StringIO(req.query_string)
data = decrypt_json_resp(f,
settings.SERVER_APIKEY_URI_MAP[SERVICES.USR],
settings.PRIVATE_KEY_PATH)
f.close()
form_params = cgi.parse_qs(data)
for p in form_params:
form_params[p] = form_params[p][0]
action = form_params.get('action')
id_user = form_params.get('id_user')
email = form_params.get('email')
imo = form_params.get('imo')
mmsi = form_params.get('mmsi')
if action not in ('add', 'delete'):
raise ValidationError('INVALID_REQUEST')
if not id_user or not email or not imo or not mmsi:
raise ValidationError('INVALID_REQUEST')
values = {
'id_user': id_user,
'email': email,
'imo': imo,
'mmsi': mmsi,
'done': False,
}
if action == 'add':
records = db_utils.select(conn,
"vessel_arrival_notif",
columns=("imo", "mmsi"),
where=values)
if len(records) == 0:
db_utils.insert(conn, "vessel_arrival_notif", values=values)
elif action == 'delete':
db_utils.delete(conn, "vessel_arrival_notif", where=values)
return {'res': RESP_RESULT.S}
def create_shipping_list(conn,
id_item,
quantity,
packing_quantity,
id_shipment=None,
picture=None,
free_shipping=None):
shipping_value = {
'id_item': id_item,
'quantity': quantity,
'packing_quantity': packing_quantity
}
if id_shipment:
shipping_value['id_shipment'] = id_shipment
if picture:
shipping_value['picture'] = picture
if free_shipping is not None:
shipping_value['free_shipping'] = free_shipping
insert(conn, 'shipping_list', values=shipping_value)
logging.info('shipping_list create: %s', shipping_value)
def log_incomes(conn, iv_id):
try:
q = ("SELECT id_order "
"FROM invoices "
"WHERE id = %s")
r = query(conn, q, (iv_id,))
id_order = r[0][0]
q = ("SELECT id_user "
"FROM orders "
"WHERE id = %s")
r = query(conn, q, (id_order,))
id_user = r[0][0]
results = select(conn, 'incomes_log', where={'order_id': id_order})
if len(results) == 0:
insert(conn, 'incomes_log',
values={'order_id': id_order,
'users_id': id_user,
'up_time': datetime.utcnow()})
except Exception, e:
logging.error('log_incomes_err: %s', e, exc_info=True)
def _save_ticket(self, conn, values):
ticket_id = db_utils.insert(conn,
"ticket",
values=values,
returning='id')[0]
# attachment
form_params = cgi.parse_qs(self.request.query_string)
for _id in form_params.get('attachment', []):
db_utils.update(conn,
"ticket_attachment",
values={'id_ticket': ticket_id},
where={'id': _id})
return ticket_id
def update_shipment(conn, id_shipment, values, shipment=None):
where = {'id': id_shipment}
values['update_time'] = datetime.now()
if shipment is None or shipment['id'] != int(id_shipment):
shipment = get_shipment_by_id(conn, id_shipment)
if not shipment:
return
r = update(conn, "shipments", values=values, where=where, returning="id")
if (values.get('status')
and int(values.get('status')) != shipment['status']):
insert(conn,
'shipment_status',
values={
'id_shipment': id_shipment,
'status': shipment['status'],
'timestamp': shipment['update_time']
})
from models.order import up_order_log
up_order_log(conn, shipment['id_order'],
{shipment['id_brand']: [shipment['id_shop']]})
logging.info("shipment_%s updated: %s", id_shipment, values)
return r and r[0] or None
def _copy_fake_order_item(conn,
id_order,
orig_id_item,
item_update_value,
quantity=1):
item_copy_value = db_utils.select_dict(conn,
'order_items',
'id',
where={
'id': orig_id_item
}).values()[0]
item_copy_value = dict(item_copy_value)
item_copy_value.update(item_update_value)
item_copy_value.pop('id')
id_item = db_utils.insert(conn,
'order_items',
values=item_copy_value,
returning='id')[0]
logging.info('order_item create: item id: %s, values: %s', id_item,
item_copy_value)
details_value = {
'id_order': id_order,
'id_item': id_item,
'quantity': quantity
}
db_utils.insert(conn, 'order_details', values=details_value)
logging.info('order_details create: %s', details_value)
db_utils.update(
conn,
"order_items",
values={'modified_by_coupon': item_copy_value['modified_by_coupon']},
where={'id': orig_id_item})
_create_shipping_list(conn, id_item, orig_id_item, quantity=quantity)
def _on_post(self, req, resp, conn, **kwargs):
filename = req.get_param('name', required=True)
random_key = b64encode(os.urandom(64)).decode('utf-8')
content = req.stream.read()
content = CBCCipher(random_key).encrypt(content)
result = upload(filename, content)
if result.get('res') == RESP_RESULT.F:
raise Exception(result['err'])
location = result['location']
attach_id = db_utils.insert(conn,
"ticket_attachment",
values={
'location': location,
'random_key': random_key
},
returning='id')[0]
return {"res": RESP_RESULT.S, "err": "", "id": attach_id}
