Ejemplo n.º 1
0
 def getAgent(self, bc, prot, userid, passwd):
     ma = ManageAgent(bc.dbconn, bc.cacheconn)
     if ma.resolveProtocol(prot) != userid:
         return False
     x = ma.verifyAgent(userid, passwd)
     if x['code'] == agent.AGST_FOUND:
         return x['agent']
     return False
Ejemplo n.º 2
0
 def web_trx(self, agent_id, product, msisdn, pin):
     bc = AgentNotifier()
     ma = ManageAgent(bc.dbconn, bc.cacheconn)
     hlrmap = HLRMap(bc.dbconn, bc.cacheconn)
     x = ma.verifyAgent(agent_id, '1234', True, False)
     if x['code'] in (agent.AGST_NOTFOUND, agent.AGST_NOTACTIVE):
         return json.dumps({'success': 0, 'reason': 'Agent not registered / not active'})
     prod_c = DBCache(const.PRODUCT_PREFIX, config.DEFAULT_EXPIRE,
                          const.PRODUCT_SQL)
     prod = prod_c.get(bc.dbconn, bc.cacheconn, product)
     if not prod:
         return json.dumps({'success': 0, 'reason': 'Invalid product id'})
     msisdn = sanitizeMSISDN(msisdn)
     method = firstMethod(hlrmap, prod, msisdn)
     tran_id = self.topup(bc, x['agent'], msisdn, prod, method)
     return json.dumps({'success': 1, 'reason': '', 'tranid': tran_id})
Ejemplo n.º 3
0
 def __init__(self):
     super(TopupParser, self).__init__('UNKN', 'INVL', 'TopupParser')
     self.agent_manager = ManageAgent(self.dbconn, self.cacheconn)
     self.dm = DepositMutation(5, self.dbconn, self.cacheconn)
     self.um = UnitMutation(5, self.dbconn, self.cacheconn)
     self.hlrmap = HLRMap(self.dbconn, self.cacheconn)
     cdf = config.DEFAULT_EXPIRE
     self.c_product = DBCache(const.PRODUCT_PREFIX, cdf, const.PRODUCT_SQL)
     self.c_price = DBCache(const.AGENTPRICE_PREFIX, cdf, const.AGENTPRICE_SQL)
     self.c_operator = DBCache(const.OPERATOR_PREFIX, cdf, const.OPERATOR_SQL,
                               user_func={'prefix': lambda x: x.split(',')})
     map(lambda x: x.setConn(self.dbconn, self.cacheconn), [
             self.c_product,
             self.c_price,
             self.c_operator,
         ])
     self.rx_check, self.rx_topup, self.rx_separator = (None, None, None)
     self._init2()
     self.log = mylogger('TopupParser', 'topupparser.log')
     self.to_db = []
     self.parsed = []
     self.handler = [
             self.check,
         ]
     self.processUNKN = self.process
Ejemplo n.º 4
0
 def bnisms(self):
     if cherrypy.request.remote.ip not in self.auth_ip:
         print 'UNAUTH IP {0}'.format(cherrypy.request.remote.ip)
         return
     bc = BaseComponent()
     ma = ManageAgent(bc.dbconn, bc.cacheconn)
     try:
         # if 'xml' not in cherrypy.request.headers['content-type']:
             # return 'Content is not XML'
         x = cherrypy.request.body.read()
         print x
         dom1 = parseString(x)
     except:
         return 'Unable to parse XML document'
     cherrypy.response.headers['content-type'] = 'text/xml; charset=\"UTF-8\"'
     berita = self.getText(dom1, 'berita')
     trxid = self.getText(dom1, 'trxid')
     try:
         amount = int(self.getText(dom1, 'amount'))
     except:
         amount = 0
     product = self.getText(dom1, 'product')
     msisdn = self.getText(dom1, 'msisdn')
     status = '999'
     top_element = 'response_trx'
     message = berita
     ag = None
     product = product.upper()
     if product in self.prod_list:
         status = '00'
         amount = self.prod_list[product]
     elif product not in self.prod_list and product != 'ALL':
         status = '08'
     elif berita.upper() == 'CEKMSISDN':
         top_element = 'response_alert'
         ag = ma.resolveProtocol('sms://{0}'.format(msisdn))
         if not ag:
             status = '07'
         else:
             status = '00'
             message = msisdn
     else:
         ag = ma.resolveProtocol('sms://{0}'.format(msisdn))
         if not ag:
             status = '07'
         elif amount == 0:
             status = '05'
         else:
             r = self._callAdminHelper('depmut_execute', {
                     'agent_id': ag,
                     'type': 'C',
                     'amount': int(amount),
                     'comment': 'BNI SMS',
                 })
             if r['success'] == 1:
                 status = '00'
             else:
                 status = '05'
         sql = '''INSERT INTO `agent_deposit` (`mutation_id`,`timestamp`,
                  `agent_id`,`mutation`,`type`,`deposit_balance`,`source`,
                  `comment`) VALUES (%s,%s,%s,%s,%s,%s,%s,%s)'''
         c = bc.dbconn.cursor(MySQLdb.cursors.DictCursor)
         c.execute(sql, (r['mutation_id'], datetime.now(), ag,
                   int(amount), 'C', r['balance'], 'BNI-NARINDO','SMS'))
         bc.dbconn.commit()
         c.close()
     doc = self.createXML({
         'trxid': trxid,
         'receiptcode': datetime.today().strftime('%H%M%S'),
         'msisdn': msisdn,
         'amount': amount,
         'product': product,
         'msg': message,
         'status': status,
     }, top_element)
     result = doc.toxml()
     print result
     bc.dbconn.close();
     return result
Ejemplo n.º 5
0
 def __init__(self, name='XX'):
     super(AgentNotifier, self).__init__(name)
     self.am = ManageAgent(self.dbconn, self.cacheconn)
Ejemplo n.º 6
0
class AgentNotifier(BaseComponent):
    '''Class focusing on notifying agent'''
    def __init__(self, name='XX'):
        super(AgentNotifier, self).__init__(name)
        self.am = ManageAgent(self.dbconn, self.cacheconn)
    
    def productIdAndOrder(self, prod_id, order):
        '''Returns product_id.order only if order > 1'''
        if int(order) > 1:
            return '{0}.{1}'.format(prod_id, order)
        else:
            return prod_id
    
    def buildSubTopupSucess(self, param):
        '''Build substitution dictionary for a
           "transaction_successful" message.
           Needed parameters:
                - agent_id
                - reg_protocol
                - product_id
                - order
                - msisdn_destination
                - references
                - deposit
                - sell_price
        '''
        if not isinstance(param, dict):
            return False
        to_sub = {}
        to_sub['product_id'] = self.productIdAndOrder(param['product_id'],
                                                      param['order'])
        to_sub['dest'] = param['msisdn_destination']
        to_sub['ref'] = param['references']
        to_sub['balance'] = thousandSeparator(param['deposit'])
        to_sub['price'] = thousandSeparator(param.get('sell_price', 0))
        to_sub['agent_id'] = param.get('agent_id', '')
        to_sub['name'] = self.am.getAgentData(param['agent_id'])['agent_name']
        to_sub['unit'] = param['product_id']
        return to_sub
    
    def notifyTopupSucess(self, param):
        '''Send a "transaction_successful" to an agent.
           Needed parameters:
                - agent_id
                - reg_protocol
                - product_id
                - order
                - msisdn_destination
                - references
                - deposit
                - sell_price
                - type
        '''
        t = param.get('type', 1)
        if t == 3:
            msg = 'transaction_successful_unit'
        else:
            msg = 'transaction_successful'
        self.writeNotifyOut(param['reg_protocol'], msg,
                            self.buildSubTopupSucess(param))
    
    def buildSubTopupFail(self, param, precompute):
        '''Build substitution dictionary for a "transaction_fail" message.
           Needed parameters:
                - reg_protocol
                - product_id
                - order
                - msisdn_destination
                - deposit
                - sell_price
                - type
        '''
        if not isinstance(param, dict):
            return False
        to_sub = {}
        to_sub['product_id'] = self.productIdAndOrder(param['product_id'],
                                                      param['order'])
        to_sub['dest'] = param['msisdn_destination']
        to_sub['unit'] = param['product_id']
        if precompute:
            to_sub['balance'] = thousandSeparator(param['deposit'])
        else:
            t = param.get('type', 1)
            if t == 3:
                to_sub['balance'] = int(param['deposit']) + 1
            else:
                to_sub['balance'] = int(param['deposit']) + int(param['sell_price'])
        return to_sub

    def notifyTopupFail(self, param, precompute=True):
        '''Send a "transaction_fail" to an agent.
           Needed parameters:
                - reg_protocol
                - product_id
                - order
                - msisdn_destination
                - deposit
                - sell_price
                - type
        '''
        t = param.get('type', 1)
        if t == 3:
            msg = 'transaction_fail_unit'
        else:
            msg = 'transaction_fail'
        self.writeNotifyOut(param['reg_protocol'], msg,
                            self.buildSubTopupFail(param, precompute))
Ejemplo n.º 7
0
class TopupParser(ProcessNotifyIn):
    def __init__(self):
        super(TopupParser, self).__init__('UNKN', 'INVL', 'TopupParser')
        self.agent_manager = ManageAgent(self.dbconn, self.cacheconn)
        self.dm = DepositMutation(5, self.dbconn, self.cacheconn)
        self.um = UnitMutation(5, self.dbconn, self.cacheconn)
        self.hlrmap = HLRMap(self.dbconn, self.cacheconn)
        cdf = config.DEFAULT_EXPIRE
        self.c_product = DBCache(const.PRODUCT_PREFIX, cdf, const.PRODUCT_SQL)
        self.c_price = DBCache(const.AGENTPRICE_PREFIX, cdf, const.AGENTPRICE_SQL)
        self.c_operator = DBCache(const.OPERATOR_PREFIX, cdf, const.OPERATOR_SQL,
                                  user_func={'prefix': lambda x: x.split(',')})
        map(lambda x: x.setConn(self.dbconn, self.cacheconn), [
                self.c_product,
                self.c_price,
                self.c_operator,
            ])
        self.rx_check, self.rx_topup, self.rx_separator = (None, None, None)
        self._init2()
        self.log = mylogger('TopupParser', 'topupparser.log')
        self.to_db = []
        self.parsed = []
        self.handler = [
                self.check,
            ]
        self.processUNKN = self.process
    
    def _init2(self):
        c = self.dbconn.cursor(MySQLdb.cursors.DictCursor)
        c.execute('SELECT `regex`,`separator` from `parse` where `name`=' \
                  '"topup" LIMIT 1')
        tmp = c.fetchone()
        self.rx_topup, self.rx_separator = tmp['regex'], tmp['separator']
        c.execute('SELECT `regex` from `parse` where `name`=' \
                  '"initial_check" LIMIT 1')
        tmp = c.fetchone()
        self.rx_check = tmp['regex']
        c.close()
    
    def check(self, r, tmp):
        def timeDifference(t):
            tmp = datetime.now() - datetime.strptime(t, '%y/%m/%d %H:%M:%S')
            if tmp.days >= 0:
                return tmp.seconds
            else:
                return -tmp.seconds
        
        parse_obj = re.match(self.rx_check, r['parameters'], re.IGNORECASE)
        if not parse_obj:
            return True
        parse_result = parse_obj.groupdict()
        if timeDifference(parse_result['time_sent']) > \
                    config.REQUEST_VALID_PERIOD:
            raise Timeout(self, r, tmp)
        prot = parse_result['protocol']
        agent_id = self.agent_manager.resolveProtocol(prot)
        if not agent_id:
            self.writeNotifyOut(prot, 'agent_invalid')
            print 'AGST_NOTFOUND {0}'.format(prot)
            return True
        ag = self.agent_manager.verifyAgent(agent_id, 'xxxx')
        if ag['code'] == AGST_NOTFOUND or ag['code'] == AGST_NOTACTIVE:
            self.writeNotifyOut(prot, 'agent_invalid')
            print 'Reject non-active agent {0}'.format(agent_id)
            return True
        x = self.cmdList()
        _, _, _, _, msg = r['parameters'].split(',', 4)
        for c in x:
            cmd, _, _ = msg.partition(x[c])
            if cmd.upper() == c:
                raise UNMS(self, r, tmp)
        parse_obj = re.match(self.rx_topup, r['parameters'], re.IGNORECASE)
        if not parse_obj:
            raise UNMS(self, r, tmp)
        parse_result = parse_obj.groupdict()
        try:
            self._topup(r['id'], agent_id, parse_result)
        except Error, e:
            if e.msg == AGST_NOTFOUND:
                self.writeNotifyOut(prot, 'agent_invalid')
            elif e.msg == AGST_NOTACTIVE:
                self.writeNotifyOut(prot, 'agent_invalid')
            elif e.msg == AGST_WRONGPIN:
                self.writeNotifyOut(prot, 'wrong_pin')
            elif e.msg == WRONG_REQ_FORMAT:
                self.writeNotifyOut(prot, 'wrong_req_format')
        finally: