320 lines
12 KiB
C#
320 lines
12 KiB
C#
|
|
using AppLibs.Libs;
|
|
using Dapper;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.AspNetCore.Razor.Language.Intermediate;
|
|
using Microsoft.VisualBasic;
|
|
using MySqlConnector;
|
|
using Newtonsoft.Json;
|
|
using Newtonsoft.Json.Linq;
|
|
using System.Data.Common;
|
|
using System.Xml.Linq;
|
|
using TWASys_App.Dapper.AExtentions;
|
|
using TWASys_App.DBModels;
|
|
using TWASys_App.DBModels.SotrageModel;
|
|
|
|
namespace TWASys_App.Models
|
|
{
|
|
public class StorageModel : ModelBase
|
|
{
|
|
public long IdStorageServer { set; get; }
|
|
public long StorageTypeID { set; get; }
|
|
|
|
public string ControllerName { set; get; } = "";
|
|
|
|
public string StorageName { set; get; } = "";
|
|
|
|
public ICollection<ValidationDomain> ValidationDomains { set; get; } = new List<ValidationDomain>();
|
|
|
|
public int Size { set; get; }
|
|
public string IpPublic { set; get; } = "";
|
|
|
|
public string IpPrivatev4 { set; get; } = "";
|
|
|
|
public string IpPrivatev6 { set; get; } = "";
|
|
|
|
public string OsName { set; get; } = "";
|
|
|
|
public string OsPlatform { set; get; } = "";
|
|
|
|
public string OsVersion { set; get; } = "";
|
|
|
|
public string OsKernel { set; get; } = "";
|
|
|
|
public string OsArch { set; get; } = "";
|
|
|
|
public string BiosSN { set; get; } = "";
|
|
public string BiosVendor { set; get; } = "";
|
|
|
|
public string BiosUUID { set; get; } = "";
|
|
|
|
public int SocketN { set; get; }
|
|
|
|
public string CpuName { set; get; } = "";
|
|
|
|
public float TotalRam { set; get; }
|
|
|
|
public string TokenID { set; get; } = "";
|
|
|
|
public string TokenValue { set; get; } = "";
|
|
|
|
public string RTokenID { set; get; } = "";
|
|
|
|
public string RTokenValue { set; get; } = "";
|
|
|
|
public async Task<IActionResult> GetStorages(int status = 0)
|
|
{
|
|
await using (var con = new MySqlConnection(DBManagement.GetConnectionString()))
|
|
{
|
|
string sql = @"
|
|
WITH d AS (
|
|
SELECT *
|
|
FROM StorageServer
|
|
WHERE status = @status
|
|
ORDER BY idStorageServer
|
|
LIMIT @PageSize OFFSET @Offset)
|
|
SELECT d.*,t.typeName FROM d
|
|
JOIN TypeStorageServer t ON t.idTypeStorageServer = d.idTypeStorageServer;
|
|
";
|
|
await con.OpenAsync();
|
|
if (IsFirstQuery)
|
|
{
|
|
await using (var multi = await con
|
|
.QueryMultipleAsync("SELECT COUNT(*) FROM StorageServer;" + sql, new { Offset = (PageNumber - 1) * PageSize, PageSize = this.PageSize, status = status }))
|
|
{
|
|
int maxRow = await multi.ReadSingleAsync<int>();
|
|
var types = await multi.ReadAsync();
|
|
return new JsonResult(new
|
|
{
|
|
mrows = maxRow,
|
|
data = JsonConvert.SerializeObject(types)
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var t = (await con.QueryAsync(sql, new { Offset = (PageNumber - 1) * PageSize, PageSize = this.PageSize, status = status }));
|
|
return new JsonResult(new
|
|
{
|
|
data = JsonConvert.SerializeObject(t)
|
|
});
|
|
}
|
|
}
|
|
}
|
|
public override async Task<MessageHeader> AddAsync()
|
|
{
|
|
await using var con = new MySqlConnector.MySqlConnection(DBManagement.GetConnectionString(true));
|
|
|
|
await con.OpenAsync();
|
|
var trans = await con.BeginTransactionAsync();
|
|
var f = new MessageHeader();
|
|
try
|
|
{
|
|
var localServer = new LocalServer
|
|
{
|
|
IpPrivateServer = IpPrivatev4,
|
|
IpPrivateServerv6 = IpPrivatev6,
|
|
IpPublicServer = IpPublic,
|
|
PathServer = "",
|
|
SerialNumber = BiosSN,
|
|
OsVersion = OsVersion,
|
|
OsName = OsName,
|
|
OsArch = OsArch,
|
|
OsKernal = OsKernel,
|
|
SocketNum = SocketN,
|
|
CpuName = CpuName,
|
|
TotalRam = TotalRam,
|
|
BiosVender = BiosVendor,
|
|
ProductUuid = BiosUUID,
|
|
Status = 0
|
|
};//idTypeStorageServer
|
|
var storageServer = new StorageServer
|
|
{
|
|
IdEmp = null,
|
|
IdTypeStorageServer = StorageTypeID,
|
|
StorageName = StorageName,
|
|
CreateDate = DateTime.UtcNow,
|
|
ControllerID = ControllerName,
|
|
Status = 0
|
|
};
|
|
var ss_lc = new StorageServer_has_LocalServer
|
|
{
|
|
IdStorageServer = storageServer.IdStorageServer,
|
|
IdLocalServer = localServer.IdLocalServer,
|
|
CreateDate = DateTime.UtcNow,
|
|
ModifyDate = null,
|
|
Status = 0
|
|
};
|
|
|
|
var serverAuthorization = new ServerAuthorization
|
|
{
|
|
IdStorageServer = storageServer.IdStorageServer,
|
|
CreateDate = DateTime.UtcNow,
|
|
Count = 1,
|
|
Status = 0
|
|
};
|
|
var token = new Token
|
|
{
|
|
IdToken = TokenID,
|
|
AccessToken = TokenValue,
|
|
CreateDate = DateTime.UtcNow,
|
|
ExpireDate = DateTime.UtcNow.AddMonths(3),
|
|
Status = 0
|
|
};
|
|
var ssAT = new ServerAuthorization_has_Token
|
|
{
|
|
IdToken = TokenID,
|
|
Count = 1,
|
|
Status = 0
|
|
};
|
|
var rT = new RefreshToken
|
|
{
|
|
IdRefreshToken = RTokenID,
|
|
IdServerAuthorization = serverAuthorization.IdServerAuthorization,
|
|
__RefreshToken = RTokenValue,
|
|
CreateDate = DateTime.UtcNow,
|
|
ExpireDate = DateTime.UtcNow.AddMonths(9),
|
|
Status = 0
|
|
};
|
|
BatchInsert bi = new BatchInsert(con, trans);
|
|
bi.AddRow(localServer);
|
|
bi.AddRow(storageServer);
|
|
bi.AddRow(ss_lc);
|
|
bi.AddRow(serverAuthorization);
|
|
bi.AddRow(token);
|
|
bi.AddRow(ssAT);
|
|
bi.AddRow(rT);
|
|
await bi.ExcuteQuery();
|
|
await trans.CommitAsync();
|
|
f.Status = 1;
|
|
f.Message = "OK";
|
|
}
|
|
catch (DbException ex)
|
|
{
|
|
await trans.RollbackAsync();
|
|
await trans.DisposeAsync();
|
|
f.Status = 0;
|
|
f.Message = ex.Message;
|
|
f.ID = 61031;
|
|
}
|
|
return f;
|
|
}
|
|
|
|
public override Task<MessageHeader> DeleteAsync()
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
public override Task<MessageHeader> UpdateAsync()
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
private void ProccessToken(Dictionary<long, ServerAuthorization> dict, IList<dynamic> tokens, bool isToken =true)
|
|
{
|
|
foreach (dynamic token in tokens)
|
|
{
|
|
if (dict.ContainsKey(token.idServerAuthorization))
|
|
{
|
|
ServerAuthorization tm;
|
|
if (dict.TryGetValue(token.idServerAuthorization, out tm))
|
|
{
|
|
if (isToken)
|
|
{
|
|
tm.Tokens.Add(new Token { IdToken = token.idToken, AccessToken = token.accessToken, CreateDate = token.createDate, ExpireDate = token.expireDate });
|
|
}
|
|
else
|
|
{
|
|
tm.RefreshTokens.Add(new RefreshToken { });
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var tmp = new ServerAuthorization
|
|
{
|
|
IdServerAuthorization = token.idServerAuthorization
|
|
};
|
|
tmp.Tokens.Add(new Token { IdToken = token.idToken, AccessToken = token.accessToken });
|
|
dict.TryAdd(token.idServerAuthorization, tmp);
|
|
}
|
|
}
|
|
}
|
|
|
|
public async Task<MessageHeader> UpdateStorageSize()
|
|
{
|
|
var fMess = new MessageHeader();
|
|
string sql = @"UPDATE StorageServer
|
|
SET Size = @size
|
|
Where idStorageServer = @idStorage;
|
|
WITH sa_need AS (
|
|
SELECT idServerAuthorization
|
|
FROM ServerAuthorization
|
|
WHERE idStorageServer = @idStorage
|
|
),
|
|
maxc AS (
|
|
SELECT idServerAuthorization, MAX(`count`) AS max_count
|
|
FROM ServerAuthorization_has_Token
|
|
WHERE idServerAuthorization IN (SELECT idServerAuthorization FROM sa_need)
|
|
GROUP BY idServerAuthorization
|
|
)
|
|
SELECT
|
|
sa.idServerAuthorization,
|
|
st.idToken,
|
|
t.accessToken,
|
|
t.createDate,
|
|
t.expireDate
|
|
FROM sa_need sa
|
|
JOIN maxc m ON m.idServerAuthorization = sa.idServerAuthorization
|
|
JOIN ServerAuthorization_has_Token st
|
|
ON st.idServerAuthorization = sa.idServerAuthorization AND st.`count` = m.max_count
|
|
LEFT JOIN Token t ON t.idToken = st.idToken;
|
|
WITH sa_need AS (
|
|
SELECT idServerAuthorization
|
|
FROM ServerAuthorization
|
|
WHERE idStorageServer = @idStorage)
|
|
SELECT r.*
|
|
FROM sa_need s
|
|
JOIN RefreshToken r
|
|
ON r.idServerAuthorization = s.idServerAuthorization
|
|
WHERE r.idRefreshToken = (
|
|
SELECT r2.idRefreshToken
|
|
FROM RefreshToken r2
|
|
WHERE r2.idServerAuthorization = s.idServerAuthorization and r2.status = 0
|
|
ORDER BY r2.expireDate DESC
|
|
LIMIT 1);";
|
|
try
|
|
{
|
|
await using var con = new MySqlConnection(DBManagement.GetConnectionString(true));
|
|
await con.OpenAsync();
|
|
using var trans = await con.BeginTransactionAsync();
|
|
using var multi = await con.QueryMultipleAsync(sql, new { size = Size, id = IdStorageServer }, trans);
|
|
|
|
IList<dynamic> tokens = (await multi.ReadAsync()).AsList();
|
|
IList<dynamic> rTokens = (await multi.ReadAsync()).AsList();
|
|
Dictionary<long, ServerAuthorization> dict = new Dictionary<long, ServerAuthorization>();
|
|
ProccessToken(dict, tokens);
|
|
ProccessToken(dict, rTokens, false);
|
|
|
|
using (var writer = new StreamWriter(Path.GetFullPath("Json/dataServer.json"), false))
|
|
{
|
|
await writer.WriteAsync(JsonConvert.SerializeObject(new
|
|
{
|
|
idRToken = "",
|
|
rToken = "",
|
|
cDate = "",
|
|
eDate = "",
|
|
token = "",
|
|
idToken = ""
|
|
}));
|
|
}
|
|
}
|
|
catch (DbException ex)
|
|
{
|
|
|
|
}
|
|
return fMess;
|
|
}
|
|
}
|
|
}
|