/// <summary>
/// 赋值Session
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public static void SetSession(string key, string value)
{
string json = SerializerJson.SerializeObject(value);
byte[] serializedResult = System.Text.Encoding.UTF8.GetBytes(json);
Compatible.HttpContext.Current.Session.Set(key, serializedResult);
}
public override void OnActionExecuting(ActionExecutingContext context)
{
base.OnActionExecuting(context);
Microsoft.Extensions.Primitives.StringValues token = context.HttpContext.Request.Headers["AccessToken"];
if (!string.IsNullOrWhiteSpace(token))
{
//存在AccessToken值，进行验证
RedisCacheTicket authBase = new RedisCacheTicket(token);
TicketEntity userTicket = authBase.CurrentUserTicket;
if (userTicket != null && userTicket.MemberID > 0)
{
CurrentUserTicket = userTicket;
return;
}
}
//直接输出结果，不经过Controller
ResponseResult result = new ResponseResult()
{
errno = 30,
errmsg = "请重新登录",
};
context.Result = new ContentResult()
{
Content = SerializerJson.SerializeObject(result), StatusCode = 200
};
}
/// <summary>
/// RPC服务端
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="exchange"></param>
/// <param name="queue"></param>
/// <param name="isProperties"></param>
/// <param name="handler"></param>
/// <param name="isDeadLetter"></param>
public void RpcService <T>(string exchange, string queue, bool isProperties, Func <T, T> handler, bool isDeadLetter)
{
//队列声明
var channel = GetModel(queue, isProperties);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var msgStr = body.StreamToStr();
var msg = SerializerJson.DeserializeObject <T>(msgStr);
var props = ea.BasicProperties;
var replyProps = channel.CreateBasicProperties();
replyProps.CorrelationId = props.CorrelationId;
try
{
msg = handler(msg);
}
catch (Exception ex)
{
//ex.GetInnestException().WriteToFile("队列接收消息", "RabbitMq");
}
finally
{
channel.BasicPublish(exchange, props.ReplyTo, replyProps, SerializerJson.SerializeObject(msg).StrToByte());
channel.BasicAck(ea.DeliveryTag, false);
}
};
channel.BasicConsume(queue, false, consumer);
}
/// <summary>
/// 发送短信
/// </summary>
/// <param name="mobile"></param>
/// <returns></returns>
public static bool SendMesssage(string mobile, string Content)
{
string url = string.Format("{0}:{1}/inter/sendSingleSMS", EMayConfig.Host, EMayConfig.Port);
SingMessage entity = new SingMessage()
{
content = Content,
mobile = mobile,
customsmsid = DateTime.Now.ToString("yyyyMMddHHmmsss"),
extendedcode = "",
requesttime = DateTime.Now.Ticks,
timertime = "",
requestvalidperiod = EMayConfig.ValidPeriod
};
HttpWebResponse response = null;
string json = SerializerJson.SerializeObject(entity);
byte[] byteArray = EMayConfig.IsCompress ? AESHelper.AESEncrypt(GzipHelper.GZipCompressString(json), EMayConfig.SecretKey) : AESHelper.AESEncrypt(json, EMayConfig.SecretKey);
byte[] result = HttpHelper.SendRequestData(url, byteArray, ref response);
string code = response.GetResponseHeader("result").ToString();
if (code == "SUCCESS")
{
string res = AESHelper.AESDecryptString(result, EMayConfig.SecretKey);
return(true);
}
else
{
return(false);
}
}
public override void OnActionExecuting(ActionExecutingContext context)
{
base.OnActionExecuting(context);
this.Ip = GetHostAddress();
bool a = context.HttpContext.Request.Cookies.ContainsKey("AccessToken");
bool b = context.HttpContext.Request.Cookies.TryGetValue("AccessToken", out string token);
string cb = string.Empty;;
bool c = context.HttpContext.Request.Cookies.TryGetValue("CabinetCode", out cb);
CabinetCode = cb;
if (b)
{
this.OpenId = token;
}
else
{
context.Result = new ContentResult()
{
Content = SerializerJson.SerializeObject(new
{
code = 30,
msg = "请重新登录",
}),
StatusCode = 200
};
}
}
/// <summary>
/// 启动服务
/// </summary>
public Task StartAsync(CancellationToken cancellationToken)
{
ConsumerService consumerService = new ConsumerService("DMS.QueueA");
//被动拉取对列消息，可以用定时任务来处理
consumerService.Pull <MessageBModel>(msg =>
{
//throw new Exception("Always fails!");
var json = SerializerJson.SerializeObject(msg);
Console.WriteLine(json);
});
//正常消费，不处理异常
//consumerService.Subscribe<MessageBModel>(msg =>
//{
// throw new Exception("Always fails!");
//});
//消费时异常，重新在次消费，可以设置消费的时间延迟消费
//consumerService.SubscribeRetry<MessageBModel>(msg =>
//{
// throw new Exception("Always fails!");
//});
return(Task.CompletedTask);
}
public bool Start()
{
_rabbitMqProxy.Subscribe <MessageModel>(msg =>
{
var json = SerializerJson.SerializeObject(msg);
Console.WriteLine(json);
});
return(true);
}
/// <summary>
/// 获取参数错误信息
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
public static string getResultInfo(object param)
{
if (Compatible.HttpContext.Current != null && Compatible.HttpContext.Current.Request != null && Compatible.HttpContext.Current.Request.Query["debug"] == "true")
{
if (param == null)
{
return("param is null！");
}
else
{
return(SerializerJson.SerializeObject(param));
}
}
return(string.Empty);
}
public bool Start()
{
var input = Input();
while (input.ToLower() != "n")
{
_rabbitMqProxy.Pull <MessageModel>(msg =>
{
Console.WriteLine(SerializerJson.SerializeObject(msg));
});
input = Input();
}
return(true);
}
/// <summary>
/// RPC客户端
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="command"></param>
/// <returns></returns>
public string RpcClient <T>(T command) where T : class
{
var queueInfo = GetRabbitMqAttribute <T>();
if (queueInfo.IsNullOrEmpty())
{
throw new ArgumentException("RabbitMqAttribute");
}
var body = SerializerJson.SerializeObject(command);
var exchange = queueInfo.ExchangeName;
var queue = queueInfo.QueueName;
var routingKey = queueInfo.ExchangeName;
var isProperties = queueInfo.IsProperties;
return(RpcClient(exchange, queue, routingKey, body, isProperties));
}
public override void OnActionExecuting(ActionExecutingContext context)
{
base.OnActionExecuting(context);
bool b = context.HttpContext.Request.Cookies.TryGetValue("AccessToken", out string token);
if (!b)
{
context.Result = new ContentResult()
{
Content = SerializerJson.SerializeObject(new
{
code = 30,
msg = "请重新登录",
}),
StatusCode = 200
};
}
}
private static void InitRedis(RedisEntityConfig redisconfig)
{
CSRedisClient client = null;
if (redisconfig.RedisMode == "Single")
{
client = new CSRedisClient(redisconfig.RedisConnectionSingle);
}
else if (redisconfig.RedisMode == "Multiple")
{
client = new CSRedisClient(null, redisconfig.RedisConnectionMultiple.ToArray());
}
else
{
throw new Exception("Redis初始化异常!,请检查配置文件");
}
RedisHelper.Initialization(client, value => SerializerJson.SerializeObject(value), deserialize: (data, type) => SerializerJson.DeserializeObject(data, type));
}
/// <summary>
/// 发布消息
/// </summary>
/// <param name="command">指令</param>
/// <returns></returns>
public void Publish <T>(T command) where T : class
{
//获取当前队列的特性
var queueInfo = GetRabbitMQAttribute <T>();
if (queueInfo.IsNullOrEmpty())
{
throw new ArgumentException(RabbitMqAttribute);
}
var body = SerializerJson.SerializeObject(command);
var exchange = queueInfo.ExchangeName;
var queue = queueInfo.QueueName;
var routingKey = queueInfo.ExchangeName;
var isProperties = queueInfo.IsProperties;
Publish(exchange, queue, routingKey, body, isProperties);
}
private static void InitRedis(ref IServiceCollection services, RedisEntityConfig redisconfig)
{
CSRedisClient client = null;
if (redisconfig.RedisMode == "Single")
{
client = new CSRedisClient(redisconfig.RedisConnectionSingle);
}
else if (redisconfig.RedisMode == "Multiple")
{
client = new CSRedisClient(null, redisconfig.RedisConnectionMultiple.ToArray());
}
else
{
throw new Exception("Redis初始化异常!,请检查配置文件");
}
RedisHelper.Initialization(client, value => SerializerJson.SerializeObject(value), deserialize: (data, type) => SerializerJson.DeserializeObject(data, type));
services.AddSingleton <IDistributedCache>(new TKBase.Framework.Redis.CSRedisCache(RedisHelper.Instance));
}
public override void OnActionExecuting(ActionExecutingContext context)
{
base.OnActionExecuting(context);
Ip = GetHostAddress();
bool a = context.HttpContext.Request.Headers.ContainsKey("AccessToken");
bool b = context.HttpContext.Request.Headers.TryGetValue("AccessToken", out Microsoft.Extensions.Primitives.StringValues token);
if (!string.IsNullOrWhiteSpace(token))
{
RedisCacheTicket authBase = new RedisCacheTicket(token);
TicketEntity userTicket = authBase.CurrUserInfo;
if (userTicket != null && userTicket.MemberID > 0)
{
CurrentUserTicket = userTicket;
}
else
{
//直接输出结果，不经过Controller
context.Result = new ContentResult()
{
Content = SerializerJson.SerializeObject(new
{
code = 30,
msg = "请重新登录",
}),
StatusCode = 200
};
}
}
else
{
context.Result = new ContentResult()
{
Content = SerializerJson.SerializeObject(new
{
code = 30,
msg = "请重新登录",
}),
StatusCode = 200
};
}
}
/// <summary>
/// 发布消息到死信队列
/// </summary>
/// <param name="body">死信信息</param>
/// <param name="ex">异常</param>
/// <param name="queue">死信队列名称</param>
/// <returns></returns>
private void PublishToDead <T>(string queue, string body, Exception ex) where T : class
{
var queueInfo = typeof(T).GetCustomAttribute <RabbitMqAttribute>();
if (queueInfo.IsNullOrEmpty())
{
throw new ArgumentException(RabbitMqAttribute);
}
var deadLetterExchange = queueInfo.ExchangeName;
string deadLetterQueue = queueInfo.QueueName;
var deadLetterRoutingKey = deadLetterExchange;
var deadLetterBody = new DeadLetterQueue
{
Body = body,
CreateDateTime = DateTime.Now,
ExceptionMsg = ex.Message,
Queue = queue,
RoutingKey = deadLetterExchange,
Exchange = deadLetterRoutingKey
};
Publish(deadLetterExchange, deadLetterQueue, deadLetterRoutingKey, SerializerJson.SerializeObject(deadLetterBody));
}
private string ConvertJson <T>(T value)
{
string result = value is string?value.ToString() : SerializerJson.SerializeObject(value);
return(result);
}
public static string SendRequestData <T>(string url, T data, ref HttpWebResponse response, CertificateEntity Certificate = null) where T : class
{
return(SendRequestData(url, SerializerJson.SerializeObject(data), ref response, Certificate));
}
/// <summary>
/// 保存一个对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="obj"></param>
/// <param name="expiry"></param>
/// <returns></returns>
public bool StringSet <T>(string key, T obj, TimeSpan?expiry = default(TimeSpan?)) where T : class
{
return(StringSet(key, SerializerJson.SerializeObject(obj), expiry));
}
/// <summary>
/// 发布
/// </summary>
/// <typeparam name="F"></typeparam>
/// <param name="Topic"></param>
/// <param name="Entity"></param>
public static void Publish <F>(string Topic, F Entity) where F : class
{
string Messsage = SerializerJson.SerializeObject(Entity);
Publish(Topic, Messsage);
}