Example #1
0
 def packages(self, request):
     api_log.debug('%s - [GET] %s/packages',
                   request.getHost().host, self.path)
     try:
         config = Configuration()
         data = json.dumps(config.get_packages(), cls=PGEncoder)
     except ConfigurationException as e:
         data = {'status': 'failed', 'error': str(e)}
     api_log.debug(data)
     return data
Example #2
0
 def site(self, request):
     api_log.debug('%s - [GET] %s/site', request.getHost().host, self.path)
     try:
         config = Configuration()
         data = json.dumps(config.get_site(), cls=PGEncoder)
     except ConfigurationException as e:
         data = {'status': 'failed', 'error': str(e)}
     except psycopg2.InterfaceError as e:
         if str(e) == "connection already closed":
             api_log.debug("Exiting due to DB Error: %s", e)
             os._exit(-1)
     api_log.debug(data)
     return data
Example #3
0
    def bill(self, session, subscriber, destination_number, context, duration):
        if context == 'LOCAL':
            bill_log.info(
                '==========================================================================='
            )
            bill_log.info('LOCAL Context')
            bleg_connected = session.getVariable('bleg_uuid')
            hangup_cause = session.getVariable('hangup_cause')
            #subscriber = session.getVariable('bleg_destination_number')
            #print session.getVariable('bleg_billsec')

            configuration = Configuration()
            try:
                _charge_local = configuration.check_charge_local_calls()
                if _charge_local == 1:
                    _charge = configuration.get_charge_local_calls()
                    if duration > int(_charge[1]):
                        call_cost = _charge[0]
                    else:
                        call_cost = 0
                else:
                    return
            except:
                bill_log.error('Error reading local calls charge config.')
                return

            # set destination_name and cost for the CDR
            session.setVariable('destination_name', 'Local')
            session.setVariable('cost', str(call_cost))
            bill_log.info('Call duration: %d sec Call cost: %.2f' %
                          (duration, call_cost))

            if call_cost > Decimal('0.00'):
                sub = Subscriber()
                try:
                    previous_balance = sub.get_balance(subscriber)
                    current_balance = previous_balance - call_cost
                    real_balance = 0 if current_balance < 0 else current_balance
                    bill_log.info(
                        'Previous balance: %.2f Current Balance: %.2f' %
                        (previous_balance, real_balance))
                    sub.set_balance(subscriber, real_balance)
                    bill_log.info('Billing %s completed successfully' %
                                  subscriber)
                except SubscriberException as e:
                    bill_log.error('Error during billing the subscriber: %s' %
                                   e)
            else:
                bill_log.info('Call too short to Bill')

        if context == 'OUTBOUND':
            bill_log.info(
                '==========================================================================='
            )
            bill_log.info(
                'OUTBOUND Context Bill subscriber %s destination %s' %
                (subscriber, destination_number))

            sub = Subscriber()
            # get rate
            rate = self.get_rate(destination_number)
            log_dest = rate[1]
            package = sub.get_package(subscriber)
            if package == 1 and rate[1] == "Mexico Cellular-Telcel":
                bill_log.info(
                    'Subscriber has package, removing 5 mins from call duration of %s seconds',
                    duration)
                log_dest = rate[1] + ' (P)'
                duration = duration - 300
                if duration < 0:
                    duration = 0
            if 'charge_outbound_rate_type' in globals(
            ) and charge_outbound_rate_type == 'sec':
                call_cost = Decimal(
                    math.ceil((rate[3] / 60) * duration * 100) / 100).quantize(
                        Decimal('0.01'))
            else:
                call_cost = self.get_call_cost(duration, rate[3])

            try:
                previous_balance = sub.get_balance(subscriber)
                current_balance = previous_balance - call_cost
                if current_balance < 0:
                    # There was not enough balance to cover the rounded up minutes
                    real_balance = 0
                    # Log what we ACTUALLY deducted in the CDR
                    call_cost = previous_balance
                else:
                    real_balance = current_balance
                bill_log.info('Previous balance: %.2f Current Balance: %.2f' %
                              (previous_balance, real_balance))
                sub.set_balance(subscriber, real_balance)
                bill_log.info('Billing %s completed successfully' % subscriber)
            except SubscriberException as e:
                bill_log.error('Error during billing the subscriber: %s' % e)

            # set destination_name and cost for the CDR
            session.setVariable('destination_name', log_dest)
            session.setVariable('cost', str(call_cost))
            bill_log.info('Call duration: %d sec Call cost: %.2f' %
                          (duration, call_cost))

        if context == 'INBOUND':
            bill_log.info(
                '==========================================================================='
            )
            bill_log.info('INBOUND Context')
            bleg_connected = session.getVariable('bleg_uuid')
            hangup_cause = session.getVariable('hangup_cause')
            subscriber = session.getVariable('bleg_destination_number')
            #print session.getVariable('bleg_billsec')
            configuration = Configuration()

            if (bleg_connected != '' and bleg_connected != None
                ) and hangup_cause == 'NORMAL_CLEARING':
                bill_log.info('Call B-leg was connected. Bill subscriber %s' %
                              subscriber)
                try:
                    charge_info = configuration.get_charge_inbound_calls()
                    if charge_info[1] == 'call':
                        bill_log.info('Charge type: per call, Cost: %s' %
                                      charge_info[0])
                        call_cost = charge_info[0]
                        try:
                            sub = Subscriber()
                            previous_balance = sub.get_balance(subscriber)
                            current_balance = previous_balance - call_cost
                            bill_log.info(
                                'Previous balance: %.2f Current Balance: %.2f'
                                % (previous_balance, current_balance))
                            sub.set_balance(subscriber, current_balance)
                            bill_log.info('Billing %s completed successfully' %
                                          subscriber)
                        except SubscriberException as e:
                            bill_log.error(
                                'Error during billing the subscriber: %s' % e)
                    elif charge_info[1] == 'min':
                        bill_log.info(
                            'Charge type rate per min, cost per min: %s' %
                            charge_info[0])
                        # BUG: Cannot get b-leg billsec from FS. Use the billsec of a-leg instead
                        call_cost = self.get_call_cost(duration,
                                                       charge_info[0])
                        bill_log.info('Call duration %s sec Call cost: %s' %
                                      (duration, call_cost))
                        try:
                            sub = Subscriber()
                            previous_balance = sub.get_balance(subscriber)
                            current_balance = previous_balance - call_cost
                            bill_log.info(
                                'Previous balance: %.2f Current Balance: %.2f'
                                % (previous_balance, current_balance))
                            sub.set_balance(subscriber, current_balance)
                            bill_log.info('Billing %s completed successfully' %
                                          subscriber)
                        except SubscriberException as e:
                            bill_log.error(
                                'Error during billing the subscriber: %s' % e)
                except ConfigurationException as e:
                    bill_log.error(e)
            else:
                bill_log.info(
                    'Call B-leg was not connected. Not billing subscriber %s' %
                    subscriber)
Example #4
0
#!/usr/bin/env python
from pyrogram import Client
from modules.configuration import Configuration
from modules.sms import GetSMSCode
from time import sleep

cfg_obj = Configuration()
config = cfg_obj.load()
sms = GetSMSCode(config)


def phone_code_callback(mobile_number):
    sleep(30)
    code = sms.get_code(mobile_number)
    return code


def main():
    mobile_number = sms.get_mobile_number()
    # Get current account balance before signup
    print(sms.account_info)
    try:
        app = Client(session_name=mobile_number,
                     phone_number=mobile_number,
                     phone_code=phone_code_callback,
                     first_name="John",
                     last_name="Doe")

        with app:
            print(app.get_me())