def __init__(self, request, dbname, tablename, id=None):
super().__init__()
self.dbname = dbname
self.tablename = tablename
self.request = request
self.db = DBPools()
self.id = id
def getPagingData(self, dict_data, ns, request):
pool = DBPools()
@pool.runSQLPaging
def sql(dbname, NS):
sqldesc = dict_data.get('sqldesc')
return sqldesc
db = dict_data['sqldesc']['db']
ret = sql(db, ns)
return ret
def getData(self, dict_data, ns, request):
pool = DBPools()
@pool.runSQL
def sql(dbname, NS):
sqldesc = dict_data.get('sqldesc')
return sqldesc
db = dict_data['sqldesc']['db']
ret = [i for i in sql(db, ns)]
return ret
def __init__(self):
workdir = programPath = ProgramPath()
if len(sys.argv) > 1:
workdir = sys.argv[1]
config = getConfig(workdir, {
'ProgramPath': programPath,
'workdir': workdir
})
if config.get('databases'):
DBPools(config.databases)
initEnv()
paths = [os.path.abspath(p) for p in config.website.paths]
resource = BaseResource(paths, indexes=config.website.indexes)
setupTemplateEngine()
resource.indexes = config.website.indexes
resource.processors = config.website.processors
self.app = MyApp(static=resource)
resource.app = self.app
def __init__(self, auth_klass=AuthAPI, workdir=None):
super().__init__()
if workdir is not None:
pp = ProgramPath()
config = getConfig(workdir, {
'workdir': workdir,
'ProgramPath': pp
})
else:
config = getConfig()
if config.databases:
DBPools(config.databases)
initEnv()
setupTemplateEngine()
self.app = web.Application()
auth = auth_klass()
auth.setupAuth(self.app)
self.configPath(config)
def getDataDesc(self, dict_data, ns, request):
pool = DBPools()
@pool.runSQLResultFields
def sql(dbname, NS):
sqldesc = dict_data.get('sqldesc')
# print('sql(),sqldesc=',sqldesc)
return sqldesc
rec = dict_data.get('datadesc', None)
if rec is None:
sqldesc = dict_data.get('sqldesc')
ns = dict_data.get('arguments', {})
rec = [r for r in sql(sqldesc['db'], ns) if r['name'] != '_row_id']
dict_data['datadesc'] = rec
f = codecs.open(self.src_file, 'w', self.config.website.coding)
b = json.dumps(dict_data, indent=4)
f.write(b)
f.close()
return rec
def initEnv():
pool = DBPools()
g = ServerEnv()
g.configValue = configValue
g.visualcoding = visualcoding
g.uriop = URIOp
g.isNone = isNone
g.json = json
g.int = int
g.str = str
g.float = float
g.type = type
g.ArgsConvert = ArgsConvert
g.time = time
g.curDateString = curDateString
g.curTimeString = curTimeString
g.datetime = datetime
g.random = random
g.str2date = str2Date
g.str2datetime = str2Datetime
g.curDatetime = curDatetime
g.uObject = uObject
g.uuid = getID
g.runSQL = runSQL
g.runSQLPaging = runSQLPaging
g.runSQLIterator = pool.runSQL
g.runSQLResultFields = pool.runSQLResultFields
g.getTables = pool.getTables
g.getTableFields = pool.getTableFields
g.getTablePrimaryKey = pool.getTablePrimaryKey
g.getTableForignKeys = pool.getTableForignKeys
g.folderInfo = folderInfo
g.abspath = abspath
g.data2xlsx = data2xlsx
g.xlsxdata = XLSXData
g.openfile = openfile
g.CRUD = CRUD
g.DBPools = DBPools
},
"cfae": {
"driver": "mysql.connector",
"coding": "utf8",
"dbname": "cfae",
"kwargs": {
"user": "******",
"db": "cfae",
"password": "******",
"host": "localhost"
}
}
}
loop = asyncio.get_event_loop()
pool = DBPools(dbs, loop=loop)
async def printTables(dbname):
r = await pool.getTables(dbname)
print('tables=', r)
async def printFields(dbname, tablename):
r = await pool.getTableFields(dbname, tablename)
print(dbname, tablename, 'fields=', r)
async def printPrimary(dbname, tablename):
r = await pool.getTablePrimaryKey(dbname, tablename)
print(dbname, tablename, 'primary key=', r)
class DBCrud(RestEndpoint):
def __init__(self, request, dbname, tablename, id=None):
super().__init__()
self.dbname = dbname
self.tablename = tablename
self.request = request
self.db = DBPools()
self.id = id
async def options(self) -> Response:
try:
with self.db.sqlorContext(self.dbname) as sor:
d = await sor.I(self.tablename)
return json_response(Success(d))
except Exception as e:
print(e)
traceback.print_exc()
return json_response(
Error(errno='metaerror', msg='get metadata error'))
async def get(self) -> Response:
"""
query data
"""
try:
ns = multiDict2Dict(self.request.query)
with self.db.sqlorContext(self.dbname) as sor:
d = await sor.R(self.tablename, ns)
return json_response(Success(d))
except Exception as e:
print(e)
traceback.print_exc()
return json_response(
Error(errno='search error', msg='search error'))
async def post(self):
"""
insert data
"""
try:
ns = multiDict2Dict(await self.request.post())
with self.db.sqlorContext(self.dbname) as sor:
d = await sor.C(self.tablename, ns)
return json_response(Success(d))
except Exception as e:
print(e)
traceback.print_exc()
return json_response(Error(errno='add error', msg='add error'))
async def put(self):
"""
update data
"""
try:
ns = multiDict2Dict(await self.request.post())
with self.db.sqlorContext(self.dbname) as sor:
d = await sor.U(self.tablename, ns)
return json_response(Success(' '))
except Exception as e:
print(e)
traceback.print_exc()
return json_response(
Error(errno='update error', msg='update error'))
async def delete(self, request: Request, instance_id):
"""
delete data
"""
try:
ns = multiDict2Dict(self.request.query)
with self.db.sqlorContext(self.dbname) as sor:
d = await sor.D(self.tablename, ns)
return json_response(Success(d))
except Exception as e:
print(e)
traceback.print_exc()
return json_response(Error(erron='delete error', msg='error'))
def __init__(self,db,encryptKey): super(DatabaseAC,self).__init__() self.db = db self.pool = DBPools() self.encryptKey = encryptKey self.rc4 = RC4(encryptKey)
def addRolePermission(self,roleid,permid):
crud = _CRUD(self,db,'ac_rolepermission')
ns = {
"rp_id":getID(),
"role_id":roleid,
"perm_id":permid
}
crud.C(ns)
return ns
if __name__ == '__main__':
from appPublic.jsonConfig import getConfig
from sqlor.dbpools import DBPools
p = 'd:/run'
conf = getConfig(p)
DBPools(conf.databases)
ac = DatabaseAC('metadb',conf.encryptkey)
#ns1 = ac.addUser('root','根用户','ymq123')
#ns2 = ac.addRole('superuser')
#ns3 = ac.addUserRole(ns1['user_id'],ns2['role_id'])
ups = [
['root','ymq123'],
['root','YYYY'],
['rrrr','ymq123']
]
rc4_1 = RC4(conf.encryptkey)
rc4_2 = RC4(conf.encryptkey)
for a in ups:
#print(a[1],rc4_1.encode(a[1])==rc4_2.encode(a[1]))
print(a[0],a[1],ac.checkPassword(a[0],a[1]))
