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;
