/// <summary>
/// 持久化Redis Token
/// </summary>
/// <param name="userID">The user identifier.</param>
/// <param name="rememberPassword">if set to <c>true</c> [remember password].</param>
/// <returns></returns>
/// 时间：2018/1/17
/// 修改：李允智
private string GenerateAndStoreToken(string userID, bool rememberPassword)
{
var redis = this.RedisProvider.GetDatabase();
string token = EncryptHelper.EncryptMD5(Guid.NewGuid().ToString());
string key = RedisKeys.GetTokenCacheKey(token);
redis.StringSet(key, userID);
if (!rememberPassword)
{
redis.KeyExpire(key, DateTime.Now.AddDays(7));
}
else
{
redis.KeyExpire(key, DateTime.Now.AddDays(30));
}
//用户信息是写到Redis里的
string userToken = TOKEN_KEY + userID;
var user = redis.JsonGet <UserModel>(userToken);
if (user == null)
{
UserModel _user = new UserModel();
_user.UserName = userID;
_user.Avatar = DashboardConfig.DefaultAvatar;
_user.Sex = SexType.female;
_user.NickName = userID;
redis.StringSetAsync(userToken, JsonConvert.SerializeObject(_user));
}
return(token);
}
public HttpResponseMessage GetRechargeOrder([FromBody] CC_Order order)
{
try
{
var db = new RedisOperation(_RedisDB);
var key = RedisKeys.CCRechargeOrder(order.CustomerID);
var result = db.SelectListQueue <CC_Order>(key);
if (result.CustomerID.IsNullStr())
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.DataNotFound,
Message = "success"
}));
}
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel <CC_Order>
{
Code = ResponseCode.Success,
Message = "success",
Result = result
}));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Fail,
Message = "fail:" + ex.Message
}));
}
}
public HttpResponseMessage GetOrderSend([FromBody] CC_OrderSend OrderSend)
{
try
{
var db = new RedisOperation(_RedisDB);
var key = RedisKeys.CCOrderSend(OrderSend.CustomerID);
var result = db.SelectListQueue <CC_OrderSend>(key);
if (result.CustomerID.IsNullStr() || result.ConfigData == null || result.OrderSendData == null)
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.DataNotFound,
Message = "success"
}));
}
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel <CC_OrderSend>
{
Code = ResponseCode.Success,
Message = "success",
Result = result
}));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Fail,
Message = "fail:" + ex.Message
}));
}
}
public HttpResponseMessage GetConnection([FromBody] CC_Connection connection)
{
try
{
var db = new RedisOperation(_RedisDB);
var key = RedisKeys.CCConnectionKey(connection.CustomerID);
var result = db.SelectString <CC_Connection>(key);
if (result.Customer_Name.IsNullStr() || result.ConnectionStr.IsNullStr())
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.DataNotFound,
Message = "success"
}));
}
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel <CC_Connection>
{
Code = ResponseCode.Success,
Message = "success",
Result = result
}));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Fail,
Message = "fail:" + ex.Message
}));
}
}
public HttpResponseMessage GetBasicSetting([FromBody] CC_BasicSetting basicSetting)
{
try
{
var db = new RedisOperation(_RedisDB);
var key = RedisKeys.CCBasicSetting(basicSetting.CustomerId);
var result = db.SelectString <CC_BasicSetting>(key);
if (result.CustomerId.IsNullStr() || result.SettingList.Count <= 0)
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.DataNotFound,
Message = "success"
}));
}
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel <CC_BasicSetting>
{
Code = ResponseCode.Success,
Message = "success",
Result = result
}));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Fail,
Message = "fail:" + ex.Message
}));
}
}
/// <summary>
/// 添加一条消息
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task Add(AddMessageModel model)
{
long messageID;
using (var uw = this.CreateUnitOfWork())
{
var entity = new Message
{
CommentID = model.Comment,
CreateDate = DateTime.Now,
FromUserID = model.FromUser,
TopicID = model.Topic,
ToUserID = model.ToUser,
Type = model.Type
};
await uw.InsertAsync(entity);
messageID = entity.ID;
}
var redis = this.RedisProvider.GetDatabase();
string key = RedisKeys.GetUserMessageCacheKey(model.ToUser);
await redis.SetAddAsync(key, messageID);
}
public async Task <bool> AddServer(Server server)
{
var database = _connectionMultiplexer.GetDatabase();
var redisResult = await database.ScriptEvaluateAsync(
_addServerScript,
parameters : new
{
serverKey = RedisKeys.Servers(server.Secret),
serversByCodeKey = RedisKeys.ServersByCode,
publicServersByPlayerCountKey = RedisKeys.PublicServersByPlayerCount,
hostUserId = (RedisValue)server.Host.UserId,
hostUserName = (RedisValue)server.Host.UserName,
remoteEndPoint = (RedisValue)server.RemoteEndPoint.ToString(),
secret = (RedisValue)server.Secret,
code = (RedisValue)server.Code,
isPublic = (RedisValue)server.IsPublic,
discoveryPolicy = (RedisValue)(int)server.DiscoveryPolicy,
invitePolicy = (RedisValue)(int)server.InvitePolicy,
beatmapDifficultyMask = (RedisValue)(int)server.BeatmapDifficultyMask,
gameplayModifiersMask = (RedisValue)(int)server.GameplayModifiersMask,
songPackBloomFilterTop = (RedisValue)server.SongPackBloomFilterTop,
songPackBloomFilterBottom = (RedisValue)server.SongPackBloomFilterBottom,
currentPlayerCount = (RedisValue)server.CurrentPlayerCount,
maximumPlayerCount = (RedisValue)server.MaximumPlayerCount,
random = (RedisValue)server.Random,
publicKey = (RedisValue)server.PublicKey
},
flags : CommandFlags.DemandMaster
);
return((bool)redisResult);
}
public HttpResponseMessage GetRole([FromBody] CC_Role role)
{
try
{
var db = new RedisOperation(_RedisDB);
var key = RedisKeys.CCMenuRoleKey(role.CustomerID, role.RoleID);
var result = db.SelectString <CC_Role>(key);
if (result.RoleID.IsNullStr() || result.MenuList.Count <= 0)
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.DataNotFound,
Message = "success"
}));
}
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel <CC_Role>
{
Code = ResponseCode.Success,
Message = "success",
Result = result
}));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Fail,
Message = "fail:" + ex.Message
}));
}
}
public async Task <List <string> > GetLogsAsync(string id, int page, int count)
{
var key = RedisKeys.SentryList(SentryEnum.Log, id);
var l = await _redis.ListLengthAsync(key);
if (l < 1)
{
return(new List <string>());
}
var s = l - count * page;
if (s < 1)
{
return(new List <string>());
}
var e = l - count * (page - 1);
if (e < 0)
{
e = 0;
}
var r = await _redis.ListRangeAsync(
key,
l - count *page,
l - count *(page - 1)
);
return(r.Select(x => x.ToString()).ToList());
}
public HttpResponseMessage GetSuperRetailTraderOrder([FromBody] CC_Order Order)
{
try
{
var db = new RedisOperation(_RedisDB);
var key = RedisKeys.CCSuperRetailTraderOrder(Order.CustomerID);
var result = db.SelectListQueue <CC_Order>(key); //队列按照先进先出的原则，左边进右边出
if (result.CustomerID.IsNullStr() || result.LogSession == null || result.OrderInfo == null)
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.DataNotFound,
Message = "success"
}));
}
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel <CC_Order>
{
Code = ResponseCode.Success,
Message = "success",
Result = result
}));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Fail,
Message = "fail:" + ex.Message
}));
}
}
/// <summary>
/// 查询未读消息数目
/// </summary>
/// <param name="userID"></param>
/// <returns></returns>
public long QueryUnreadCount(long userID)
{
var redis = this.RedisProvider.GetDatabase();
string key = RedisKeys.GetUserMessageCacheKey(userID);
return(redis.SetLength(key));
}
public void LogOut()
{
if (this.SecurityManager.Token != null)
{
var database = this.RedisProvider.GetDatabase();
string key = RedisKeys.GetTokenCacheKey(SecurityManager.Token);
database.KeyDelete(key);
}
}
public Task AddAssetPairPriceAsync(AssetPairPrice assetPair)
{
var tasks = new List <Task>
{
_database.HashSetAsync(RedisKeys.GetMarketProfileKey(assetPair.AssetPair), assetPair.ToHashEntries()),
_database.SetAddAsync(RedisKeys.GetAssetPairsKey(), assetPair.AssetPair)
};
return(Task.WhenAll(tasks));
}
public CancellationTokenSource StartLogs(DockerClient client,
string id,
Action <string, string, long> backCall = null)
{
var cancellationTokenSource = new CancellationTokenSource();
var progress = new Progress <string>();
var queue = new ConcurrentQueue <string>();
var key = RedisKeys.SentryList(SentryEnum.Log, id);
// 重置这个redis
_redis.KeyDelete(key);
progress.ProgressChanged += (obj, message) =>
{
queue.Enqueue(message);
};
_ = Task.Run(async() => // 每 5ms 存储一次
{
while (true)
{
if (queue.TryDequeue(out var message))
{
var rule = "[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}.[0-9]{9}Z";
var time = Regex.Matches(message, rule)[0].Value;
var v = message.Split(new[] { time }, StringSplitOptions.None)[1]
.Replace("\u001b[40m\u001b[1m\u001b[33mwarn\u001b[39m\u001b[22m\u001b[49m:", "[warn]")
.Replace("\u001B[41m\u001B[30mfail\u001B[39m\u001B[22m\u001B[49m", "[fail]");
var l = _redis.ListRightPush(key, new { time, log = v });
if (backCall != null)
{
backCall(id, v, l);
}
}
await Task.Delay(5);
}
}, cancellationTokenSource.Token);
_ = client.Containers.GetContainerLogsAsync(
id,
new ContainerLogsParameters
{
// as the error said, you have to choose one stream either stdout or stderr. If you don't input any of these option to be true, it would panic.
ShowStdout = true,
ShowStderr = true,
Timestamps = true,
Follow = true
},
cancellationTokenSource.Token,
progress
);
return(cancellationTokenSource);
}
private static void PushEntities()
{
Console.WriteLine($"How much Entities to push in queue: ");
var targets = _TargetService.InitializeTargets(Int32.Parse(Console.ReadLine()));
foreach (var target in targets)
{
var targetJson = JsonConvert.SerializeObject(target);
_RedisService.RightPush(RedisKeys.ListTargetsKey(), targetJson);
}
}
public HttpResponseMessage SetCouponList([FromBody] CC_Coupon couponData)
{
try
{
var db = new RedisOperation(_RedisDB);
var key = RedisKeys.CCCouponKey(couponData.CustomerId, couponData.CouponTypeId);
//
var coupons = new List <CC_Coupon>();
for (var i = 0; i < couponData.CouponLenth; i++)
{
coupons.Add(couponData.DeepClone());
}
//
var total = couponData.CouponLenth;
var limit = 100;
var start = 0;
//
do
{
//
var models = coupons.Skip(start).Take(limit).ToList();
//
db.InsertListQueueBatch <CC_Coupon>(key, models);
//
if (start < (total - limit))
{
start = start + limit;
}
else
{
start = total;
}
}while (start < total);
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Success,
Message = "success"
}));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Fail,
Message = "fail:" + ex.Message
}));
}
}
public void UpdateCurrentPlayerCount(string secret, int currentPlayerCount)
{
var database = _connectionMultiplexer.GetDatabase();
database.ScriptEvaluate(
_updateCurrentPlayerCountScript,
parameters: new
{
serverKey = RedisKeys.Servers(secret),
currentPlayerCount = (RedisValue)currentPlayerCount
},
flags: CommandFlags.DemandMaster | CommandFlags.FireAndForget
);
}
public async Task <Server> GetServer(string secret)
{
var database = _connectionMultiplexer.GetDatabase();
var hashEntries = await database.HashGetAllAsync(RedisKeys.Servers(secret));
if (!hashEntries.Any())
{
return(null);
}
var server = GetServerFromHashEntries(hashEntries);
server.Secret = secret;
return(server);
}
public async Task <bool> RemoveServer(string secret)
{
var database = _connectionMultiplexer.GetDatabase();
var redisResult = await database.ScriptEvaluateAsync(
_removeServerScript,
parameters : new
{
serverKey = RedisKeys.Servers(secret),
serversByCodeKey = RedisKeys.ServersByCode,
publicServersByPlayerCountKey = RedisKeys.PublicServersByPlayerCount,
secret = (RedisValue)secret
},
flags : CommandFlags.DemandMaster
);
return((bool)redisResult);
}
/// <summary>
/// 加载用户信息
/// </summary>
/// 时间：2018/1/17
/// 修改：李允智
private void LoadUser()
{
this.InitToken();
if (string.IsNullOrWhiteSpace(this.Token))
{
return;
}
var redis = this.RedisProvider.GetDatabase();
string tokenKey = RedisKeys.GetTokenCacheKey(this.Token);
var id = redis.StringGet(tokenKey);
if (id.HasValue)
{
var oaAuthService = this.ServiceProvider.GetService <OAAuthService>();
_user = oaAuthService.Get(id.ToString());
}
}
public HttpResponseMessage SetActivityVipId([FromBody] ActivityVipMapping data)
{
try {
var db = new RedisOperation(_RedisDB);
var key = RedisKeys.CCActivity(data.CustomerId, data.ActivityId);
var result = db.InsertSet(key, data.VipId);
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel {
Code = ResponseCode.Success,
Message = "success"
}));
}
catch (Exception ex) {
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel {
Code = ResponseCode.Fail,
Message = "fail:" + ex.Message
}));
}
}
private string GenerateAndStoreToken(long userID, bool rememberPassword)
{
var database = this.RedisProvider.GetDatabase();
string token = EncryptHelper.EncryptMD5(Guid.NewGuid().ToString());
string key = RedisKeys.GetTokenCacheKey(token);
database.StringSet(key, userID.ToString());
if (!rememberPassword)
{
database.KeyExpire(key, DateTime.Now.AddDays(7));
}
else
{
database.KeyExpire(key, DateTime.Now.AddDays(30));
}
return(token);
}
/// <summary>
/// 将消息标记为已读
/// </summary>
/// <param name="userID"></param>
/// <param name="idList"></param>
/// <returns></returns>
public async Task MarkAsRead(long userID, long[] idList)
{
if (idList.Length == 0)
{
return;
}
using (var uw = this.CreateUnitOfWork())
{
await uw.CreateRepository <IMessageRepository>().MarkAsRead(userID, idList);
}
var redis = this.RedisProvider.GetDatabase();
RedisValue[] values = idList.Select(t => (RedisValue)t).ToArray();
string key = RedisKeys.GetUserMessageCacheKey(userID);
await redis.SetRemoveAsync(key, values);
}
private void LoadUser()
{
this.InitToken();
if (string.IsNullOrWhiteSpace(this.Token))
{
return;
}
var redis = this.RedisProvider.GetDatabase();
string tokenKey = RedisKeys.GetTokenCacheKey(this.Token);
var id = redis.StringGet(tokenKey);
if (id.HasValue)
{
_userID = Convert.ToInt64(id);
var userService = this.ServiceProvider.GetService <UserService>();
_user = userService.Get(Convert.ToInt64(id));
}
}
public HttpResponseMessage SetOrderSend([FromBody] CC_OrderSend OrderSend)
{
try
{
var db = new RedisOperation(_RedisDB);
var key = RedisKeys.CCOrderSend(OrderSend.CustomerID);
db.InsertListQueue(key, OrderSend);
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Success,
Message = "success"
}));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Fail,
Message = "fail:" + ex.Message
}));
}
}
public HttpResponseMessage DeleteContactList([FromBody] CC_Contact Contact)
{
try
{
var db = new RedisOperation(_RedisDB);
var key = RedisKeys.CCContactKey(Contact.CustomerId);
db.Delete(key);
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Success,
Message = "success"
}));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Fail,
Message = "fail:" + ex.Message
}));
}
}
public HttpResponseMessage DeleteSalesCardOrderList([FromBody] CC_Order order)
{
try
{
var db = new RedisOperation(_RedisDB);
var key = RedisKeys.CCSalesCardOrder(order.CustomerID);
db.Delete(key);
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Success,
Message = "success"
}));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Fail,
Message = "fail:" + ex.Message
}));
}
}
public HttpResponseMessage DelRole([FromBody] CC_Role role)
{
try
{
var db = new RedisOperation(_RedisDB);
var key = RedisKeys.CCMenuRoleKey(role.CustomerID, role.RoleID);
db.DeleteString(key);
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Success,
Message = "success"
}));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Fail,
Message = "fail:" + ex.Message
}));
}
}
public HttpResponseMessage SetOrderReward([FromBody] CC_OrderReward OrderReward) //调用的地方传过来的是json字符串，默认就转化过来了
{
try
{
var db = new RedisOperation(_RedisDB);
var key = RedisKeys.CCOrderReward(OrderReward.CustomerID); //获取相关的键
db.InsertListQueue(key, OrderReward); //插入数据
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Success,
Message = "success"
}));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Fail,
Message = "fail:" + ex.Message
}));
}
}
public HttpResponseMessage SetVipMappingCoupon([FromBody] CC_VipMappingCoupon VipMappingCoupon)
{
try
{
var db = new RedisOperation(_RedisDB);
var key = RedisKeys.CCVipMappingCouponKey(VipMappingCoupon.CustomerId);
db.InsertListQueue(key, VipMappingCoupon);
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Success,
Message = "success"
}));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseModel
{
Code = ResponseCode.Fail,
Message = "fail:" + ex.Message
}));
}
}
