def tela_cliente(): txid = request.vars.getlist("txid") if not txid: return "Eh preciso informar uma transacao para usar essa funcao" from cloudant.account import Cloudant cloudantDB = "easypay" client = Cloudant("rcsousa", "F@b1m3u@m0r", account="rcsousa") client.connect() db = client[cloudantDB] doc = db[txid[0]] id = doc['_id'] item = doc['item'] quantidade = doc['quantidade'] valor = doc['valor'] timestamp = doc['timestamp'] figura = doc['figura'] result = { "id": id, "item": item, "quantidade": quantidade, "valor": valor, "timestamp": timestamp, "figura": figura } return dict(ordem=result, user=auth.user)
def test_cors_update_origins_none(self): """test updating the cors config""" resp = { "enable_cors": True, "allow_credentials": True, "origins": [] } mock_get = mock.Mock() mock_get.raise_for_status = mock.Mock() mock_get.json = mock.Mock() mock_get.json.return_value = { "enable_cors": True, "allow_credentials": True, "origins": ["https://example.com"] } self.mock_instance.get = mock.Mock() self.mock_instance.get.return_value = mock_get mock_put = mock.Mock() mock_put.raise_for_status = mock.Mock() mock_put.json = mock.Mock() mock_put.json.return_value = resp self.mock_instance.put.return_value = mock_put c = Cloudant(self.username, self.password, account=self.username) c.connect() cors = c.update_cors_configuration( enable_cors=True, allow_credentials=True ) self.assertEqual(cors, resp) self.assertTrue(self.mock_instance.get.called) self.assertTrue(self.mock_instance.put.called)
def test_requests_usage(self): with mock.patch( 'cloudant.account.Cloudant._usage_endpoint' ) as mock_usage: mock_usage.return_value = {'usage': 'mock'} c = Cloudant(self.username, self.password, account=self.username) c.connect() bill = c.requests_usage(2015, 12) self.assertEqual(bill, mock_usage.return_value)
def test_create_delete_methods(self): mock_resp = mock.Mock() mock_resp.json = mock.Mock() mock_resp.json.return_value = {} mock_resp.text = "mock response" mock_resp.status_code = 201 mock_del = mock.Mock() mock_del.status_code = 200 mock_get = mock.Mock() mock_get.status_code = 404 self.mock_instance.put.return_value = mock_resp self.mock_instance.delete.return_value = mock_del self.mock_instance.get.return_value = mock_get # instantiate and connect c = Cloudant(self.username, self.password) c.connect() self.failUnless(self.mock_session.called) # create db call c.create_database("unittest") self.mock_instance.get.assert_has_calls( mock.call('https://steve.cloudant.com/unittest') ) self.mock_instance.put.assert_has_calls( mock.call('https://steve.cloudant.com/unittest') ) # delete db call mock_get.reset_mocks() mock_get.status_code = 200 c.delete_database("unittest") self.mock_instance.get.assert_has_calls( mock.call('https://steve.cloudant.com/unittest') ) self.mock_instance.delete.assert_has_calls( mock.call('https://steve.cloudant.com/unittest') ) # create existing db fails mock_get.reset_mocks() mock_get.status_code = 200 self.assertRaises(CloudantException, c.create_database, "unittest") # delete non-existing db fails mock_get.reset_mocks() mock_get.status_code = 404 self.assertRaises(CloudantException, c.delete_database, "unittest")
def test_cors_configuration(self): """test getting cors config""" mock_resp = mock.Mock() mock_resp.raise_for_status = mock.Mock() mock_resp.json = mock.Mock() mock_resp.json.return_value = {'cors': 'blimey'} self.mock_instance.get = mock.Mock() self.mock_instance.get.return_value = mock_resp c = Cloudant(self.username, self.password, account=self.username) c.connect() cors = c.cors_configuration() self.assertEqual(cors, mock_resp.json.return_value) self.assertTrue(mock_resp.raise_for_status.called)
def test_generate_api_key(self): mock_resp = mock.Mock() mock_resp.raise_for_status = mock.Mock() mock_resp.json = mock.Mock() mock_resp.json.return_value = {'api': 'token'} self.mock_instance.post = mock.Mock() self.mock_instance.post.return_value = mock_resp c = Cloudant(self.username, self.password, account=self.username) c.connect() api_key = c.generate_api_key() self.assertEqual(api_key, {'api': 'token'}) self.assertTrue(mock_resp.raise_for_status.called)
def test_shared_databases(self): mock_resp = mock.Mock() mock_resp.raise_for_status = mock.Mock() mock_resp.json = mock.Mock() mock_resp.json.return_value = {'shared_databases': ['database1', 'database2']} self.mock_instance.get = mock.Mock() self.mock_instance.get.return_value = mock_resp c = Cloudant(self.username, self.password, account=self.username) c.connect() shared = c.shared_databases() self.assertEqual(shared, ['database1', 'database2']) self.assertTrue(mock_resp.raise_for_status.called)
def test_session_calls(self): """test session related methods""" c = Cloudant( self.username, self.password, url='https://steve.cloudant.com', x_cloudant_user=self.username ) c.connect() self.assertTrue(self.mock_session.called) self.assertEqual( self.mock_instance.auth, (self.username, self.password) ) self.assertEqual( self.mock_instance.headers['X-Cloudant-User'], self.username ) self.assertIsNotNone(self.mock_instance.headers['User-Agent']) self.assertEqual('COOKIE', c.session_cookie()) self.assertTrue(self.mock_instance.get.called) self.mock_instance.get.assert_has_calls( [ mock.call('https://steve.cloudant.com/_session') ] ) self.assertTrue(self.mock_instance.post.called) self.mock_instance.post.assert_has_calls( [ mock.call( 'https://steve.cloudant.com/_session', headers={'Content-Type': 'application/x-www-form-urlencoded'}, data={'password': '******', 'name': 'steve'} ) ] ) c.disconnect() self.assertTrue(self.mock_instance.delete.called) self.mock_instance.delete.assert_has_calls( [ mock.call('https://steve.cloudant.com/_session') ] )
def tela_cliente(): txid = request.vars.getlist("txid") if not txid: return "Eh preciso informar uma transacao para usar essa funcao" from cloudant.account import Cloudant cloudantDB = "easypay" client = Cloudant("rcsousa", "F@b1m3u@m0r", account="rcsousa") client.connect() db = client[cloudantDB] doc = db[txid[0]] id = doc['_id'] item = doc['item'] quantidade = doc['quantidade'] valor = doc['valor'] timestamp = doc['timestamp'] figura = doc['figura'] result = {"id": id, "item" : item, "quantidade" : quantidade, "valor" : valor, "timestamp" : timestamp, "figura" : figura} return dict(ordem=result, user=auth.user)
def setup_db(username, password, url): dbname = "spark_data" client = Cloudant(username, password, url=url) client.connect() # Perform client tasks... session = client.session() print 'Username: {0}'.format(session['userCtx']['name']) databases = client.all_dbs() db = client.create_database(dbname) print 'Databases: {0}'.format(client.all_dbs()) return db
def test_cors_disable(self): """test disabling cors""" resp = { "enable_cors": False, "allow_credentials": False, "origins": [] } mock_put = mock.Mock() mock_put.raise_for_status = mock.Mock() mock_put.json = mock.Mock() mock_put.json.return_value = resp self.mock_instance.put.return_value = mock_put c = Cloudant(self.username, self.password, account=self.username) c.connect() cors = c.disable_cors() self.assertEqual(cors, resp) self.assertTrue(self.mock_instance.get.called) self.assertTrue(self.mock_instance.put.called)
def test_cors_origins_get(self): """test getting cors origins""" resp = { "enable_cors": True, "allow_credentials": True, "origins": [ "https://example.com", "https://www.example.com" ] } mock_resp = mock.Mock() mock_resp.raise_for_status = mock.Mock() mock_resp.json = mock.Mock() mock_resp.json.return_value = resp self.mock_instance.get.return_value = mock_resp c = Cloudant(self.username, self.password, account=self.username) c.connect() origins = c.cors_origins() self.assertEqual(origins, resp['origins']) self.assertTrue(self.mock_instance.get.called)
def test_session_calls(self): """test session related methods""" c = Cloudant(self.username, self.password) c.connect() self.failUnless(self.mock_session.called) self.assertEqual( self.mock_instance.auth, (self.username, self.password) ) self.assertEqual( self.mock_instance.headers, {'X-Cloudant-User': self.username} ) self.assertEqual('COOKIE', c.session_cookie()) self.failUnless(self.mock_instance.get.called) self.mock_instance.get.assert_has_calls( mock.call('https://steve.cloudant.com/_session') ) self.failUnless(self.mock_instance.post.called) self.mock_instance.post.assert_has_calls( mock.call( 'https://steve.cloudant.com/_session', headers={'Content-Type': 'application/x-www-form-urlencoded'}, data={'password': '******', 'name': 'steve'} ) ) c.disconnect() self.failUnless(self.mock_instance.delete.called) self.mock_instance.delete.assert_has_calls( mock.call('https://steve.cloudant.com/_session') )
def test_usage_endpoint(self): """test the usage endpoint method""" mock_resp = mock.Mock() mock_resp.raise_for_status = mock.Mock() mock_resp.json = mock.Mock() mock_resp.json.return_value = {'usage': 'mock'} mock_get = mock.Mock() mock_get.return_value = mock_resp self.mock_instance.get = mock_get c = Cloudant(self.username, self.password, account=self.username) c.connect() usage = c._usage_endpoint('endpoint', 2015, 12) self.assertEqual(usage, mock_resp.json.return_value) self.assertTrue(mock_resp.raise_for_status.called) mock_get.assert_has_calls( [ mock.call('endpoint/2015/12') ] ) self.assertRaises( CloudantException, c._usage_endpoint, 'endpoint', month=12 )
pass return False if __name__ == '__main__': # ensure we have internet connection # mark every 10 minutes startup_time = time.time() while not has_internet(): elapsed = time.time() - startup_time if elapsed % 600 == 0: print '%s mins without internet connection...' % (elapsed/60) # connect to cloudant client client.connect() # subscribe to client channel pubnub.subscribe(channels=pubnub_channel_client, callback=callback, error=callback, connect=connect, reconnect=reconnect, disconnect=disconnect) # ensure red led is off GPIO.output(RED_LED, False) try: print('Booting system...') GPIO.add_event_detect(PIR_PIN, GPIO.RISING, callback=alert) # indicate the system is ready GPIO.output(GREEN_LED, True)
class UnitTestDbBase(unittest.TestCase): """ The base class for all unit tests targeting a database """ @classmethod def setUpClass(cls): """ If targeting CouchDB, Set up a CouchDB instance otherwise do nothing. Note: Admin Party is currently unsupported so we must create a CouchDB user for tests to function with a CouchDB instance if one is not provided. """ if os.environ.get('RUN_CLOUDANT_TESTS') is None: if os.environ.get('DB_URL') is None: os.environ['DB_URL'] = 'http://127.0.0.1:5984' if os.environ.get('DB_USER') is None: os.environ['DB_USER_CREATED'] = '1' os.environ['DB_USER'] = '******'.format( unicode_(uuid.uuid4()) ) os.environ['DB_PASSWORD'] = '******' resp = requests.put( '{0}/_config/admins/{1}'.format( os.environ['DB_URL'], os.environ['DB_USER'] ), data='"{0}"'.format(os.environ['DB_PASSWORD']) ) resp.raise_for_status() @classmethod def tearDownClass(cls): """ If necessary, clean up CouchDB instance once all tests are complete. """ if (os.environ.get('RUN_CLOUDANT_TESTS') is None and os.environ.get('DB_USER_CREATED') is not None): resp = requests.delete( '{0}://{1}:{2}@{3}/_config/admins/{4}'.format( os.environ['DB_URL'].split('://', 1)[0], os.environ['DB_USER'], os.environ['DB_PASSWORD'], os.environ['DB_URL'].split('://', 1)[1], os.environ['DB_USER'] ) ) del os.environ['DB_USER_CREATED'] del os.environ['DB_USER'] resp.raise_for_status() def setUp(self): """ Set up test attributes for unit tests targeting a database """ if os.environ.get('RUN_CLOUDANT_TESTS') is None: self.user = os.environ['DB_USER'] self.pwd = os.environ['DB_PASSWORD'] self.url = os.environ['DB_URL'] self.client = CouchDB(self.user, self.pwd, url=self.url) else: self.account = os.environ.get('CLOUDANT_ACCOUNT') self.user = os.environ.get('DB_USER') self.pwd = os.environ.get('DB_PASSWORD') self.url = os.environ.get( 'DB_URL', 'https://{0}.cloudant.com'.format(self.account)) self.client = Cloudant( self.user, self.pwd, url=self.url, x_cloudant_user=self.account) def tearDown(self): """ Ensure the client is new for each test """ del self.client def db_set_up(self): """ Set up test attributes for Database tests """ self.client.connect() self.test_dbname = self.dbname() self.db = self.client._DATABASE_CLASS(self.client, self.test_dbname) self.db.create() def db_tear_down(self): """ Reset test attributes for each test """ self.db.delete() self.client.disconnect() del self.test_dbname del self.db def dbname(self, database_name='db'): return '{0}-{1}'.format(database_name, unicode_(uuid.uuid4())) def populate_db_with_documents(self, doc_count=100): docs = [ {'_id': 'julia{0:03d}'.format(i), 'name': 'julia', 'age': i} for i in range(doc_count) ] return self.db.bulk_docs(docs)
class CloudantAccountTests(UnitTestDbBase): """ Cloudant specific Account unit tests """ def test_constructor_with_account(self): """ Test instantiating an account object using an account name """ # Ensure that the client is new del self.client self.client = Cloudant(self.user, self.pwd, account=self.account) self.assertEqual( self.client.cloudant_url, 'https://{0}.cloudant.com'.format(self.account) ) def test_connect_headers(self): """ Test that the appropriate request headers are set """ try: self.client.connect() self.assertEqual( self.client.r_session.headers['X-Cloudant-User'], self.account ) agent = self.client.r_session.headers.get('User-Agent') self.assertTrue(agent.startswith('python-cloudant')) finally: self.client.disconnect() def test_billing_data(self): """ Test the retrieval of billing data """ try: self.client.connect() expected = [ 'data_volume', 'total', 'start', 'end', 'http_heavy', 'http_light' ] # Test using year and month year = datetime.now().year month = datetime.now().month data = self.client.bill(year, month) self.assertTrue(all(x in expected for x in data.keys())) #Test without year and month arguments del data data = self.client.bill() self.assertTrue(all(x in expected for x in data.keys())) finally: self.client.disconnect() def test_volume_usage_data(self): """ Test the retrieval of volume usage data """ try: self.client.connect() expected = [ 'data_vol', 'granularity', 'start', 'end' ] # Test using year and month year = datetime.now().year month = datetime.now().month data = self.client.volume_usage(year, month) self.assertTrue(all(x in expected for x in data.keys())) #Test without year and month arguments del data data = self.client.volume_usage() self.assertTrue(all(x in expected for x in data.keys())) finally: self.client.disconnect() def test_requests_usage_data(self): """ Test the retrieval of requests usage data """ try: self.client.connect() expected = [ 'requests', 'granularity', 'start', 'end' ] # Test using year and month year = datetime.now().year month = datetime.now().month data = self.client.requests_usage(year, month) self.assertTrue(all(x in expected for x in data.keys())) #Test without year and month arguments del data data = self.client.requests_usage() self.assertTrue(all(x in expected for x in data.keys())) finally: self.client.disconnect() def test_shared_databases(self): """ Test the retrieval of shared database list """ try: self.client.connect() self.assertIsInstance(self.client.shared_databases(), list) finally: self.client.disconnect() def test_generate_api_key(self): """ Test the generation of an API key for this account """ try: self.client.connect() expected = ['key', 'password', 'ok'] api_key = self.client.generate_api_key() self.assertTrue(all(x in expected for x in api_key.keys())) self.assertTrue(api_key['ok']) finally: self.client.disconnect() def test_cors_configuration(self): """ Test the retrieval of the current CORS configuration for this account """ try: self.client.connect() expected = ['allow_credentials', 'enable_cors', 'origins'] cors = self.client.cors_configuration() self.assertTrue(all(x in expected for x in cors.keys())) finally: self.client.disconnect() def test_cors_origins(self): """ Test the retrieval of the CORS origins list """ try: self.client.connect() origins = self.client.cors_origins() self.assertIsInstance(origins, list) finally: self.client.disconnect() def test_disable_cors(self): """ Test disabling CORS (assuming CORS is enabled) """ try: self.client.connect() # Save original CORS settings save = self.client.cors_configuration() # Test CORS disable self.assertEqual(self.client.disable_cors(), {'ok': True}) # Restore original CORS settings self.client.update_cors_configuration( save['enable_cors'], save['allow_credentials'], save['origins'], True ) finally: self.client.disconnect() def test_update_cors_configuration(self): """ Test updating CORS configuration """ try: self.client.connect() # Save original CORS settings save = self.client.cors_configuration() # Test updating CORS settings, overwriting origins result = self.client.update_cors_configuration( True, True, ['https://ibm.com'], True) self.assertEqual(result, {'ok': True}) updated_cors = self.client.cors_configuration() self.assertTrue(updated_cors['enable_cors']) self.assertTrue(updated_cors['allow_credentials']) expected = ['https://ibm.com'] self.assertTrue(all(x in expected for x in updated_cors['origins'])) # Test updating CORS settings, adding to origins result = self.client.update_cors_configuration( True, True, ['https://ibm.cloudant.com'] ) self.assertEqual(result, {'ok': True}) del updated_cors updated_cors = self.client.cors_configuration() self.assertTrue(updated_cors['enable_cors']) self.assertTrue(updated_cors['allow_credentials']) expected.append('https://ibm.cloudant.com') self.assertTrue(all(x in expected for x in updated_cors['origins'])) # Restore original CORS settings self.client.update_cors_configuration( save['enable_cors'], save['allow_credentials'], save['origins'], True ) finally: self.client.disconnect()
from cloudant.account import Cloudant client = Cloudant('eurisko', 'nox721!carpe', account='eurisko') # or using url # client = Cloudant(USERNAME, PASSWORD, url='https://acct.cloudant.com') # Connect to the account client.connect() # Perform client tasks... session = client.session() print session['userCtx']['name'] print client.all_dbs() db = client['eurisko'] inserted_counter = 0 # now connec to local sqlite3 def parse_results(results): """ """ for result in results: print 'parsing result' data = {} data['customer_id'] = 0 data['tags'] = [] data['title'] = result[0] data['content'] = result[1] data['timestamp'] = result[2] insert_to_cloudant(data)
class Login: """This class deals with all login and logout Functions: log_in(username, password): Returns true for success, false for failure log_state: returns if you are logged in or not log_out: Logs out, returns true get_user: Returns username get_usergroup: Returns usergroup TODO: Implement log of attempts """ def __init__(self): self.state = False # Am I logged in? self.current_user = "" self.current_usergroup = 0 def log_state(self): return self.state def get_user(self): return self.current_user def get_usergroup(self): """Usergroup 1: Admin Usergroup 2: User""" return self.usergroup # Todo: Save to files def log_of_attempts(self): return True def log_in(self, user, password): # Connect to database USERNAME = "" # ADD YOUR OWN PASSWORD = "" # ADD YOUR OWN URL = "" # ADD YOUR OWN self.client = Cloudant(USERNAME, PASSWORD, url=URL) self.client.connect() # Get users database # print 'Databases: {0}'.format(self.client.all_dbs()) # Debugging login_db = self.client[u'users'] # print type(login_db) # debugging # TODO: Get from own class ts = time.time() st = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S') # if user in self.users: user_found = Document(login_db, user) if user_found.exists(): # Get password from DB with Document(login_db, user) as document: temp_pass = document[u'password'] temp_usergroup = document[u'usergroup'] if password == temp_pass: self.log_of_attempts # userlogins.append([user, password, st]) self.state = True self.current_user = user self.current_usergroup = int(temp_usergroup) return True else: self.log_of_attempts # userrequests.append([user, password, st]) print "Wrong password" return False else: self.log_of_attempts # userrequests.append([user, password, st]) print "User not found" return False def log_out(self): self.current_usergroup = 0 self.current_user = "" self.state = False self.client.disconnect() # disconnect to DB return True
class CloudantDB: def upload_file(self, file): self.connect_to_db(); return self.upload_file_to_db(file); def upload_file_to_db(self, file): file_name = file.filename; file_contenttype = file.content_type uploaded_file_content = file.read(); with open(file_name, 'wb') as f: f.write(uploaded_file_content); fileEncrypt = security.FileEncryption(); encrypted_file_path = fileEncrypt.encrypt_file(file_name); with open(encrypted_file_path, 'rb') as f: uploaded_file_content = f.read(); hashed_content = hashing.hash_data(uploaded_file_content); file_hashed_content, version = self.get_file_if_exists(file_name); if(version > 0): if(hashed_content == file_hashed_content): return "File Already Exists"; version += 1; date = datetime.datetime.now(pytz.timezone("US/Central")); fmt = "%Y-%m-%d %H:%M:%S %Z" last_modified_time = date.strftime(fmt); data = { 'file_name': file_name, 'hashed_content': hashed_content, 'version': version, 'last_modified_time': last_modified_time } my_doc = self.database.create_document(data); my_doc.put_attachment(file_name, file_contenttype, uploaded_file_content); if my_doc.exists(): print "SUCCESS"; return "File Uploaded Successfully"; def download_file(self, file_name, version): selector = { "file_name": file_name, "version": version } fields = ["version","_id","last_modified_time"]; data = self.database.get_query_result(selector=selector, fields=fields) for my_doc in data: print my_doc; id = my_doc["_id"] last_modified_time = my_doc["last_modified_time"] document_val = Document(self.database, id); with open(file_name, 'wb') as f: document_val.get_attachment(file_name, write_to=file_name, attachment_type='binary') fileDecrypt = security.FileEncryption(); fileDecrypt.decrypt_file(file_name, file_name); def download_file_test(self, file_name, id): username = "******"; password = "******" url = "https://f0ebf985-0718-42ab-81c8-d9a4749781fe-bluemix.cloudant.com" password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm(); password_mgr.add_password(None, url, username, password) urllib2.install_opener(urllib2.build_opener(urllib2.HTTPBasicAuthHandler(password_mgr))) url_to_download = self.URL_TO_DOWNLOAD +"/files_data/"+ id + "/" + file_name; request = urllib2.Request(url_to_download) f = urllib2.urlopen(request) data = f.read(); return data; def download_file_from_db(self, file_name, version): self.connect_to_db(); return self.download_file(file_name, version); def get_file_if_exists(self, file_name): selector = { "file_name": file_name, "version": {"$gt": 0} } fields = ["hashed_content", "version"] sort = [{"version":"asc"}] data = self.database.get_query_result(selector=selector, fields=fields, sort=sort) version = 0; file_contents = ""; for doc in data: if(version < doc["version"]): version = doc["version"]; file_contents = doc["hashed_content"]; return file_contents, version; def connect_to_db(self): self.file_upload_path = os.path.dirname(__file__) + "\\templates\\file_downloads" self.URL_TO_DOWNLOAD = "https://f0ebf985-0718-42ab-81c8-d9a4749781fe-bluemix.cloudant.com" self.client = Cloudant() self.client.connect(); self.session = self.client.session(); self.database = self.client['files_data']; def disconnect_db(self): self.cloudant_account.logout(); def list_all_in_db(self): list = [] for doc in self.database: if 'file_name' in doc.keys(): list.append(doc['file_name']) print list return list;