bugfix

filemgr/filemgr.py

@@ -1,10 +1,19 @@
+import os
 from traceback import format_exc
 from ahserver.serverenv import get_serverenv
 from ahserver.auth_api import get_session_userinfo
 from sqlor.dbpools import DBPools
 from appPublic.uniqueID import getID
 from appPublic.log import debug, error, exception
-# from appbase.params import get_parmas
+from ahserver.filestorage import FileStorage
+import hashlib
+
+def get_file_hash(filepath, algo='sha256', chunk_size=8192):
+    h = hashlib.new(algo)
+    with open(filepath, 'rb') as f:
+        while chunk := f.read(chunk_size):
+            h.update(chunk)
+    return h.hexdigest()
 
 def get_dbname():
 	f = get_serverenv('get_module_dbname')
@@ -12,87 +21,57 @@ def get_dbname():
 	return dbname
 
 class FileMgr:
-	def __init__(self, biztype):
+	async def add_file(request, params_kw):
-		self.biztype = biztype
+		fs = FileStorage()
+		webpath = params_kw.upfile
+		realpath = fs.realpath(wwebpath)
+		filesize = os.path.getsize(realpath)
+		hashvalue = get_file_hash(realpath) 
+		dbname = get_dbname()
+		u = await get_session_userinfo(request)
+		db = DBPools()
+		async with db.sqlorContext(dbname) as sor:
+			recs = await sor.R('file',{'hashvalue': hashvalue})
+			if len(recs) > 0:
+				os.unlink(realpath)
+				r = recs[0]
+				webpath = r.webpath
+				realpath = r.realpath
+			ns = {
+				"id": getID(),
+				"folderid": params_kw.fid,
+				"fiid":params_kw.fiid,
+				"name":os.path.basename(params_kw.upfile),
+				"webpath": webpath,
+				"realpath": realpath, 
+				"filetpye":params_kw.upfile.split('.')[-1].lower(),
+				"filesize":filesize, 
+				"owner": u.userorgid,
+				"hashvalue": hashvalue
+			}
+			await sor.C('file', ns)
 	
-	async def get_bizinfo_nodes(self, request):
+	async def del_file(request, fid):
 		db = DBPools()
 		dbname = get_dbname()
 		async with db.sqlorContext(dbname) as sor:
-			return await self.sor_get_bizinfo_nodes(sor, request)
+			recs = await sor.R('file', {'id': fid})
-		return []
+			if recs:
+				delrec = recs[0]
+				await sor.D('file', {'id':fid})
+				remain = sor.R('file', {'hashvalue':delrec.hashvalue})
+				if not remain:
+					os.unlink(delrec.realpath)
 
-	async def sor_get_bizinfo_nodes(self, sor, request):
+	async def has_sub(request, sor, folderid):
-		userinfo = await get_session_userinfo(request)
+		sql = """select unique a.* from folder a 
-		ns = {
+    left join folder b on a.id = b.parentid 
-			'orgid':usrinfo.userorgid,
+    left join file c on a.id=c.folderid 
-			'biztype':self.biztype
+where id=${folderid}$"""
-		}
+		recs = await sor.sqlExe(sql, {'folderid':folderid})
-		recs = await sor.R('folderinfo', ns)
+		if recs:
-		return recs
-	
-	async def add_bizinfo_node(self, request, ns):
-		dbname = get_dbname()
-		db = DBPools()
-		async with db.sqlorContext(dbname) as sor:
-			return await self.sor_add_bizinfo_node(sor,request, ns)
-		return False
-	async def sor_add_bizinfo_node(self, sor, request, ns):
-			userinfo = await get_session_userinfo(request)
-			ns['orgid'] = userinfo.userorgid,
-			ns['biztype'] = self.biztype
-			ns['id'] = getID()
-			ns['cur_size'] = 0
-			# ns['max_size'] = await get_params(sor, userinfo.userid, 'folder_max_size');
-			await sor.C('folderinfo', ns)
-			return True
-	
-	async def delete_bizinfo_node(self, request, ns):
-		dbname = get_dbname()
-		db = DBPools()
-		async with db.sqlorContext(dbname) as sor:
-			return await self.sor_delete_bizinfo_node(self, sor, request, ns)
-		return False
-
-	async def sor_delete_bizinfo_node(self, sor, request, ns):
-		userinfo = await get_session_userinfo(request)
-		ns1['orgid'] = userinfo.userorgid,
-		ns1['biztype'] = self.biztype
-		ns1['id'] = ns['id']
-		await sor.D('folderinfo', ns1)
-		return True
-
-	async def update_bizinfo_node(self, request, ns):
-		dbname = get_dbname()
-		db = DBPools()
-		async with db.sqlorContext(dbname) as sor:
-			return self.sor_update_bizinfo_node(sor, request, ns)
-		return False
-
-	async def sor_update_bizinfo_node(self, sor, request, ns):
-		userinfo = await get_session_userinfo(request)
-		ns1['orgid'] = userinfo.userorgid,
-		ns1['biztype'] = self.biztype
-		ns1['id'] = ns['id']
-		recs = await sor.R('folderinfo', ns1)
-		if len(recs) > 0:
-			await sor.U('folderinfo', ns1)
 			return True
 		return False
-		
-	async def add_folder(self, request, ns):
-		dbname = get_dbname()
-		db = DBPools()
-		async with db.sqlorContext(dbname) as sor:
-			return await self.sor_add_folder(sor, request, ns)
-		return False
-	async def sor_add_folder(self, sor, request, ns):
-		userinfo = await get_session_userinfo(request)
-		ns1['orgid'] = userinfo.userorgid,
-		ns1['biztype'] = self.biztype
-		ns1['id'] = ns['id']
-		await sor.C('folderinfo', ns1)
-		return True
 
 	async def get_subfolder(self, request, fid, fiid):
 		userinfo = await get_session_userinfo(request)
@@ -100,110 +79,38 @@ class FileMgr:
 		db = DBPools()
 		async with db.sqlorContext(dbname) as sor:
 			return await self.sor_get_subfolder(sor, request, fid, fiid)
+			return await self.sor_get_subfile(sor, request, fid, fiid)
 		return []
 
 	async def sor_get_subfolder(self, sor, request, fid, fiid):
-		sql = """select x.*, 'folder' as rtype,
+		sql = """select x.*, 'folder' as filetype,
 case when y.id is null then 1
 else 0 end as is_left
-from (select a.id as fiid, b.* 
+from folder  as x left join (
-from folderinfo a, folder b
+select unique a.* from folder a 
-where a.id = ${fiid}$
+	left join folder b on a.id = b.parentid 
-	and b.fiid = a.id
+	left join file c on a.id=c.folderid 
-	and b.parentid = ${fid}$
+where b.id is not null or c.id is n
-	and a.orgid = ${orgid}$
+ot null;
-	and a.biztype = ${biztype}$
-order by name) as x left join (
-select unique a.* from folder a left join folder b on a.id = b.par
-entid where b.id is not NULL
 ) as y
 on x.id = y.id
+where x.parentid = ${fid}$ and fiid=${fiid}$
 """
 		ns = {
 			'fid':fid,
-			'fiid':fiid,
+			'fiid':fiid
-			'orgid':userinfo.userorgid,
-			'biztype':self.biztype
 		}
 		recs = await sor.sqlExe(sql, ns)
 		return recs
 	
-	async def get_files(self, request, fid, fiid):
+	async def sor_get_subfile(self, sor, request, fid, fiid):
-		dbname = get_dbname()
-		db = DBPools()
-		async with db.sqlorContext(dbname) as sor:
-			return await self.sor_get_files(sor, request, fid, fiid)
-		return []
-
-	async def sor_get_files(self, sor, request, fid, fiid):
 		userinfo = await get_session_userinfo(request)
-		sql = """select a.id as fiid, b.* 
+		sql = """select a.*, 1 as is_leaf from file where folderid=${fid}$ and fiid=${fiid}"""
-from folderinfo a, file b
-where a.id = ${fiid}$
-	and b.folderid = ${fid}$
-	and a.orgid = ${orgid}
-	and b.userid = ${userid}$
-	and a.biztype = ${biztype}$
-order by name"""
 		ns = {
 			'fid':fid,
-			'fiid':fiid,
+			'fiid':fiid
-			'userid':userinfo.userid,
-			'orgid':userinfo.userorgid,
-			'biztype':self.biztype
 		}
 		recs = await sor.sqlExe(sql, ns)
 		return recs
 		
-	async def get_folderinfo(self, sor, fiid):
-		dbname = get_dbname()
-		db = DBPools()
-		async with db.sqlorContext(dbname) as sor:
-			return await self.sor_get_folderinfo(sor, request, fid, fiid)
-		return []
-
-	async def sor_get_folderinfo(self, sor, fiid):
-		userinfo = await get_session_userinfo(request)
-		sql = """select * from folderinfo
-where id = ${fiid}$
-	and orgid = ${orgid}$
-	and biztype = ${biztype}$"""
-		ns = {
-			'id':fiid,
-			'orgid':userinfo.userorgid,
-			'biztype':self.biztype
-		}
-		recs = await sor.sqlExe(sql, ns)
-		if len(recs)>0:
-			return recs
-		return None
-
-	async def delete_file(self, request, fid, fiid):
-		dbname = get_dbname()
-		db = DBPools()
-		async with db.sqlorContext(dbname) as sor:
-			return await self.sor_delete_file(self, sor, request, fid, fiid)
-		return False
-	
-	async def sor_delete_file(self, sor, request, fid, fiid):
-		userinfo = await get_session_userinfo(request)
-		sql = """select a.id as fiid, b.* 
-from folderinfo a, file b
-where a.id = ${fiid}$
-	and b.id = ${fid}$
-	and a.orgid = ${orgid}
-	and b.userid = ${userid}$
-	and a.biztype = ${biztype}$"""
-		ns = {
-			'fid':fid,
-			'fiid':fiid,
-			'userid':userinfo.userid,
-			'orgid':userinfo.userorgid,
-			'biztype':self.biztype
-		}
-		recs = await sor.sqlExe(sql, ns)
-		if len(recs) > 0:
-			await sor.D('file', {'id': fid})
-			return True
-		return False