def bundle(self, name, agent_id, price, pin):
bc = AgentNotifier()
c_agent = DBCache(const.AGENT_PREFIX, config.DEFAULT_EXPIRE,
const.AGENT_SQL)
c_agent.setConn(bc.dbconn, bc.cacheconn)
dm = DepositMutation(20, bc.dbconn, bc.cacheconn)
ag = c_agent.sGet(agent_id)
if not ag:
return json.dumps({'success': 0, 'reason': 'AGENT NOT FOUND'})
sql = '''SELECT * FROM `bundle` WHERE `bundle_name`=%s'''
c = bc.dbconn.cursor(MySQLdb.cursors.DictCursor)
c.execute(sql, (name,))
cs = c.fetchall()
if len(cs) == 0:
return json.dumps({'success': 0, 'reason': 'BUNDLE NOT FOUND'})
balance = dm.debit(agent_id, int(price), 'Bundle {0}'.format(name))
if balance < 0:
return json.dumps({'success': 0, 'reason': 'NOT ENOUGH DEPOSIT'})
um = UnitMutation(5, bc.dbconn, bc.cacheconn)
for r in c:
um.credit(agent_id, r['product_id'], r['unit'], 0, name)
msg = 'Add bundle {0} to {1}-{2} Rp {3}'.\
format(name, agent_id, ag['agent_name'], thousandSeparator(price))
for prot in ('ym://b_martian','ym://inileonard', 'ym://sridwan981'):
bc.writeNotifyOut(prot, 'general_message', {'message': msg})
bc.dbconn.commit()
return json.dumps({'success': 1, 'reason': ''})
def new_agent(self, agent_name, agent_type, agent_price,
agent_address, agent_protocol, agent_pin, agent_upline, pin):
'''Add new agent'''
bc = AgentNotifier()
am = ManageAgentPrice(bc.dbconn, bc.cacheconn)
new_id = am.newAgent(agent_name, agent_address, agent_type, agent_pin,
agent_upline, config.AGENT_DEFAULT_MARKUP,
agent_price, agent_protocol)
if not new_id:
return json.dumps({
'success': 0,
'agent_id': '',
})
bc.dbconn.commit()
if am.registerProtocols(new_id, agent_protocol):
bc.dbconn.commit()
bc.writeNotifyOut(agent_protocol, 'add_agent_success', {
'agent_id': new_id,
'name': agent_name,
'pin': agent_pin,
})
bc.dbconn.commit()
return json.dumps({
'success': 1,
'agent_id': new_id,
})
def stock_check_multi(self, dev_id, pin):
bc = AgentNotifier()
devs = []
_1 = dev_id.split(',')
ops = []
for d in _1:
d2 = self.c_dev.get(bc.dbconn, bc.cacheconn, d)
if d2:
devs.append({
'device_id': d,
'opid': d2['operator_id'],
'pin': d2['pin'],
})
if d2['operator_id'] not in ops:
ops.append(d2['operator_id'])
if len(devs) == 0:
return json.dumps({'success': 0, 'reason': 'DEVICE NOT FOUND'})
devs_sql = map(lambda x: '"{0}"'.format(x['device_id']), devs)
c = bc.dbconn.cursor(MySQLdb.cursors.DictCursor)
dcs = {}
c.execute('''SELECT `device_id`, `check_stock_counter` from `devices` WHERE
`device_id` IN ({0})'''.format(','.join(devs_sql)))
for r in c:
dcs[r['device_id']] = r['check_stock_counter']
c.execute('''SELECT `operator_id`,`stock_check_1`,`stock_check_2` from `operator`
WHERE `operator_id` IN ({0})'''.format(','.join(map(lambda x: str(x), ops))))
ops = {}
for r in c:
ops[r['operator_id']] = (r['stock_check_1'], r['stock_check_2'])
for r in devs:
server_id, port = r['device_id'].split('.')
leaf_server = '{0}@{2}/{1}'.format(config.LEAFSERVER, server_id,
config.MSG_SERVER)
sc1, sc2 = ops[r['opid']]
parse = multipleReplace({'<pin>': r['pin'],}, sc1)
msg = '{0},{1},{2}'.format(port, '0', parse)
bc.sendMessage(leaf_server, 'JBDV', msg, commit=False)
if len(sc2) > 0:
parse = multipleReplace({'<pin>': r['pin'],}, sc2)
msg = '{0},{1},{2}'.format(port, '0', parse)
bc.sendMessage(leaf_server, 'JBDV', msg, commit=False)
bc.dbconn.commit()
to = datetime.now() + timedelta(seconds=59)
tout = True
while datetime.now() < to:
time.sleep(0.5)
c.execute('''SELECT `device_id`, `check_stock_counter` from `devices` WHERE
`device_id` IN ({0})'''.format(','.join(devs_sql)))
for r in c:
if dcs[r['device_id']] != r['check_stock_counter']:
devs_sql.remove('"{0}"'.format(r['device_id']))
dcs[r['device_id']] = r['check_stock_counter']
if len(devs_sql) == 0:
tout = False
break
if tout:
return json.dumps({'success': 0, 'reason': 'TIMEOUT'})
return json.dumps({'success': 1, 'reason': '', 'notifyid': dcs,})
def all_leaf_stop(self, pin):
bc = AgentNotifier()
c = bc.dbconn.cursor(MySQLdb.cursors.DictCursor)
c.execute('''SELECT DISTINCT `server_id` from `devices`
WHERE `status`=1''')
for s in c:
bc.sendMessage('{0}@{1}/{2}'.format(config.LEAFSERVER,
config.MSG_SERVER, s['server_id']), 'LSTO', '*')
return json.dumps({'success': 1,})
def leaf_start(self, server_id, pin):
bc = AgentNotifier()
c = bc.dbconn.cursor(MySQLdb.cursors.DictCursor)
c.execute('''SELECT `port` from `devices`
WHERE `server_id`=%s and `active`=1 and `status`=1''',
(server_id,))
devs = ' '.join([x['port'] for x in c])
if len(devs) == 0:
return json.dumps({'success': 1,})
bc.sendMessage('{0}@{1}/{2}'.format(config.LEAFSERVER,
config.MSG_SERVER, server_id), 'LSRT', devs)
return json.dumps({'success': 1,})
def depmut_execute(self, agent_id, type, amount, comment, pin):
result = {
'success': 0,
'balance': 0,
}
try:
int(amount)
except:
result['message'] = 'AMOUNT NOT VALID'
return json.dumps(result)
# agent must exist
bc = AgentNotifier()
c_agent = DBCache(const.AGENT_PREFIX, config.DEFAULT_EXPIRE,
const.AGENT_SQL)
c_agent.setConn(bc.dbconn, bc.cacheconn)
#print c_agent.sGet(agentid)
ag = c_agent.sGet(agent_id)
if not ag:
result['message'] = 'AGENT NOT REGISTERED'
return json.dumps(result)
dm = DepositMutation(20, bc.dbconn, bc.cacheconn)
prev_bal = dm.getBalance(agent_id)
if type.upper() == 'C':
balance = dm.credit(agent_id, int(amount), comment)
bc.writeNotifyOut(ag['default_protocol'], 'deposit_credit', {
'mutation': thousandSeparator(amount),
'balance_before': thousandSeparator(prev_bal),
'balance': thousandSeparator(balance),
})
elif type.upper() == 'D':
balance = dm.debit(agent_id, int(amount), comment)
bc.writeNotifyOut(ag['default_protocol'], 'deposit_debit', {
'mutation': thousandSeparator(amount),
'balance_before': thousandSeparator(prev_bal),
'balance': thousandSeparator(balance),
})
else:
result['message'] = 'TYPE NOT RECOGNIZED'
return json.dumps(result)
if balance == NOT_ENOUGH_BALANCE:
result['message'] = 'NOT ENOUGH BALANCE'
return json.dumps(result)
elif balance == LOCK_FAILED:
result['message'] = 'SERVER BUSY'
return json.dumps(result)
bc.dbconn.commit()
msg = '{0}-{1} Deposit: Rp. {2} Before: Rp. {3} After: Rp. {4} ({5}) ID:{6}'.\
format(ag['agent_id'], ag['agent_name'], thousandSeparator(amount),
thousandSeparator(prev_bal), thousandSeparator(balance),
comment, dm.last_id)
for prot in ('ym://b_martian','ym://inileonard', 'ym://sridwan981'):
bc.writeNotifyOut(prot, 'general_message', {'message': msg})
bc.dbconn.commit()
result.update({
'success': 1,
'message': 'SUCCESS',
'balance': balance,
'mutation_id': dm.last_id,
})
return json.dumps(result)
def transaction_success(self, tran_id, pin):
bc = AgentNotifier()
c = bc.dbconn.cursor(MySQLdb.cursors.DictCursor)
c.execute('''SELECT SQL_NO_CACHE `reg_protocol`,`product_id`,`msisdn_destination`,
`agent_id`,`base_price`,`sell_price`,`status`,`order`,`deposit`,`type`
FROM `transaction` where `transaction_id`=%s''',
(tran_id,))
r = c.fetchone()
if not r:
return json.dumps({'success': 0, 'reason': 'RECORD NOT FOUND'})
if int(r['status']) == const.TR_RETRIED or \
int(r['status']) == const.TR_EXECUTED or \
int(r['status']) > const.TR_FAILED_GENERAL_REV:
return json.dumps({'success': 0, 'reason': 'CANNOT SET STATUS'})
if int(r['status']) >= const.TR_FAILED_HLR_REV and \
int(r['status']) <= const.TR_FAILED_GENERAL_REV :
dm = DepositMutation(20, bc.dbconn, bc.cacheconn)
dm.debit(r['agent_id'], r['sell_price'], 'Manual success {0}'.\
format(tran_id))
c_agent_price = DBCache(const.AGENTPRICE_PREFIX, config.DEFAULT_EXPIRE, const.AGENTPRICE_SQL)
owner = '{0:0>{1}}'.format(1, config.AGENT_ID_LENGTH)
try:
if r['agent_id'] != owner:
fl = getFrontline(bc.dbconn, bc.cacheconn, r['agent_id'])
if not fl:
self.logger.error('<countProfit> Frontline for agent {0} not found'.format(r['agent_id']))
raise
else:
fl = r['agent_id']
ag = c_agent_price.sGet((fl, r['product_id'],))
if not ag:
self.logger.error('<countProfit> Price for agent {0} not found'.format(r['agent_id']))
raise
profit = int(ag['sell_price']) - int(r['base_price'])
except:
profit = 0
c.execute('''UPDATE `transaction` SET `status`=%s,`profit`=%s
WHERE `transaction_id`=%s''',
(const.TR_EXECUTED, profit, tran_id,))
r['references'] = '0'
bc.notifyTopupSucess(r)
bc.dbconn.commit()
return json.dumps({'success': 1, 'reason': 'SUCCESS'})
def test_1(self):
bc = AgentNotifier()
tr = {
'product_id': 'HS10',
'order': 1,
'msisdn_destination': '08128989888',
'references': '0123456789',
'deposit': 1000000000,
'sell_price': 10750,
'agent_id': '88888',
}
msg = bc.buildMessage('transaction_successful',
bc.buildSubTopupSucess(tr))
return json.dumps({
'reqid': 'xxx',
'status': 1,
'message': msg,
'timestamp': datetime.now().strftime('%y%m%d%H%M%S'),
})
def transaction_fail(self, tran_id, pin):
bc = AgentNotifier()
c = bc.dbconn.cursor(MySQLdb.cursors.DictCursor)
c.execute('''SELECT SQL_NO_CACHE `reg_protocol`,`product_id`,`msisdn_destination`,
`agent_id`,`sell_price`,`status`,`order`,`deposit`,`type`
FROM `transaction` where `transaction_id`=%s''',
(tran_id,))
r = c.fetchone()
if not r:
return json.dumps({'success': 0, 'reason': 'RECORD NOT FOUND'})
if int(r['status']) < const.TR_AUTHORIZED or \
int(r['status']) >= const.TR_RETRIED:
return json.dumps({'success': 0, 'reason': 'CANNOT SET STATUS'})
dm = DepositMutation(20, bc.dbconn, bc.cacheconn)
dm.credit(r['agent_id'], r['sell_price'], 'reversal Transaction {0}'.\
format(tran_id))
c.execute('UPDATE `transaction` set `status`=%s where `transaction_id`=%s',
(const.TR_FAILED_GENERAL_REV, tran_id,))
# r['deposit'] = int(r['deposit']) + int(r['sell_price'])
bc.notifyTopupFail(r, False)
bc.dbconn.commit()
return json.dumps({'success': 1, 'reason': 'SUCCESS'})
def stock_check(self, dev_id, pin):
bc = AgentNotifier()
dev = self.c_dev.get(bc.dbconn, bc.cacheconn, dev_id)
if not dev:
return json.dumps({'success': 0, 'reason': 'DEVICE NOT FOUND'})
c = bc.dbconn.cursor(MySQLdb.cursors.DictCursor)
c.execute('''SELECT `check_stock_counter` from `devices` WHERE
`device_id`=%s LIMIT 1''', (dev_id,))
old_count = int(c.fetchone()['check_stock_counter'])
c.execute('''SELECT `stock_check_1`,`stock_check_2` from `operator`
WHERE `operator_id`=%s''', (dev['operator_id'],))
r = c.fetchone()
server_id, port = dev_id.split('.')
leaf_server = '{0}@{2}/{1}'.format(config.LEAFSERVER, server_id,
config.MSG_SERVER)
parse = multipleReplace({'<pin>': dev['pin'],}, r['stock_check_1'])
msg = '{0},{1},{2}'.format(port, '0', parse)
bc.sendMessage(leaf_server, 'JBDV', msg, commit=False)
if len(r['stock_check_2']) > 0:
parse = multipleReplace({'<pin>': dev['pin'],}, r['stock_check_2'])
msg = '{0}.{1},{2},{3}'.format(server_id, port, '0', parse)
bc.sendMessage(leaf_server, 'JBDV', msg, commit=False)
bc.dbconn.commit()
to = datetime.now() + timedelta(seconds=59)
tout = True
while datetime.now() < to:
time.sleep(0.5)
c.execute('''SELECT `check_stock_counter` from `devices` WHERE
`device_id`=%s LIMIT 1''', (dev_id,))
new_count = int(c.fetchone()['check_stock_counter'])
if old_count < new_count:
tout = False
break
if tout:
return json.dumps({'success': 0, 'reason': 'TIMEOUT'})
return json.dumps({'success': 1, 'reason': '', 'notifyid': new_count,})
def device_reconnect(self, device_id, pin):
bc = AgentNotifier()
server_id, _, port = device_id.partition('.')
bc.sendMessage('{0}@{1}/{2}'.format(config.LEAFSERVER,
config.MSG_SERVER, server_id), 'RCMD', '{0},1'.format(port))
return json.dumps({'success': 1,})
def sendSMS(self, msisdn, msg=''):
bc = AgentNotifier()
bc.writeNotifyOut('sms://{0}'.format(msisdn), 'transaction_successful',
{})
return json.dumps({'success': 1, 'reason': 'SUCCESS'})
def leaf_stop(self, server_id, pin):
bc = AgentNotifier()
bc.sendMessage('{0}@{1}/{2}'.format(config.LEAFSERVER,
config.MSG_SERVER, server_id), 'LSTO', '*')
return json.dumps({'success': 1,})
