sunliang
/
MinIO
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

--文件管理权限控制后台接口

Browse Source
master
程志刚 1 year ago
parent 413747ef7a
commit 59ec650181
2 changed files with 835 additions and 0 deletions
Show Stats Download Patch File Download Diff File

797
IBKLinker-Minio/Controller/MinioController/MinioApiController.cs
Unescape Escape View File

@ -168,5 +168,802 @@ namespace IBKLinker_Minio.Controller.MinioController
}
return result;
}
#region minio权限表
/// <summary>
/// 添加minio权限表
/// </summary>
/// <param name="cS_B04_PL_STEEL_ROW_COMP">合金配比策略一基表Model</param>
[HttpPost, Route("AddAuthority")]
public RequestEntity AddAuthority(MinioAuthority cS_B04_PL_STEEL_ROW_COMP)
{
RequestEntity request = new RequestEntity();
try
{
///创建数据库连接上下文对象
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
///拿到表自增长的值赋值给自增长主键pk
cS_B04_PL_STEEL_ROW_COMP.Id = getPk("S_MINIO_AUTHORITY", "MINIO_AUTHORITY");
///给创建时间赋值
cS_B04_PL_STEEL_ROW_COMP.CreatorTime = DateTime.Now;
///把需要添加的数据同步到数据库
db.Insert<MinioAuthority>(cS_B04_PL_STEEL_ROW_COMP);
request.code = "0";
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_AUTHORITY，minio权限表添加数据失败，错误原因:{0}", ex);
}
return request;
}
/// <summary>
/// 修改minio权限表
/// </summary>
/// <param name="data">修改数据</param>
[HttpPost, Route("UpdateAuthority")]
public RequestEntity UpdateAuthority(IList<MinioAuthority> data)
{
RequestEntity request = new RequestEntity();
try
{
///创建数据库连接上下文对象
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
try
{
///启动事务
db.BeginTransaction();
///给修改时间赋值
DateTime time = DateTime.Now;
db.Update<MinioAuthority>(data);
db.Commit();
request.code = "0";
}
catch (Exception ex)
{
request.code = "1";
db.Rollback();
///把错误日志写到日志文件
logger.ErrorFormat("主表:MINIO_AUTHORITY，修改minio权限表失败，错误原因:{0}", ex);
}
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_AUTHORITY，创建数据库连接对象，错误原因:{0}", ex);
}
return request;
}
/// <summary>
/// 删除minio权限表
/// </summary>
/// <param name="master">需要删除的数据</param>
[HttpPost, Route("RemoveAuthority")]
public RequestEntity RemoveAuthority(IList<MinioAuthority> master)
{
RequestEntity request = new RequestEntity();
try
{
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
db.BeginTransaction();
db.Delete<MinioAuthority>(master);
db.Commit();
request.code = "0";
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_AUTHORITY，创建数据库连接对象失败，错误原因:{0}", ex);
}
return request;
}
/// <summary>
/// 查询minio权限表
/// </summary>
/// <returns></returns>
[HttpPost, Route("GetAuthority")]
public RequestEntity GetAuthority(MinioAuthority minioAuthority)
{
RequestEntity request = new RequestEntity();
try
{
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
string sql = string.Empty;
IList<MinioAuthority> result = new List<MinioAuthority>();
if (!string.IsNullOrEmpty(minioAuthority.LimitsAuthorityId.ToString()))
{
sql += " and LIMITS_AUTHORITY_ID ='" + minioAuthority.LimitsAuthorityId +"'";
}
request.data = db.Query<MinioAuthority>("select * from MINIO_AUTHORITY where 1=1 " + sql + " ORDER BY PK");
request.code = "0";
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_AUTHORITY，查询minio权限表失败，错误原因:{0}", ex);
}
return request;
}
#endregion
#region minio角色表
/// <summary>
/// 添加minio角色表
/// </summary>
/// <param name="cS_B04_PL_STEEL_ROW_COMP">合金配比策略一基表Model</param>
[HttpPost, Route("AddUSER")]
public RequestEntity AddUSER(MinioUser minioUser)
{
RequestEntity request = new RequestEntity();
try
{
///创建数据库连接上下文对象
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
///拿到表自增长的值赋值给自增长主键pk
minioUser.UserId = getPk("S_MINIO_USER", "MINIO_USER");
///给创建时间赋值
minioUser.CreatorTime = DateTime.Now;
///把需要添加的数据同步到数据库
db.Insert<MinioUser>(minioUser);
request.code = "0";
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_USER，minio角色表添加数据失败，错误原因:{0}", ex);
}
return request;
}
/// <summary>
/// 修改minio角色表
/// </summary>
/// <param name="data">修改数据</param>
[HttpPost, Route("UpdateUSER")]
public RequestEntity UpdateUSER(IList<MinioUser> data)
{
RequestEntity request = new RequestEntity();
try
{
///创建数据库连接上下文对象
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
try
{
///启动事务
db.BeginTransaction();
///给修改时间赋值
DateTime time = DateTime.Now;
db.Update<MinioUser>(data);
db.Commit();
request.code = "0";
}
catch (Exception ex)
{
request.code = "1";
db.Rollback();
///把错误日志写到日志文件
logger.ErrorFormat("主表:MINIO_USER，修改minio角色表失败，错误原因:{0}", ex);
}
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_USER，创建数据库连接对象，错误原因:{0}", ex);
}
return request;
}
/// <summary>
/// 删除minio角色表
/// </summary>
/// <param name="master">需要删除的数据</param>
[HttpPost, Route("RemoveUSER")]
public RequestEntity RemoveUSER(IList<MinioUser> master)
{
RequestEntity request = new RequestEntity();
try
{
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
db.BeginTransaction();
db.Delete<MinioUser>(master);
db.Commit();
request.code = "0";
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_USER，创建数据库连接对象失败，错误原因:{0}", ex);
}
return request;
}
/// <summary>
/// 查询minio角色表
/// </summary>
/// <returns></returns>
[HttpPost, Route("GetUSER")]
public RequestEntity GetUSER(MinioUser minioUser)
{
RequestEntity request = new RequestEntity();
try
{
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
string sql = string.Empty;
IList<MinioUser> result = new List<MinioUser>();
if (!string.IsNullOrEmpty(minioUser.UserName.ToString()))
{
sql += " and USER_NAME ='" + minioUser.UserName+"'";
}
request.data = db.Query<MinioUser>("select * from MINIO_USER where 1=1 " + sql + " ORDER BY PK");
request.code = "0";
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_USER，查询minio角色表失败，错误原因:{0}", ex);
}
return request;
}
#endregion
#region minio文件关联表表
/// <summary>
/// 添加minio角色表
/// </summary>
/// <param name="minioFileassociation">合金配比策略一基表Model</param>
[HttpPost, Route("AddFileassociation")]
public RequestEntity AddFileassociation(MinioFileassociation minioFileassociation)
{
RequestEntity request = new RequestEntity();
try
{
///创建数据库连接上下文对象
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
///拿到表自增长的值赋值给自增长主键pk
minioFileassociation.Pk = getPk("S_MINIO_FILEASSOCIATION", "MINIO_FILEASSOCIATION");
///给创建时间赋值
minioFileassociation.CreatorTime = DateTime.Now;
///把需要添加的数据同步到数据库
db.Insert<MinioFileassociation>(minioFileassociation);
request.code = "0";
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_FILEASSOCIATION，minio文件关联表表添加数据失败，错误原因:{0}", ex);
}
return request;
}
/// <summary>
/// 修改minio角色表
/// </summary>
/// <param name="data">修改数据</param>
[HttpPost, Route("UpdateFileassociation")]
public RequestEntity UpdateFileassociation(IList<MinioFileassociation> data)
{
RequestEntity request = new RequestEntity();
try
{
///创建数据库连接上下文对象
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
try
{
///启动事务
db.BeginTransaction();
///给修改时间赋值
DateTime time = DateTime.Now;
db.Update<MinioFileassociation>(data);
db.Commit();
request.code = "0";
}
catch (Exception ex)
{
request.code = "1";
db.Rollback();
///把错误日志写到日志文件
logger.ErrorFormat("主表:MINIO_FILEASSOCIATION，修改minio文件关联表表失败，错误原因:{0}", ex);
}
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_FILEASSOCIATION，创建数据库连接对象，错误原因:{0}", ex);
}
return request;
}
/// <summary>
/// 删除minio角色表
/// </summary>
/// <param name="master">需要删除的数据</param>
[HttpPost, Route("RemoveFileassociation")]
public RequestEntity RemoveFileassociation(IList<MinioFileassociation> master)
{
RequestEntity request = new RequestEntity();
try
{
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
db.BeginTransaction();
db.Delete<MinioFileassociation>(master);
db.Commit();
request.code = "0";
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_FILEASSOCIATION，创建数据库连接对象失败，错误原因:{0}", ex);
}
return request;
}
/// <summary>
/// 查询minio角色表
/// </summary>
/// <returns></returns>
[HttpPost, Route("GetFileassociation")]
public RequestEntity GetFileassociation(MinioFileassociation minioFileassociation)
{
RequestEntity request = new RequestEntity();
try
{
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
string sql = string.Empty;
IList<MinioFileassociation> result = new List<MinioFileassociation>();
if (!string.IsNullOrEmpty(minioFileassociation.FileName.ToString()))
{
sql += " and FILE_NAME ='" + minioFileassociation.FileName+"'";
}
request.data = db.Query<MinioFileassociation>("select * from MINIO_FILEASSOCIATION where 1=1 " + sql + " ORDER BY PK");
request.code = "0";
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_FILEASSOCIATION，查询minio文件关联表表失败，错误原因:{0}", ex);
}
return request;
}
#endregion
#region minio角色权限表
/// <summary>
/// 添加minio角色权限表
/// </summary>
/// <param name="minioRolePermission">minio角色权限表</param>
[HttpPost, Route("AddRolePermission")]
public RequestEntity AddRolePermission(MinioRolePermission minioRolePermission)
{
RequestEntity request = new RequestEntity();
try
{
///创建数据库连接上下文对象
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
///拿到表自增长的值赋值给自增长主键pk
minioRolePermission.Pk = getPk("S_MINIO_ROLE_PERMISSION", "MINIO_ROLE_PERMISSION");
///给创建时间赋值
minioRolePermission.CreatorTime = DateTime.Now;
///把需要添加的数据同步到数据库
db.Insert<MinioRolePermission>(minioRolePermission);
request.code = "0";
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_ROLE_PERMISSION，minio角色权限表添加数据失败，错误原因:{0}", ex);
}
return request;
}
/// <summary>
/// 修改minio角色表
/// </summary>
/// <param name="data">修改数据</param>
[HttpPost, Route("UpdateRolePermission")]
public RequestEntity UpdateRolePermission(IList<MinioRolePermission> data)
{
RequestEntity request = new RequestEntity();
try
{
///创建数据库连接上下文对象
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
try
{
///启动事务
db.BeginTransaction();
///给修改时间赋值
DateTime time = DateTime.Now;
db.Update<MinioRolePermission>(data);
db.Commit();
request.code = "0";
}
catch (Exception ex)
{
request.code = "1";
db.Rollback();
///把错误日志写到日志文件
logger.ErrorFormat("主表:MINIO_ROLE_PERMISSION，修改minio角色权限表表失败，错误原因:{0}", ex);
}
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_ROLE_PERMISSION，创建数据库连接对象，错误原因:{0}", ex);
}
return request;
}
/// <summary>
/// 删除minio角色表
/// </summary>
/// <param name="master">需要删除的数据</param>
[HttpPost, Route("RemoveRolePermission")]
public RequestEntity RemoveRolePermission(IList<MinioRolePermission> master)
{
RequestEntity request = new RequestEntity();
try
{
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
db.BeginTransaction();
db.Delete<MinioRolePermission>(master);
db.Commit();
request.code = "0";
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_ROLE_PERMISSION，创建数据库连接对象失败，错误原因:{0}", ex);
}
return request;
}
/// <summary>
/// 查询minio角色表
/// </summary>
/// <returns></returns>
[HttpPost, Route("GetRolePermission")]
public RequestEntity GetRolePermission(MinioRolePermission minioRolePermission)
{
RequestEntity request = new RequestEntity();
try
{
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
string sql = string.Empty;
IList<MinioRolePermission> result = new List<MinioRolePermission>();
if (!string.IsNullOrEmpty(minioRolePermission.Id.ToString()))
{
sql += " and ID =" + minioRolePermission.Id;
}
request.data = db.Query<MinioRolePermission>("select * from MINIO_ROLE_PERMISSION where 1=1 " + sql + " ORDER BY PK");
request.code = "0";
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_ROLE_PERMISSION，查询minio角色权限表失败，错误原因:{0}", ex);
}
return request;
}
#endregion
#region minio文件文件夹路径表
/// <summary>
/// 添加minio文件文件夹路径表
/// </summary>
/// <param name="minioStoragePath">minio文件文件夹路径表</param>
[HttpPost, Route("AddStoragePath")]
public RequestEntity AddStoragePath(MinioStoragePath minioStoragePath)
{
RequestEntity request = new RequestEntity();
try
{
///创建数据库连接上下文对象
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
///拿到表自增长的值赋值给自增长主键pk
minioStoragePath.Pk = getPk("S_MINIO_STORAGE_PATH", "MINIO_STORAGE_PATH");
///给创建时间赋值
minioStoragePath.CreatorTime = DateTime.Now;
///把需要添加的数据同步到数据库
db.Insert<MinioStoragePath>(minioStoragePath);
request.code = "0";
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_STORAGE_PATH，minio文件文件夹路径表添加数据失败，错误原因:{0}", ex);
}
return request;
}
/// <summary>
/// 修改minio文件文件夹路径
/// </summary>
/// <param name="data">修改数据</param>
[HttpPost, Route("UpdateStoragePath")]
public RequestEntity UpdateStoragePath(IList<MinioStoragePath> data)
{
RequestEntity request = new RequestEntity();
try
{
///创建数据库连接上下文对象
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
try
{
///启动事务
db.BeginTransaction();
///给修改时间赋值
DateTime time = DateTime.Now;
db.Update<MinioStoragePath>(data);
db.Commit();
request.code = "0";
}
catch (Exception ex)
{
request.code = "1";
db.Rollback();
///把错误日志写到日志文件
logger.ErrorFormat("主表:MINIO_STORAGE_PATH，修改minio文件文件夹路径表失败，错误原因:{0}", ex);
}
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_STORAGE_PATH，创建数据库连接对象，错误原因:{0}", ex);
}
return request;
}
/// <summary>
/// 删除minio文件文件夹路径表
/// </summary>
/// <param name="master">需要删除的数据</param>
[HttpPost, Route("RemoveStoragePath")]
public RequestEntity RemoveStoragePath(IList<MinioStoragePath> master)
{
RequestEntity request = new RequestEntity();
try
{
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
db.BeginTransaction();
db.Delete<MinioStoragePath>(master);
db.Commit();
request.code = "0";
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_ROLE_PERMISSION，创建数据库连接对象失败，错误原因:{0}", ex);
}
return request;
}
/// <summary>
/// 查询minio文件文件夹路径表
/// </summary>
/// <returns></returns>
[HttpPost, Route("GetStoragePath")]
public RequestEntity GetStoragePath(MinioStoragePath minioStoragePath)
{
RequestEntity request = new RequestEntity();
try
{
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
string sql = string.Empty;
IList<MinioStoragePath> result = new List<MinioStoragePath>();
if (!string.IsNullOrEmpty(minioStoragePath.FileName.ToString()))
{
sql += " and FILE_NAME ='" + minioStoragePath.FileName+"'";
}
request.data = db.Query<MinioStoragePath>("select * from MINIO_STORAGE_PATH where 1=1 " + sql + " ORDER BY PK");
request.code = "0";
}
}
catch (Exception ex)
{
request.code = "1";
logger.ErrorFormat("主表:MINIO_STORAGE_PATH，查询minio文件文件夹路径表失败，错误原因:{0}", ex);
}
return request;
}
#endregion
#region minio文件菜单递归和权限判断
/// <summary>
/// 根据ID查询子菜单
/// </summary>
/// <param name="PK"></param>
/// <returns></returns>
public List<MinioStoragePath> GetMenuTree(string PK = "")
{
List<MinioStoragePath> date = new List<MinioStoragePath>();
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
string sql = string.Empty;
if (!string.IsNullOrEmpty(PK))
{
sql += " and UPK =" +int.Parse(PK);
}
date = db.Query<MinioStoragePath>("select * from MINIO_STORAGE_PATH where 1=1 " + sql + " ORDER BY PK").ToList();
}
return date;
}
/// <summary>
/// 获取根目录和根目录下一级得菜单信息
/// </summary>
/// <returns></returns>
public RequestEntity GetRecursion()
{
RequestEntity request = new RequestEntity();
try
{
//拿到根目录
List<RequstStoragePath> requstStoragePaths = new List<RequstStoragePath>();
List<MinioStoragePath> date = new List<MinioStoragePath>();
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
string sql = string.Empty;
date = db.Query<MinioStoragePath>("select * from MINIO_STORAGE_PATH ORDER BY PK").ToList();
}
if (date.Count > 0)
{
foreach (var item in date)
{
RequstStoragePath model = new RequstStoragePath();
model.Pk = item.Pk;
model.FileName = item.FileName;
model.FilePate = item.FilePate;
model.FileType = item.FileType;
model.requstStoragePaths = new List<StoragePath>();
List<MinioStoragePath> ds = GetMenuTree(item.Pk.ToString());
foreach (var items in ds)
{
StoragePath models = new StoragePath();
models.Pk = items.Pk;
models.FileName = items.FileName;
models.FilePate = items.FilePate;
models.FileType = items.FileType;
model.requstStoragePaths.Add(models);
}
requstStoragePaths.Add(model);
}
}
request.data = requstStoragePaths;
request.code = "0";
}
catch (Exception)
{
request.code = "1";
throw;
}
return request;
}
public bool GetEmpower(string UserID,string FileName,string EmpowerType)
{
//用户ID，文件ID，文件操作类型（查看/移动）
//通过用户ID查询用户得角色ID，
//判断当前角色是否有操作权限
//通过角色ID查询用户有权限得文件夹
return false;
}
#endregion
#region 公用方法
/// <summary>
/// 矫正pk值
/// </summary>
/// <param name="sequenceName"></param>
/// <param name="tableName"></param>
/// <returns></returns>
public Int32 getPk(String sequenceName, String tableName)
{
///创建数据库连接上下文对象
using (IDbContext db = ObjectContainer.GetObject<IDbContext>("db"))
{
///拿到表自增长序列最大pk值
int pk_SequenceCurrentMax = Convert.ToInt32(db.QueryScalar("select " + sequenceName + ".nextval from dual"));
///拿到表目前最大pk值
Object pk_TableCurrentMaxObj = db.QueryScalar("select t.pk from " + tableName + " t where rownum <=1 order by t.pk desc");
int pk_TableCurrentMax = pk_SequenceCurrentMax;
//如果表最大值查询结果不为空进行对比，
if (pk_TableCurrentMaxObj != null)
{
pk_TableCurrentMax = Convert.ToInt32(pk_TableCurrentMaxObj);
//拿到表中最大值和序列最大值之间的差值
int num_BetweenTableSequence = pk_TableCurrentMax - pk_SequenceCurrentMax + 1;
//更改序列递增规则，使下一次拿到的序列号比表中最大pk大1
db.QueryScalar("alter sequence " + sequenceName + " increment by " + num_BetweenTableSequence.ToString());
//执行nexval拿到下一个序列号
pk_TableCurrentMax = Convert.ToInt32(db.QueryScalar("select " + sequenceName + ".nextval from dual"));
//更改序列递增规则为每次递增一个。
db.QueryScalar("alter sequence " + sequenceName + " increment by 1");
}
return pk_TableCurrentMax;
}
}
#endregion
}
}

38
IBKLinker-Minio/Entity/MinioController/RequstStoragePath.cs
Unescape Escape View File

@ -0,0 +1,38 @@
using SOA.Persistent;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace IBKLinker_Minio.Entity.MinioController
{
public class StoragePath
{
/// <summary>
/// 主键
/// </summary>
public int Pk { get; set; }
/// <summary>
///文件名称
/// </summary>
public string FileName { get; set; }
/// <summary>
///文件类型
/// </summary>
public int FileType { get; set; }
/// <summary>
///文件路径
/// </summary>
public string FilePate { get; set; }
}
public class RequstStoragePath: StoragePath
{
public List<StoragePath> requstStoragePaths { get; set; }
}
}
Write Preview
Loading…
Cancel
Save