コード例 #1
0
ファイル: parrots.py プロジェクト: dperezrada/payparrot
def parrots_finish(db):
    if request.query.denied:
        redirect('/twitter_denied.html')
    session = Sessions.findOne(db, {'oauth_token': request.query.oauth_token})
    if session:
        account = Accounts.findOne(db, session.account_id)
        if not account:
            response.status = 404
            return {'error': 'Invalid token'}
        twitter = Twitter()
        try:
            access_tokens = twitter.get_access_tokens(request.query.oauth_verifier,{'oauth_token': session.oauth_token, 'oauth_token_secret': session.oauth_token_secret})
            twitter.create_client(access_tokens.get('oauth_token'),access_tokens.get('oauth_token_secret'))
            headers, body = twitter.get('https://api.twitter.com/1/account/verify_credentials.json')
        except:
            redirect('/twitter_auth_problem.html')
            return
        if headers.status == 200:
            body = json.loads(body)
            parrot = Parrots.findOne(db, {'twitter_id': body.get('id')})
            if not parrot:
                new_parrot = Parrots(db, {
                    'twitter_info': body,
                    'twitter_id': body.get('id'),
                    'oauth_token': access_tokens.get('oauth_token'),
                    'oauth_token_secret': access_tokens.get('oauth_token_secret')
                })
                new_parrot.insert()
                parrot = new_parrot
            else:
                parrot.update({
                    'oauth_token': access_tokens.get('oauth_token'),
                    'oauth_token_secret': access_tokens.get('oauth_token_secret')
                })
            subscription = Subscriptions.findOne(db, {'account_id': account.id, 'parrot_id': parrot.id})
            subscription_parameters = {
                'parrot_id': parrot.id,
                'account_id': account.id,
                'active': True,
                'external_id': session.external_id,
                'twitter_screen_name': body.get("screen_name")
            }
            if not subscription:
                subscription = Subscriptions(db, subscription_parameters)
                subscription.insert()
            else:
                subscription.update(subscription_parameters)
            notification_id = _create_notification(db, account, parrot, subscription)
            if notification_id:
                redirect_url = generate_redirect_url(account.callback_url, session.external_id, subscription.id, notification_id)
                redirect(redirect_url)
    else:
        response.status = 404
        return {'error': 'Expired token'}
コード例 #2
0
ファイル: cron2.py プロジェクト: dperezrada/payparrot
def process_payment(db, raw_message, payment_message):
    parrot = Parrots.findOne(db, {'_id': ObjectId(payment_message.get('parrot_id'))})
    if parrot:
        message = get_message_to_share(db, payment_message)
        twitter_json = tweet_message(parrot, message, raw_message.id)
        payment = store_payment(db, twitter_json, payment_message, message, raw_message)
        if payment.success:
            if Queue.delete_message('payments', raw_message):
                log('cron2', 'Payments succeded', payment_message.get('subscription_id'))
                send_notification(db, payment, 'payment_success')
                log('cron2', 'Notification sent', payment_message.get('subscription_id'))
                create_next_payment(db, payment)
                log('cron2', 'Next payment created', payment_message.get('subscription_id'))
                add_payment_to_parrot(db, parrot, payment_message, twitter_json)
            else:
                log('cron2', 'ERROR: Couldnt delete message', payment_message.get('subscription_id'))
        else:
            total_payments_attempts = Payments.find(db, {'message_id_sqs': raw_message.id}).count()
            subscription = Subscriptions.findOne(db, {'account_id': payment.account_id, 'parrot_id': payment.parrot_id})
            if subscription:
                if total_payments_attempts > 3:
                    log('cron2', 'Too many payments attempts', payment_message.get('subscription_id'))
                    subscription.update({'active': False})
                    if Queue.delete_message('payments', raw_message):
                        send_notification(db, payment,'subscription_deactivated')
                    else:
                        log('cron2', 'ERROR: Couldnt delete message', payment_message.get('subscription_id'))
                else:
                    log('cron2', 'Attempt %s' % total_payments_attempts, payment_message.get('subscription_id'))
コード例 #3
0
    def test_crons(self):
        from payparrot_scripts.crons.cron1 import main as cron1
        cron1()
        
        from payparrot_scripts.crons.cron2 import main as cron2
        cron2()
        
        sleep(2)

        parrot = Parrots.findOne(self.db, {})
        
        twitter = Twitter()
        twitter.create_client(parrot.oauth_token, parrot.oauth_token_secret)
        headers, body = twitter.get("http://api.twitter.com/1/statuses/user_timeline.json?user_id=%s&include_rts=false&count=1" % parrot.twitter_info.get('screen_name'))
        json_twitter_status = json.loads(body)

        message_start = self.message.text
        received_message = json_twitter_status[0].get('text')
        self.assertEqual(self.message.text, received_message[0:len(message_start)])

        queue = Queue.get_queue('payments')
        self.assertEqual(0, queue.count())

        from payparrot_scripts.crons.cron3 import main as cron3
        cron3()

        raw_input("Check? ")

        
コード例 #4
0
ファイル: parrots.py プロジェクト: dperezrada/payparrot
def get_valid_parrot(db, account_id, parrot_id):
    account = Accounts.findOne(db,account_id)
    if account:
        subscription = Subscriptions.findOne(db, {'parrot_id': ObjectId(parrot_id), 'account_id': ObjectId(account_id)})
        if subscription:
            parrot = Parrots.findOne(db, parrot_id)
            if parrot:
                return parrot
コード例 #5
0
ファイル: test_cron4.py プロジェクト: dperezrada/payparrot
    def test_cron4_no_subscription(self):
        account = Accounts(self.db, {
            'email': '*****@*****.**',
            'password': '******',
            'name': 'Daniel',
            'startup': 'Payparrot',
            'url': 'http://payparrot.com/',
            'callback_url': 'http://www.epistemonikos.org',
            'notification_url': 'http://www.epistemonikos.org',
        })
        account.insert()
        parrot = Parrots(self.db, {
            'twitter_id': '123123123',
            'oauth_token': 'asd',
            'oauth_token_secret': 'asdf',
            'twitter_info': {},
            'payments': [],
            'twitter_info': {
                'screen_name': 'danielgua'
            }
        })
        parrot.insert()
        subscription = Subscriptions(self.db, {'account_id': account.id, 'active': False, 'parrot_id': parrot.id, 'twitter_screen_name': parrot.twitter_info.get("screen_name")})
        subscription.insert()

        last_date = datetime.now();
        next_action_date = last_date;
        next_payment = NextPayments(self.db, {
            'account_id': account.id,
            'parrot_id': parrot.id,
            'action_date': next_action_date
        });
        next_payment.insert()


        from payparrot_scripts.crons.cron4 import main as cron4
        cron4()

        message = Queue.get_message('payments')
        self.assertFalse(message)

        self.assertEqual(0, self.db.next_payments.find({'_id': next_payment.id}).count())
コード例 #6
0
ファイル: test_parrots.py プロジェクト: dperezrada/payparrot
 def setUp(self):
     self.app = pp_tests.get_app()
     self.connection, self.db = pp_tests.connect_to_mongo()
     self.account = pp_tests.create_account_and_login(self.app, self.db, {
         'email': '*****@*****.**',
         'password': '******',
         'name': 'Daniel',
         'startup': 'Payparrot',
         'url': 'http://payparrot.com/',
         'callback_url': 'http://www.epistemonikos.org',
         'notification_url': 'http://www.epistemonikos.org',
     })
     self.parrot = Parrots(self.db, {
         'twitter_id': '123123123',
         'oauth_token': 'asd',
         'oauth_token_secret': 'asdf',
         'twitter_info': {},
         'payments': [],
         'twitter_info': {
             'screen_name': 'danielgua'
         }
     })
     self.parrot.insert()
     self.subscription = Subscriptions(self.db, {'account_id': self.account.id, 'active': True, 'parrot_id': self.parrot.id, 'twitter_screen_name': self.parrot.twitter_info.get("screen_name")})
     self.subscription.insert()
         
     self.parrot1 = Parrots(self.db, {
         'twitter_id': '4322143214',
         'oauth_token': 'asd',
         'oauth_token_secret': 'asdf',
         'twitter_info': {},
         'payments': [],
         'twitter_info': {
             'screen_name': 'blabla'
         }
     })
     self.parrot1.insert()
     self.subscription1 = Subscriptions(self.db, {'account_id': self.account.id, 'active': True, 'parrot_id': self.parrot1.id,'twitter_screen_name': self.parrot1.twitter_info.get("screen_name")})        
     self.subscription1.insert()
コード例 #7
0
ファイル: parrots.py プロジェクト: dperezrada/payparrot
def get_parrots(account_id, db, secure = True):
    querystring = request.query;
    from_ = querystring.get("from")
    to_ = querystring.get("to")
    skip = int(querystring.get('skip', 0))
    limit = int(querystring.get('limit', 0))
    query_subscriptions = {'account_id': ObjectId(account_id), 'active': True}
    if from_ or to_:
        query_subscriptions['created_at'] = {}
    if from_:
        query_subscriptions['created_at']['$gte'] = datetime.strptime(from_, '%Y-%m-%d')
    if to_:
        query_subscriptions['created_at']['$lte'] = datetime.strptime(to_, '%Y-%m-%d')
    if querystring.screen_name:
        screen_name_regex = re.compile(querystring.screen_name,re.IGNORECASE)
        query_subscriptions['twitter_screen_name'] = screen_name_regex
    parrots_from_subscriptions = Subscriptions.find(db, query_subscriptions, {'parrot_id': True, '_id': False}).skip(skip).limit(limit).sort([('_id', -1)])
    parrots_id = map(lambda x: x.get('parrot_id'), parrots_from_subscriptions)
    parrots = list(Parrots.find(db, {'_id': {'$in': parrots_id}}))
    for parrot in parrots:
        parrot['payments'] = filter(lambda x: x.get('account_id') == account_id, parrot.get('payments'))
    # TODO: fix this
    response.headers['Content-type'] = 'application/json'
    return json.dumps(map(lambda x: Parrots.toJSON(x), parrots))
コード例 #8
0
ファイル: test_parrots.py プロジェクト: dperezrada/payparrot
class TestParrots(unittest.TestCase):
    def setUp(self):
        self.app = pp_tests.get_app()
        self.connection, self.db = pp_tests.connect_to_mongo()
        self.account = pp_tests.create_account_and_login(self.app, self.db, {
            'email': '*****@*****.**',
            'password': '******',
            'name': 'Daniel',
            'startup': 'Payparrot',
            'url': 'http://payparrot.com/',
            'callback_url': 'http://www.epistemonikos.org',
            'notification_url': 'http://www.epistemonikos.org',
        })
        self.parrot = Parrots(self.db, {
            'twitter_id': '123123123',
            'oauth_token': 'asd',
            'oauth_token_secret': 'asdf',
            'twitter_info': {},
            'payments': [],
            'twitter_info': {
                'screen_name': 'danielgua'
            }
        })
        self.parrot.insert()
        self.subscription = Subscriptions(self.db, {'account_id': self.account.id, 'active': True, 'parrot_id': self.parrot.id, 'twitter_screen_name': self.parrot.twitter_info.get("screen_name")})
        self.subscription.insert()
            
        self.parrot1 = Parrots(self.db, {
            'twitter_id': '4322143214',
            'oauth_token': 'asd',
            'oauth_token_secret': 'asdf',
            'twitter_info': {},
            'payments': [],
            'twitter_info': {
                'screen_name': 'blabla'
            }
        })
        self.parrot1.insert()
        self.subscription1 = Subscriptions(self.db, {'account_id': self.account.id, 'active': True, 'parrot_id': self.parrot1.id,'twitter_screen_name': self.parrot1.twitter_info.get("screen_name")})        
        self.subscription1.insert()

    def tearDown(self):
        pp_tests.tear_down(self.db, self.app)
        self.connection.close()

    def test_invalid_token(self):
        response = self.app.get('/parrots/finish?oauth_token=lala', status = 404)
        self.assertEqual({'error': 'Expired token'}, response.json)

    def test_get_one_parrot_status(self):
        response = self.app.get('/accounts/%s/parrots/%s' % (self.account.id, self.parrot.id))
        self.assertEqual(200, response.status_int)
        self.assertEqual(self.parrot.JSON(), response.json)

    def test_delete_one_parrot(self):
        response = self.app.delete('/accounts/%s/parrots/%s' % (str(self.account.id), str(self.parrot.id)))
        self.assertEqual(204, response.status_int)
        self.app.get('/accounts/%s/parrots/%s' % (self.account.id, self.parrot.id), status=404)
    
    def test_get_parrots_with_date_filter(self):
        one_day = timedelta(days=1)
        from_ = datetime.now()-one_day*7
        from_text = str(from_)
        to_ = datetime.now() - one_day
        to_text = str(to_)
        #Hack to change date
        self.db.subscriptions.update({'parrot_id': self.parrot1.id},{'$set': {'created_at': from_+one_day*5}})
        response = self.app.get('/accounts/%s/parrots?from=%s&to=%s' % (self.account.id, from_text.split(" ")[0], to_text.split(" ")[0]))
        self.assertEqual(200, response.status_int)
        self.assertEqual(1, len(response.json))
        self.assertEqual(str(self.parrot1.id), response.json[0]['id'])

    def test_get_parrots_by_screen_name(self):
        response = self.app.get('/accounts/%s/parrots?screen_name=%s' % (self.account.id, 'danielgua'))
        self.assertEqual(200, response.status_int)
        self.assertEqual(1, len(response.json))
        # self.assertEqual(str(self.parrot1.id), response.json[0]['id'])