def confirm_installation(self, auth):
r = requests.post(AppConfig.get("access_token_url").format(
self.shop.name),
data={
'client_id': AppConfig.get("API_KEY"),
'client_secret': AppConfig.get("API_SECRET"),
'code': auth
})
self.shop.token = (r.json()["access_token"])
def add_billing(self, last_billing):
url = self.get_url('recurring_application_charges.json')
header = self.get_header()
header['Content-Type'] = 'application/json'
trial_days = self.get_trial_period(last_billing)
r = requests.post(
url,
data=dumps({
"recurring_application_charge": {
"name":
"Recurring charge",
"price":
1.99,
"test":
AppConfig.get("environment") == "development",
"trial_days":
trial_days,
"return_url":
"http://{}.myshopify.com/admin/apps/customerce".format(
self.shop.name)
}
}),
headers=header)
if r.status_code == 201:
rdict = loads(r.content)['recurring_application_charge']
self.shop.billing_id = rdict['id']
save_shop(self.shop)
return rdict['confirmation_url']
return None
def get_trial_period(self, last_billing):
default_trial_period = AppConfig.get("default_trial_period")
if last_billing is None:
return default_trial_period
url = self.get_url(
'recurring_application_charges/{}.json'.format(last_billing))
header = self.get_header()
header['Content-Type'] = 'application/json'
r = requests.get(url, headers=header)
try:
rdict = loads(r.content)['recurring_application_charge']
except KeyError:
return default_trial_period
activated_on = rdict['activated_on']
if activated_on is None:
return default_trial_period
activated = datetime.datetime.strptime(activated_on, '%Y-%m-%d')
today = datetime.datetime.today()
period = default_trial_period - (today - activated).days
if period < 0:
return 0
if period > default_trial_period:
return default_trial_period
return period
def get_button():
shop_name = request.args.get("shop")
if shop_name is not None:
return send_from_directory(
AppConfig.get("shop_scripts_directory"),
'{}.js'.format(shop_name.replace('.myshopify.com', '')))
else:
abort(404)
def test_save_default_config(self):
''' Test the save functionality with a default config file '''
config = AppConfig()
config.init_default_config(os.path.join(self.config_dir,
'test_data.txt'))
config.save()
# read the generated default output file (only three sections expected
# nothing else should be in here since we haven't changed one value.
# but added the default config file
sections, values, comments = \
self._parse_config_file(config.get(config.application_name,
'config_file'))
self.assertTrue(sections == 3)
self.assertTrue(values == 0)
self.assertTrue(comments == 0)
config.save(verbose=True)
# search the verbose file with 3 lines of comment for each entry
sections, values, comments = \
self._parse_config_file(config.get(config.application_name,
'config_file'))
self.assertTrue(sections == 3)
self.assertTrue(values == 0)
self.assertTrue(comments == 34)
config.set('client', 'first', 42)
config.set('client', 'second', 42)
config.set('server', 'first', 42)
config.set('server', 'second', 42)
config.save()
config.save()
# read the config file after two value for each section where set
sections, values, comments = \
self._parse_config_file(config.get(config.application_name,
'config_file'))
self.assertTrue(sections == 3)
self.assertTrue(values == 4)
self.assertTrue(comments == 0)
config.save(verbose=True)
# search the verbose file with 3 lines of comment for each entry and
# some value where set with a none standard value
sections, values, comments = \
self._parse_config_file(config.get(config.application_name,
'config_file'))
self.assertTrue(sections == 3)
self.assertTrue(values == 4)
self.assertTrue(comments == 34)
# load default config
config.load_default()
self.assertTrue(config.get('client', 'first') == "42")
os.remove(config.get(config.application_name, 'config_file'))
def build_script(shop):
var = ''
if shop.button_enabled and valid_phone(shop.phone):
if shop.sticky_bar_enabled and shop.sticky_label_text is not None and shop.sticky_label_text != '':
var = build_text_script(shop)
else:
var = build_whatsapp_button_script(shop)
path = AppConfig.get("shop_scripts_directory") + '{}.js'.format(shop.name)
try:
remove(path)
except FileNotFoundError:
pass
f = open(path, 'a')
f.write(var)
class MongoDbConn():
def __init__(self, config):
self.__config = AppConfig().databaseOptions().get('mongodb').get(
config)
self.__host = self.__config.get('host')
self.__user = self.__config.get('user')
self.__port = self.__config.get('port')
self.__password = self.__config.get('password')
self.__sslCertFile = self.__config.get('ssl_certfile')
self.__sslKeyFile = self.__config.get('ssl_keyfile')
self.__sslPassphrase = self.__config.get('ssl_pem_passphrase')
self.__useSsl = False
if self.__sslCertFile and self.__sslKeyFile:
self.__useSsl = True
self.__conn = None
def connect(self):
try:
if self.__user != '' and self.__password:
self.__conn = pymongo.MongoClient(
host=self.__host,
port=self.__port,
username=self.__user,
password=self.__password,
ssl=self.__useSsl,
ssl_certfile=self.__sslCertFile,
ssl_keyfile=self.__sslKeyFile,
ssl_pem_passphrase=self.__sslPassphrase)
else:
self.__conn = pymongo.MongoClient(
host=self.__host,
port=self.__port,
ssl=self.__useSsl,
ssl_certfile=self.__sslCertFile,
ssl_keyfile=self.__sslKeyFile,
ssl_pem_passphrase=self.__sslPassphrase)
except Exception as ex:
print(ex)
return self.__conn
def close(self):
if self.__conn:
self.__conn.close()
def redirect_to_install_confirmation(self):
url = AppConfig.get("redirect_url").format(
self.shop.name, AppConfig.get("API_KEY"),
"{}/install/confirm".format(AppConfig.url),
AppConfig.get("scopes"))
return url
class ShopifyApi:
def __init__(self, shop):
self.shop = shop
url = AppConfig.get("shop_admin_url")
def get_url(self, context):
return self.url.format(self.shop.name, context)
def get_header(self):
header = {'X-Shopify-Access-Token': self.shop.token}
return header
def token_valid(self):
url = self.get_url('shop.json')
header = self.get_header()
r = requests.get(url, headers=header)
return not r.status_code == 401
def confirm_installation(self, auth):
r = requests.post(AppConfig.get("access_token_url").format(
self.shop.name),
data={
'client_id': AppConfig.get("API_KEY"),
'client_secret': AppConfig.get("API_SECRET"),
'code': auth
})
self.shop.token = (r.json()["access_token"])
def redirect_to_install_confirmation(self):
url = AppConfig.get("redirect_url").format(
self.shop.name, AppConfig.get("API_KEY"),
"{}/install/confirm".format(AppConfig.url),
AppConfig.get("scopes"))
return url
def update_sticky_bar(self):
url = self.get_url('script_tags.json')
header = self.get_header()
header['Content-Type'] = 'application/json'
build_script(self.shop)
if self.shop.script_tag_id is None:
r = requests.post(url,
data=dumps({
"script_tag": {
"event": "onload",
"src": AppConfig.url + '/shop_scripts'
}
}),
headers=header)
if r.status_code == 201:
self.shop.script_tag_id = loads(r.content)['script_tag']['id']
def add_billing(self, last_billing):
url = self.get_url('recurring_application_charges.json')
header = self.get_header()
header['Content-Type'] = 'application/json'
trial_days = self.get_trial_period(last_billing)
r = requests.post(
url,
data=dumps({
"recurring_application_charge": {
"name":
"Recurring charge",
"price":
1.99,
"test":
AppConfig.get("environment") == "development",
"trial_days":
trial_days,
"return_url":
"http://{}.myshopify.com/admin/apps/customerce".format(
self.shop.name)
}
}),
headers=header)
if r.status_code == 201:
rdict = loads(r.content)['recurring_application_charge']
self.shop.billing_id = rdict['id']
save_shop(self.shop)
return rdict['confirmation_url']
return None
def activate_billing(self):
url = self.get_url(
'recurring_application_charges/{}/activate.json'.format(
self.shop.billing_id))
header = self.get_header()
header['Content-Type'] = 'application/json'
r = requests.post(url, headers=header)
return r.status_code
def get_trial_period(self, last_billing):
default_trial_period = AppConfig.get("default_trial_period")
if last_billing is None:
return default_trial_period
url = self.get_url(
'recurring_application_charges/{}.json'.format(last_billing))
header = self.get_header()
header['Content-Type'] = 'application/json'
r = requests.get(url, headers=header)
try:
rdict = loads(r.content)['recurring_application_charge']
except KeyError:
return default_trial_period
activated_on = rdict['activated_on']
if activated_on is None:
return default_trial_period
activated = datetime.datetime.strptime(activated_on, '%Y-%m-%d')
today = datetime.datetime.today()
period = default_trial_period - (today - activated).days
if period < 0:
return 0
if period > default_trial_period:
return default_trial_period
return period
def test_set_config(self):
''' Test seting and getting values from the config object '''
config = AppConfig()
# tests without default config loaded
config.set('client', 'first', 12)
value = config.get('client', 'first')
self.assertTrue(type(value) == str)
# this is a string since we don't now anything about it
self.assertTrue(value == '12')
config.set('client', 'third', -16)
value = config.get('client', 'third')
self.assertTrue(type(value) == str)
# this is a string since we don't now anything about it
self.assertTrue(value == '-16')
# and now with default config loaded
config.init_default_config(os.path.join(self.config_dir,
'test_data.txt'))
# check previous set values if the previous value remains.
self._check_value(config, 'client', 'first', 'Aldebarans', str,
'Start', "12")
self._check_value(config, 'client', 'third',
'Amoeboid Zingatularians', int, 12, -16)
# now do some test for all kind of types
config.set('client', 'first', 112)
self._check_value(config, 'client', 'first', 'Aldebarans', str,
'Start', "112")
config.set('client', 'second', 12.45)
if PY2:
self._check_value(config, 'client', 'second', 'Altairians',
unicode, 'Stop', '12.45')
else:
self._check_value(config, 'client', 'second', 'Altairians',
str, 'Stop', '12.45')
config.set('client', 'third', -166)
self._check_value(config, 'client', 'third',
'Amoeboid Zingatularians', int, 12, -166)
config.set('client', 'forth', 11)
self._check_value(config, 'client', 'forth', 'Bartledanians', float,
12.2, 11.0)
config.set('client', 'fifth', False)
self._check_value(config, 'client', 'fifth', 'Belcerebons', bool,
True, False)
# the same with a string
config.set('client', 'fifth', "False")
self._check_value(config, 'client', 'fifth', 'Belcerebons', bool,
True, False)
config.set('client', 'fifth', "True")
self._check_value(config, 'client', 'fifth', 'Belcerebons', bool,
True, True)
# the same with numbers
config.set('client', 'fifth', 0)
self._check_value(config, 'client', 'fifth', 'Belcerebons', bool,
True, False)
config.set('client', 'fifth', 1)
self._check_value(config, 'client', 'fifth', 'Belcerebons', bool,
True, True)
# with illegal value
with self.assertRaises(AppConfigValueException):
config.set('client', 'fifth', 'no')
config.set('server', 'first', True)
self._check_value(config, 'server', 'first', 'Betelgeusians', str,
'End', 'True')
config.set('server', 'second', "Arther Dent")
if PY2:
self._check_value(config, 'server', 'second', 'Blagulon Kappans',
unicode, 'Accelerate', 'Arther Dent')
else:
self._check_value(config, 'server', 'second', 'Blagulon Kappans',
str, 'Accelerate', 'Arther Dent')
config.set('server', 'third', 42)
self._check_value(config, 'server', 'third', 'Dentrassis', int, -12,
42)
config.set('server', 'forth', 42.43)
self._check_value(config, 'server', 'forth', 'Dolphins', float,
3.3333, 42.43)
config.set('server', 'fifth', True)
self._check_value(config, 'server', 'fifth',
"G'Gugvunnts and Vl'hurgs", bool, False, True)
import logging
import sys
from flask import Flask
from appconfig import AppConfig
from firebase_admin import credentials, initialize_app
try:
cred = credentials.Certificate('db_credentials.json')
initialize_app(cred, {'databaseURL': AppConfig.get("db_url")})
except FileNotFoundError:
logging.error('Database credentials file not found')
sys.exit()
app = Flask(__name__,
static_folder="static",
template_folder="static/templates")
from api.admin_blueprint import admin_blueprint
from api.install_blueprint import install_blueprint
from api.root_blueprint import root_blueprint
from api.script_blueprint import script_blueprint
app.register_blueprint(root_blueprint)
app.register_blueprint(install_blueprint)
app.register_blueprint(admin_blueprint)
app.register_blueprint(script_blueprint)
if __name__ == '__main__':
app.run(
def __init__(self, config):
appConfig = AppConfig().imapOptions()
self.__config = appConfig.get(config)
self.__dataDir = os.path.sep.join((self.__config.get('data_dir'), self.__config.get('user')))
def __init__(self, config):
appConfig = AppConfig().smtpOptions()
self.__config = appConfig.get(config)
class Session():
def __init__(self):
self.__sessionOption = AppConfig().sessionOptions()
# check if folder not exist then create the data dir
dataDir = self.__sessionOption.get('data_dir')
if dataDir and not os.path.isdir(dataDir):
try:
os.makedirs(dataDir)
except Exception as ex:
print(ex)
# initialize session
# add default session
currentUtcTime = self.__getCurrentUtcTimeHash()
# init session if not exist
request.get_cookie('s', currentUtcTime.get('hexdigest'))
def __readSessionFile(self, sessionFile):
loadedData = dict()
f = None
try:
f = open(sessionFile, mode='rb')
loadedData = Unpickler(f).load()
except Exception as e:
print('Warning when read session file %s' % e)
finally:
if f:
f.close()
return loadedData
def _writeSessionFile(self, sessionFile, loadedData):
f = None
try:
f = open(sessionFile, mode='wb')
Pickler(f, protocol=pickle.HIGHEST_PROTOCOL).dump(loadedData)
except Exception as e:
print('Warning when read session file %s' % e)
finally:
if f:
f.close()
def setMaxAge(self, maxAge):
'''
setMaxAge(value)
set max age of the session
'''
try:
currentUtcTime = self.__getCurrentUtcTimeHash()
# get cookie from current request if not exist just add it
cookieSessionData = request.get_cookie(
's', currentUtcTime.get('hexdigest'))
# create session file
if os.path.isdir(self.__sessionOption.get('data_dir')):
sessionFile = os.path.join(
self.__sessionOption.get('data_dir'), cookieSessionData)
if os.path.isfile(sessionFile):
loadedData = self.__readSessionFile(sessionFile)
# set max ages for current session
if isinstance(loadedData, dict):
loadedData['max_age'] = maxAge
self._writeSessionFile(sessionFile, loadedData)
response.set_cookie('s', cookieSessionData, max_age=maxAge)
except Exception as e:
print(e)
def __getCurrentUtcTimeHash(self):
utcdt = datetime.datetime.utcnow().isoformat()
mdsHash = md5(utcdt.encode('utf-8'))
utcnowDiggest = {
'utc_datetime': utcdt,
'hexdigest': mdsHash.hexdigest()
}
return utcnowDiggest
def add(self, key, value):
'''
add(key, value)
add value to session, if key already exist will update the last value
'''
try:
currentUtcTime = self.__getCurrentUtcTimeHash()
# get cookie from current request if not exist just add it
cookieSessionData = request.get_cookie(
's', currentUtcTime.get('hexdigest'))
# create session file
if os.path.isdir(self.__sessionOption.get('data_dir')):
sessionFile = os.path.join(
self.__sessionOption.get('data_dir'), cookieSessionData)
isNotNewSession = os.path.isfile(sessionFile)
loadedData = dict()
if isNotNewSession:
loadedData = self.__readSessionFile(sessionFile)
if isinstance(loadedData, dict):
loadedData[key] = value
# if default max_ages None set default to 30 days 2592000 seconds
# if max ages is not defined ye then add to session data and cookies data
if (loadedData.get('max_age') is None):
loadedData['max_age'] = self.__sessionOption.get(
'default_max_age')
# add created date if not exist in the data
if (loadedData.get('date_created') is None):
loadedData['date_created'] = currentUtcTime[
'utc_datetime']
self._writeSessionFile(sessionFile, loadedData)
# set default max age if new
if (not isNotNewSession):
response.set_cookie(
's',
cookieSessionData,
max_age=self.__sessionOption.get('default_max_age'))
else:
response.set_cookie('s', cookieSessionData)
else:
raise Exception('Session dir is not exist %s' %
self.__sessionOption.get('data_dir'))
except Exception as e:
print(e)
def clear(self):
'''
clear()
clear all instance of session
'''
try:
currentUtcTime = self.__getCurrentUtcTimeHash()
# get cookie from current request if not exist just add it
cookieSessionData = request.get_cookie(
's', currentUtcTime.get('hexdigest'))
# create session file
if os.path.isdir(self.__sessionOption.get('data_dir')):
sessionFile = os.path.join(
self.__sessionOption.get('data_dir'), cookieSessionData)
if (os.path.isfile(sessionFile)):
os.remove(sessionFile)
response.set_cookie('s', cookieSessionData, max_age=0)
response.delete_cookie(cookieSessionData)
except Exception as e:
print(e)
def get(self, key=None):
'''
get()
get available current session session
'''
sessionData = None
try:
currentUtcTime = self.__getCurrentUtcTimeHash()
# get cookie from current request if not exist just add it
cookieSessionData = request.get_cookie(
's', currentUtcTime.get('hexdigest'))
# create session file
if os.path.isdir(self.__sessionOption.get('data_dir')):
sessionFile = os.path.join(
self.__sessionOption.get('data_dir'), cookieSessionData)
if os.path.isfile(sessionFile):
if key:
sessionData = self.__readSessionFile(sessionFile).get(
key)
else:
sessionData = self.__readSessionFile(sessionFile)
except Exception as e:
print(e)
return sessionData
def remove(self, key):
'''
remove(key)
remove session key, will return deleted session key value pair {key, value}
'''
removedData = {}
try:
currentUtcTime = self.__getCurrentUtcTimeHash()
# get cookie from current request if not exist just add it
cookieSessionData = request.get_cookie(
's', currentUtcTime.get('hexdigest'))
# create session file
if os.path.isdir(self.__sessionOption.get('data_dir')):
sessionFile = os.path.join(
self.__sessionOption.get('data_dir'), cookieSessionData)
if os.path.isfile(sessionFile):
loadedData = self.__readSessionFile(sessionFile)
if isinstance(loadedData, dict):
if loadedData.get(key) is not None:
removedData[key] = loadedData.pop(key)
self._writeSessionFile(sessionFile, loadedData)
except Exception as e:
print(e)
return removedData
def getExpired(self):
'''
getExpired()
get expired session file, will return list of absolute path from expired session file
'''
expiredSession = list()
if os.path.isdir(self.__sessionOption.get('data_dir')):
files = os.listdir(self.__sessionOption.get('data_dir'))
for fname in files:
sessionFile = os.path.sep.join(
[self.__sessionOption.get('data_dir'), fname])
if os.path.isfile(sessionFile):
sessionData = self.__readSessionFile(sessionFile)
if isinstance(sessionData, dict):
sessionDatetime = sessionData.get('date_created')
sessionMaxAge = sessionData.get('max_age')
if sessionDatetime is not None and sessionMaxAge is not None:
timeDelta = datetime.datetime.utcnow(
) - datetime.datetime.strptime(
sessionDatetime, '%Y-%m-%dT%H:%M:%S.%f')
totalTimeDeltaInSeconds = timeDelta.days * 86400 + timeDelta.seconds
# if expired add to expiredSession
if totalTimeDeltaInSeconds >= sessionMaxAge:
expiredSession.append(sessionFile)
return expiredSession
def CleanExpiredSession(self):
for expiredSession in self.getExpired():
os.remove(expiredSession)
class PostgreConn():
CODE_OK = 'ok'
CODE_FAIL = 'fail'
def __init__(self, config):
self.__config = AppConfig().databaseOptions().get('postgre').get(
config)
self.__host = self.__config.get('host')
self.__user = self.__config.get('user')
self.__port = self.__config.get('port')
self.__password = self.__config.get('password')
self.__db = self.__config.get('db')
self.__sslMode = 'disable'
self.__sslrootcert = None
self.__sslcert = None
self.__sslkey = None
ssl = self.__config.get('ssl')
if ssl:
self.__sslrootcert = ssl.get('sslrootcert')
self.__sslcert = ssl.get('sslcert')
self.__sslkey = ssl.get('sslkey')
if self.__sslrootcert or self.__sslcert or self.__sslkey:
self.__sslMode = 'verify-full'
self.__conn = None
def __connect(self):
self.__conn = psycopg2.connect(
host=self.__host,
user=self.__user,
password=self.__password,
dbname=self.__db,
port=self.__port,
cursor_factory=psycopg2.extras.DictCursor,
sslmode=self.__sslMode,
sslrootcert=self.__sslrootcert,
sslcert=self.__sslcert,
sslkey=self.__sslkey)
return self.__conn.cursor()
def __close(self):
if self.__conn:
self.__conn.close()
def execute(self, query):
'''
execute non return data query, like insert, update, delete data
return value:
{
'code':'ok'|'fail',
'message':'success message'|'error message'
}
'''
outputMessage = {'code': PostgreConn.CODE_FAIL, 'message': None}
try:
cur = self.__connect()
cur.execute(query)
self.__conn.commit()
outputMessage['code'] = PostgreConn.CODE_OK
outputMessage['message'] = 'Success executed sql command'
except Exception as ex:
outputMessage['message'] = 'fail executed sql command {}'.format(
ex)
finally:
self.__close()
return outputMessage
def fetchAll(self, query):
'''
fetch all query data as list of row sqlite object
{
'code':'ok'|'fail',
'message':'success message'|'error message',
'data':None|[list of sqlite row object]
}
'''
outputMessage = {
'code': PostgreConn.CODE_FAIL,
'message': None,
'data': None
}
try:
cur = self.__connect()
cur.execute(query)
data = cur.fetchall()
outputMessage['code'] = PostgreConn.CODE_OK
outputMessage['message'] = 'Success executed sql command'
outputMessage['data'] = data
except Exception as ex:
outputMessage['message'] = 'fail executed sql command {}'.format(
ex)
finally:
self.__close()
return outputMessage
def fetchOne(self, query):
'''
fetch one query data as single row sqlite object
{
'code':'ok'|'fail',
'message':'success message'|'error message',
'data':None|sqlite row object
}
'''
outputMessage = {
'code': PostgreConn.CODE_FAIL,
'message': None,
'data': None
}
try:
cur = self.__connect()
cur.execute(query)
data = cur.fetchone()
outputMessage['code'] = PostgreConn.CODE_OK
outputMessage['message'] = 'Success executed sql command'
outputMessage['data'] = data
except Exception as ex:
outputMessage['message'] = 'fail executed sql command {}'.format(
ex)
finally:
self.__close()
return outputMessage
def createTable(self, models):
"""
create table that will receive parameter as models of object creation of table
for example we have the current class of creation table definition:
the self.createOrder should be ordering of creation table
class CreateTableExample():
def __init__(self):
self.createOrder = [
'createUsers',
'createAddress'
]
def createUsers(self):
return '''
CREATE TABLE IF NOT EXISTS Users(
userid INTEGER,
username VARCHAR(255),
PRIMARY KEY (userid, username)
);
'''
def createAddress(self):
return '''
CREATE TABLE IF NOT EXISTS Address(
uid INTEGER,
uname VARCHAR(255),
addrid INTEGER,
addrname VARCHAR(255),
PRIMARY KEY (addrid),
FOREIGN KEY (uid, uname) REFERENCES Users(userid, username) ON DELETE CASCADE ON UPDATE NO ACTION
);
'''
{
'code':'ok'|'fail',
'message':'success message'|'error message',
'data':None|[list of sqlite row object]
}
with class creation table above we can use as:
from plugins.dbconn import PostgreConn
conn = PostgreConn('conn1')
conn.createTable(CreateTableExample())
"""
outputMessage = {'code': PostgreConn.CODE_FAIL, 'message': None}
try:
createOrder = getattr(models, 'createOrder')
for create in createOrder:
exeCreate = getattr(models, create)
outputMessage = self.execute(exeCreate())
except Exception as ex:
outputMessage[
'message'] = 'fail executed create table command {}'.format(ex)
return outputMessage
class SqliteConn():
'''
sqlite connection
this connection will depend on the appconfig.py databseOptions:
'sqlite':{
'conn1':
{
'pragma':[the pragma list],
'dbfile':path to database file
}
}
usage:
from plugins.dbconn import SqliteConn
conn = SqliteConn('conn1')
test initialize the table create:
from.models.sqlite_example.example_create_table import CreateTableExample
conn.createTable(CreateTableExample())
all return value should be in form of:
{
'code':'ok'|'fail',
'message':'success message'|'error message',
'data':return value of data
}
data:
fetchAll will return list of sqlite row object
fetchOne will return one sqlite row object
execute will no return any data
'''
CODE_OK = 'ok'
CODE_FAIL = 'fail'
def __init__(self, config):
self.__config = AppConfig().databaseOptions().get('sqlite').get(config)
self.__dbfile = self.__config.get('dbfile')
self.__pragma = self.__config.get('pragma')
self.__conn = None
# init data dir if not exists
dataDir = os.path.sep.join(self.__dbfile.split(os.path.sep)[:-1])
os.makedirs(dataDir, exist_ok=True)
def __connect(self):
# connect to sqlite file
self.__conn = sqlite3.connect(self.__dbfile)
self.__conn.row_factory = sqlite3.Row
return self.__conn.cursor()
def __close(self):
if self.__conn:
self.__conn.close()
def __executePragma(self, cur):
if self.__pragma and len(self.__pragma):
cur.executescript(';'.join(
['PRAGMA {}'.format(pragma) for pragma in self.__pragma]))
self.__conn.commit()
def execute(self, query):
'''
execute non return data query, like insert, update, delete data
return value:
{
'code':'ok'|'fail',
'message':'success message'|'error message'
}
'''
outputMessage = {'code': SqliteConn.CODE_FAIL, 'message': None}
try:
cur = self.__connect()
self.__executePragma(cur)
cur.execute(query)
self.__conn.commit()
outputMessage['code'] = SqliteConn.CODE_OK
outputMessage['message'] = 'Success executed sql command'
except Exception as ex:
outputMessage['message'] = 'fail executed sql command {}'.format(
ex)
finally:
self.__close()
return outputMessage
def fetchAll(self, query):
'''
fetch all query data as list of row sqlite object
{
'code':'ok'|'fail',
'message':'success message'|'error message',
'data':None|[list of sqlite row object]
}
'''
outputMessage = {
'code': SqliteConn.CODE_FAIL,
'message': None,
'data': None
}
try:
cur = self.__connect()
self.__executePragma(cur)
cur.execute(query)
data = cur.fetchall()
outputMessage['code'] = SqliteConn.CODE_OK
outputMessage['message'] = 'Success executed sql command'
outputMessage['data'] = data
except Exception as ex:
outputMessage['message'] = 'fail executed sql command {}'.format(
ex)
finally:
self.__close()
return outputMessage
def fetchOne(self, query):
'''
fetch one query data as single row sqlite object
{
'code':'ok'|'fail',
'message':'success message'|'error message',
'data':None|sqlite row object
}
'''
outputMessage = {
'code': SqliteConn.CODE_FAIL,
'message': None,
'data': None
}
try:
cur = self.__connect()
self.__executePragma(cur)
cur.execute(query)
data = cur.fetchone()
outputMessage['code'] = SqliteConn.CODE_OK
outputMessage['message'] = 'Success executed sql command'
outputMessage['data'] = data
except Exception as ex:
outputMessage['message'] = 'fail executed sql command {}'.format(
ex)
finally:
self.__close()
return outputMessage
def createTable(self, models):
"""
create table that will receive parameter as models of object creation of table
for example we have the current class of creation table definition:
the self.createOrder should be ordering of creation table
class CreateTableExample():
def __init__(self):
self.createOrder = [
'createUsers',
'createAddress'
]
def createUsers(self):
return '''
CREATE TABLE IF NOT EXISTS Users(
userid UNSIGNED INT,
username VARCHAR(255),
PRIMARY KEY (userid, username)
);
'''
def createAddress(self):
return '''
CREATE TABLE IF NOT EXISTS Address(
uid UNSIGNED INT,
uname VARCHAR(255),
addrid UNSIGNED INT,
addrname VARCHAR(255),
PRIMARY KEY (addrid),
FOREIGN KEY (uid, uname) REFERENCES Users(userid, username) ON DELETE CASCADE ON UPDATE NO ACTION
);
'''
{
'code':'ok'|'fail',
'message':'success message'|'error message',
'data':None|[list of sqlite row object]
}
with class creation table above we can use as:
from plugins.dbconn import SqliteConn
conn = SqliteConn('conn1')
conn.createTable(CreateTableExample())
"""
outputMessage = {'code': SqliteConn.CODE_FAIL, 'message': None}
try:
createOrder = getattr(models, 'createOrder')
for create in createOrder:
exeCreate = getattr(models, create)
outputMessage = self.execute(exeCreate())
except Exception as ex:
outputMessage[
'message'] = 'fail executed create table command {}'.format(ex)
return outputMessage
