18923810322/WMS-Api
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

domian-build

Browse Source
This commit is contained in:
tongfei
2023-10-18 10:37:41 +08:00
parent 9b739e2e37
commit 05ee79a04f
18 changed files with 2894 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

473
src/WMS.Web.Domain/Services/Public/SingleDataService.cs Normal file
View File

@@ -0,0 +1,473 @@
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using System;
using System.Collections.Generic;
using System.IdentityModel.Tokens.Jwt;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using WMS.Web.Core.Dto.SingleData;
using WMS.Web.Core.Internal.Results;
using WMS.Web.Domain.IService.Public;
using WMS.Web.Domain.Options;
using WMS.Web.Domain.Values.Single;
namespace WMS.Web.Domain.Services.Public
{
/// <summary>
/// 单点数据返回服务
/// </summary>
public class SingleDataService : ISingleDataService
{
private readonly AppOptions _options;
private readonly IHttpClientService _httpClientService;
private readonly ILogger<SingleDataService> _logger;
private readonly IMemoryCache _memoryCache;
private int hours = 10;//过期时间 默认10小时
public SingleDataService(IOptions<AppOptions> options, IHttpClientService httpClientService, ILogger<SingleDataService> logger, IMemoryCache memoryCache)
{
this._memoryCache = memoryCache;
this._options = options?.Value;
this._httpClientService = httpClientService;
this._logger = logger;
}
/// <summary>
/// 获取单点数据：根据接口方法名和公司ID
/// 后端列表查询统一使用
/// </summary>
/// <param name="action"></param>
/// <param name="companyId"></param>
/// <returns></returns>
public string GetSingleData(SingleAction action, int companyId, int id)
{
try
{
if (id == 0)
return "";
var cache_key = action + "_" + companyId + "_IdGetName";
var dic = _memoryCache.Get<Dictionary<int, string>>(cache_key);
if (dic == null || dic.Count <= 0 || !dic.ContainsKey(id))
{
if (dic != null)
{
string no_data_key = cache_key + "_NoData";
var cache_id = _memoryCache.Get<bool>(no_data_key);
if (cache_id == true) return "";
//未找到数据请求
if (!dic.ContainsKey(id))
{
_memoryCache.Set(no_data_key, true, new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromMinutes(30)));
}
}
var list = SingleDataPost<SingleDataResponse>(action, companyId, cache_key);
if (list.Count() <= 0) return "";
dic = list.ToDictionary(s => s.Id, s => s.Name);
_memoryCache.Set(cache_key, dic, new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromHours(hours)));
}
if (!dic.ContainsKey(id)) return "";
return dic[id];
}
catch (Exception ex)
{
_logger.LogError($"请求单点数据错误：Action->{action.ToString()}，CompanyeId->{companyId},Id->{id}，(错误原因)=>{ex.Message}");
return "";
}
}
/// <summary>
/// 获取单点数据：根据接口方法名和公司ID
/// 后端列表查询统一使用
/// </summary>
/// <param name="action"></param>
/// <param name="companyId"></param>
/// <returns></returns>
public decimal GetSingleDataNumber(SingleAction action, int companyId, int id)
{
try
{
if (id == 0)
return 0;
var cache_key = action + "_" + companyId + "_IdGetNumber";
var dic = _memoryCache.Get<Dictionary<int, decimal>>(cache_key);
if (dic == null || dic.Count <= 0 || !dic.ContainsKey(id))
{
if (dic != null)
{
string no_data_key = cache_key + "_NoData";
var cache_id = _memoryCache.Get<bool>(no_data_key);
if (cache_id == true) return 0;
//未找到数据请求
if (!dic.ContainsKey(id))
{
_memoryCache.Set(no_data_key, true, new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromMinutes(30)));
}
}
var list = SingleDataPost<SingleDataResponse>(action, companyId, cache_key);
if (list.Count() <= 0) return 0;
dic = list.ToDictionary(s => s.Id, s => s.Number);
_memoryCache.Set(cache_key, dic, new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromHours(hours)));
}
if (!dic.ContainsKey(id)) return 0;
return dic[id];
}
catch (Exception ex)
{
_logger.LogError($"请求单点数据错误：{action.ToString()}=>{ex.Message}");
return 0;
}
}
/// <summary>
/// 获取单点数据：根据接口方法名和公司ID
/// 后端列表查询统一使用
/// </summary>
/// <param name="action"></param>
/// <param name="companyId"></param>
/// <returns></returns>
public string GetSingleDataCode(SingleAction action, int companyId, int id)
{
try
{
if (id == 0)
return "";
var cache_key = action + "_" + companyId + "_IdGetCode";
var dic = _memoryCache.Get<Dictionary<int, string>>(cache_key);
if (dic == null || dic.Count <= 0 || !dic.ContainsKey(id))
{
if (dic != null)
{
string no_data_key = cache_key + "_NoData";
var cache_id = _memoryCache.Get<bool>(no_data_key);
if (cache_id == true) return "";
//未找到数据请求
if (!dic.ContainsKey(id))
{
_memoryCache.Set(no_data_key, true, new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromMinutes(30)));
}
}
var list = SingleDataPost<SingleDataResponse>(action, companyId, cache_key);
if (list.Count() <= 0) return "";
dic = list.ToDictionary(s => s.Id, s => s.Code);
_memoryCache.Set(cache_key, dic, new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromHours(hours)));
}
if (!dic.ContainsKey(id)) return "";
return dic[id];
}
catch (Exception ex)
{
_logger.LogError($"请求单点数据错误：{action.ToString()}=>{ex.Message}");
return "";
}
}
/// <summary>
/// 根据名字模糊匹配
/// </summary>
/// <param name="action"></param>
/// <param name="companyId"></param>
/// <param name="name"></param>
/// <returns></returns>
public List<int> GetIdsBySingleName(SingleAction action, int companyId, string name)
{
try
{
var cache_key = action + "_" + companyId + "_NameGetIds";
var dic = _memoryCache.Get<Dictionary<int, string>>(cache_key);
if (dic == null || dic.Count <= 0)
{
var list = SingleDataPost<SingleDataResponse>(action, companyId, cache_key);
if (list.Count() <= 0) return new List<int>();
dic = list.ToDictionary(s => s.Id, s => s.Name);
_memoryCache.Set(cache_key, dic, new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromHours(hours)));
}
var res = from d in dic where d.Value.Contains(name) select d;
return res.Select(s => s.Key).ToList();
}
catch (Exception ex)
{
_logger.LogError($"请求单点数据错误：{action.ToString()}=>{ex.Message}");
return new List<int>();
}
}
/// <summary>
/// 获取单点数据：根据接口方法名和公司ID
/// 后端列表查询统一使用
/// </summary>
/// <param name="action"></param>
/// <param name="companyId"></param>
/// <returns></returns>
public string GetSingleData(SingleAction action, int companyId, string code)
{
try
{
if (string.IsNullOrEmpty(code))
return "";
var cache_key = action + "_" + companyId + "_CodeGetName";
var dic = _memoryCache.Get<Dictionary<string, string>>(cache_key);
//仓库和客户仓库 不能为空了就重新请求 应为 这里是从仓库和客户仓库取值 有一个必然取不到
if (dic == null || dic.Count <= 0)
{
if (dic != null)
{
string no_data_key = cache_key + "_NoData";
var cache_id = _memoryCache.Get<bool>(no_data_key);
if (cache_id == true) return "";
//未找到数据请求
if (!dic.ContainsKey(code))
{
_memoryCache.Set(no_data_key, true, new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromMinutes(30)));
}
}
var list = SingleDataPost<SingleDataResponse>(action, companyId, cache_key);
if (list.Count() <= 0) return "";
dic = list.ToDictionary(s => s.Code, s => s.Name);
_memoryCache.Set(cache_key, dic, new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromHours(hours)));
}
if (!dic.ContainsKey(code)) return "";
return dic[code];
}
catch (Exception ex)
{
_logger.LogError($"请求单点数据错误：{action.ToString()}=>{ex.Message}");
return "";
}
}
/// <summary>
/// 获取单点数据集合：泛型-同步
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="action"></param>
/// <param name="companyId"></param>
/// <returns></returns>
public List<T> GetSingleData<T>(SingleAction action, int companyId) where T : class
{
try
{
var cache_key = action + "_list_" + companyId;
var list = _memoryCache.Get<List<T>>(cache_key);
if (list == null || list.Count <= 0)
list = SingleDataPost<T>(action, companyId, cache_key);
return list;
}
catch (Exception ex)
{
_logger.LogError($"请求单点数据错误：{action.ToString()}=>{ex.Message}");
return null;
}
}
/// <summary>
/// 获取单点数据集合：泛型-异步
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="action"></param>
/// <param name="companyId"></param>
/// <returns></returns>
public async Task<List<T>> GetSingleDataAsync<T>(SingleAction action, int companyId) where T : class
{
try
{
var cache_key = action + "_list_" + companyId;
var list = _memoryCache.Get<List<T>>(cache_key);
if (list == null || list.Count <= 0)
list = await SingleDataPostAsync<T>(action, companyId, cache_key);
return list;
}
catch (Exception ex)
{
_logger.LogError($"请求单点数据错误：{action.ToString()}=>{ex.Message}");
return null;
}
}
/// <summary>
/// 获取单点数据集合：泛型-异步-无缓存
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="action"></param>
/// <param name="companyId"></param>
/// <returns></returns>
public async Task<List<T>> GetSingleDataNoCacheAsync<T>(SingleAction action, int companyId) where T : class
{
try
{
var list = await SingleDataPostAsync<T>(action, companyId, "");
return list;
}
catch (Exception ex)
{
_logger.LogError($"请求单点数据错误：{action.ToString()}=>{ex.Message}");
return null;
}
}
/// <summary>
/// 单点数据：可对接全部接口
/// </summary>
/// <typeparam name="T">返回对象</typeparam>
/// <typeparam name="X">请求对象</typeparam>
/// <typeparam name="Y">方法名称</typeparam>
/// <param name="dto">请求对象</param>
/// <param name="action">方法名称</param>
/// <param name="type">控制器名称</param>
/// <returns></returns>
public async Task<T> GetSingleData<T, X, Y>(X dto, Y action, SingleControllerType type = SingleControllerType.Single) where T : class
{
try
{
var para = JsonExtensions.SerializeToJson(dto);
var cache_key = action + "_list_" + type + "_" + para;
var list = _memoryCache.Get<T>(cache_key);
if (list == null)
{
var url = _options.SingleBaseUrl + "/" + type.ToString() + "/" + action.ToString();
var result = await _httpClientService.PostAsync<T>(url, para);
_memoryCache.Set(cache_key, result, new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromHours(hours)));
}
return _memoryCache.Get<T>(cache_key);
}
catch (Exception ex)
{
_logger.LogError($"请求单点数据错误：{action.ToString()}=>{ex.Message}");
return default(T);
}
}
/// <summary>
/// 单点数据：可对接全部接口
/// </summary>
/// <typeparam name="T">返回对象</typeparam>
/// <typeparam name="X">请求对象</typeparam>
/// <typeparam name="Y">方法名称</typeparam>
/// <param name="dto">请求对象</param>
/// <param name="action">方法名称</param>
/// <param name="type">控制器名称</param>
/// <returns></returns>
public async Task<T> GetSingleDataNoCache<T, X, Y>(X dto, Y action, SingleControllerType type = SingleControllerType.Single) where T : class
{
try
{
var para = JsonExtensions.SerializeToJson(dto);
var url = _options.SingleBaseUrl + "/" + type.ToString() + "/" + action.ToString();
var result = await _httpClientService.PostAsync<T>(url, para);
return result;
}
catch (Exception ex)
{
_logger.LogError($"请求单点数据错误：{action.ToString()}=>{ex.Message}");
return default(T);
}
}
/// <summary>
/// 获取单点数据：配置项接口
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="X"></typeparam>
/// <param name="dto"></param>
/// <param name="action"></param>
/// <returns></returns>
public async Task<T> GetSysConfigData<T, X>(X dto, SysConfigAction action)
{
try
{
var para = JsonExtensions.SerializeToJson(dto);
var url = _options.SingleBaseUrl + "/" + SingleControllerType.SysConfig.ToString() + "/" + action.ToString();
var result = await _httpClientService.PostAsync<T>(url, para);
return result;
}
catch (Exception ex)
{
_logger.LogError($"请求单点数据错误：{action.ToString()}=>{ex.Message}");
return default(T);
}
}
#region 私有方法
/// <summary>
/// 请求单点服务接口：同步
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="action"></param>
/// <param name="companyId"></param>
/// <returns></returns>
private List<T> SingleDataPost<T>(SingleAction action, int companyId, string cache_key)
{
var dto = new SingleDataRequest(companyId);
//var para = JsonExtensions.SerializeToJson(dto);
var para = JsonSerializer.Serialize(dto);
var url = _options.SingleBaseUrl + "/" + SingleControllerType.Single.ToString() + "/" + action.ToString();
var result = _httpClientService.PostAsync<ResultList<T>>(url, para).GetAwaiter().GetResult();
if (!result.Success)
return new List<T>();
return result.Data.ToList();
}
/// <summary>
/// 请求单点服务接口：异步
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="action"></param>
/// <param name="companyId"></param>
/// <returns></returns>
private async Task<List<T>> SingleDataPostAsync<T>(SingleAction action, int companyId, string cache_key)
{
var dto = new SingleDataRequest(companyId);
var para = JsonSerializer.Serialize(dto);
var url = _options.SingleBaseUrl + "/" + SingleControllerType.Single.ToString() + "/" + action.ToString();
var result = await _httpClientService.PostAsync<ResultList<T>>(url, para);
if (result.Success)
{
if (!string.IsNullOrEmpty(cache_key))
{
_memoryCache.Set(cache_key, result.Data.ToList(), new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromHours(hours)));
return _memoryCache.Get<List<T>>(cache_key);
}
return result.Data.ToList();
}
return null;
}
#endregion
/// <summary>
/// 获取客户仓库
/// </summary>
/// <param name="companyId"></param>
/// <param name="customerStockCode"></param>
/// <returns></returns>
public string GetCustomerStock(int companyId, string customerStockCode)
{
return string.IsNullOrEmpty(this.GetSingleData(SingleAction.CustomerStocks, companyId, customerStockCode)) ?
this.GetSingleData(SingleAction.Stocks, companyId, customerStockCode) :
this.GetSingleData(SingleAction.CustomerStocks, companyId, customerStockCode);
}
}
}