class Plugin(object):
"""
Plugin class in basic interface
Every XXXPlugin has to inherit Plugin
"""
logger = logging.getLogger(__name__)
locator = Locator()
def preload(self, api_request):
"""
Override in plugin preload process
"""
return api_request
def success(self, api_request, result):
"""
Override in plugin success process
"""
return result
def error(self, api_request, error):
"""
Override in plugin error process
"""
pass
class Manager(object):
"""
Manager class is basic Interface
Every XXXManager has to inherit Manager
"""
logger = logging.getLogger(__name__)
locator = Locator()
import django
path = os.path.abspath(__file__ + "/../..")
if path not in sys.path:
sys.path.append(path)
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "pyengine.settings")
django.setup()
from django.contrib.auth.hashers import make_password
from pyengine.lib.locator import Locator
from pyengine.lib import config
GLOBAL_CONF = config.getGlobalConfig()
locator = Locator()
user_dao = locator.getDAO("user")
def deleteRootUser():
users = user_dao.getVOfromKey(user_id=ROOT_USER)
users.delete()
def createRootUser(password):
dic = {}
dic["user_id"] = ROOT_USER
dic["password"] = make_password(password)
dic["language"] = GLOBAL_CONF["DEFAULT_LANGUAGE"]
dic["timezone"] = GLOBAL_CONF["DEFAULT_TIMEZONE"]
class Info(object):
logger = logging.getLogger(__name__)
locator = Locator()
GLOBAL_CONF = config.getGlobalConfig()
def __init__(self, vo, options):
self.vo = vo
self.options = options
self.output = {}
def checkResponseParams(self):
if len(self.options.get('res_params', [])) > 0:
return True
else:
return False
def _recursionInfo(self, key, value, tz):
# UUID Type to String
if type(value) == uuid.UUID:
return str(value)
# Time Conversion
elif key in self.GLOBAL_CONF['DATETIME_FIELDS']:
if value != None:
value = value.replace(tzinfo=pytz.utc).astimezone(tz)
return value.strftime('%Y-%m-%d %H:%M:%S')
else:
return ''
# Instance
elif isinstance(value, Info) == True:
return value.result(tz)
# List
elif type(value) == type(list()):
# Default
list_output = []
for v in value:
if type(v) == type(dict()):
dic_output = {}
for k in v:
dic_output[k] = self._recursionInfo(k, v[k], tz)
list_output.append(dic_output)
elif isinstance(v, Info) == True:
list_output.append(v.result(tz))
else:
list_output.append(v)
return list_output
# Dictionary
elif type(value) == type(dict()):
output = {}
for k in value:
output[k] = self._recursionInfo(k, value[k], tz)
return output
# No Change
else:
return value
def result(self, timezone=None):
if timezone == None:
timezone = self.GLOBAL_CONF['DEFAULT_TIMEZONE']
tz = pytz.timezone(timezone)
to_string = {}
for k in self.output:
to_string[k] = self._recursionInfo(k, self.output[k], tz)
return to_string
import django
path = os.path.abspath(__file__ + '/../..')
if path not in sys.path:
sys.path.append(path)
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "pyengine.settings")
django.setup()
from django.contrib.auth.hashers import make_password
from pyengine.lib.locator import Locator
from pyengine.lib import config
GLOBAL_CONF = config.getGlobalConfig()
locator = Locator()
user_dao = locator.getDAO('user')
def deleteUser(user_id):
users = user_dao.getVOfromKey(user_id=user_id)
users.delete()
def createUser(user_id, password):
dic = {}
dic['user_id'] = user_id
dic['password'] = make_password(password)
dic['language'] = GLOBAL_CONF['DEFAULT_LANGUAGE']
dic['timezone'] = GLOBAL_CONF['DEFAULT_TIMEZONE']
class Command(object):
__metaclass__ = abc.ABCMeta
VAR_TYPE = {
'bool' : type(bool()),
'str' : type(str()),
'int' : type(int()),
'float' : type(float()),
'dic' : type(dict()),
'list' : type(list()),
'tuple' : type(tuple()),
'unicode' : type(unicode()),
'any' : None,
}
# Every API specify valid parameters
# Override in xxxCommand
req_params = {}
logger = logging.getLogger(__name__)
locator = Locator()
GLOBAL_CONF = config.getGlobalConfig()
def __init__(self, api_request):
self.user_meta = api_request['meta']['user']
self.plugins = api_request['meta']['plugin']
self.params = self._checkParam(api_request['params'])
if api_request['meta'].has_key('xtoken'):
self.xtoken = api_request['meta']['xtoken']
def _checkParam(self, api_params):
"""
@param param : request parameters from Service API
@return : update self.params
"""
params = {}
for key in self.req_params:
# Key Exists
if api_params.has_key(key):
# Check Variable Type
if self.VAR_TYPE[self.req_params[key][1]] == type(api_params[key]) or self.req_params[key][1] == 'any':
params[key] = api_params[key]
else:
# Convert Unicode to String
if self.req_params[key][1] == 'str' and type(api_params[key]) == self.VAR_TYPE['unicode']:
params[key] = api_params[key].encode('utf-8')
else:
raise ERROR_INVALID_PARAM_TYPE(key=key, ptype=self.req_params[key][1])
# Check Enum Value
if len(self.req_params[key]) >= 3:
if not api_params[key] in self.req_params[key][2]:
raise ERROR_INVALID_PARAMETER(key=key, value=str(self.req_params[key][2]))
else:
if self.req_params[key][0] == 'r':
raise ERROR_REQUIRED_PARAM(key=key)
return params
def makeSearch(self, *args):
"""
Append search option with (k, params[k],"eq")
"""
search = self.params.get('search', [])
for k in args:
if self.params.has_key(k) == True:
additional = {'key':k, 'value':self.params[k], 'option':'eq'}
search.append(additional)
# Convert Timezone
tz = pytz.timezone(self.user_meta['timezone'])
for s in search:
if s['key'] in self.GLOBAL_CONF['DATETIME_FIELDS']:
try:
s['value'] = tz.localize(parse_datetime(s['value']), is_dst=None)
except Exception as e:
self.logger.debug(e)
raise ERROR_INVALID_TIME_FORMAT()
return search
def rollback(self):
"""
Override in API rollback process
"""
pass
@abc.abstractmethod
def execute(self):
"""
Override in API implementation
"""
pass
import django
path = os.path.abspath(__file__ + '/../..')
if path not in sys.path:
sys.path.append(path)
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "pyengine.settings")
django.setup()
from django.contrib.auth.hashers import make_password
from pyengine.lib.locator import Locator
from pyengine.lib import config
GLOBAL_CONF = config.getGlobalConfig()
locator = Locator()
user_dao = locator.getDAO('user')
def deleteRootUser():
users = user_dao.getVOfromKey(user_id=ROOT_USER)
users.delete()
def createRootUser(password):
dic = {}
dic['user_id'] = ROOT_USER
dic['password'] = make_password(password)
dic['language'] = GLOBAL_CONF['DEFAULT_LANGUAGE']
dic['timezone'] = GLOBAL_CONF['DEFAULT_TIMEZONE']
user_dao.insert(dic)
