public async Task <IActionResult> List()
{
var messages = await _mongoDbContext.Collection <Message>().Find(new BsonDocument())
.Sort(Builders <Message> .Sort.Descending(n => n.Timestamp))
.ToListAsync();
return(Ok(messages));
}
/// <summary>
/// 删除群组相关缓存信息
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="groupId"></param>
public static void RemoveGroupCache <T>(this int groupId) where T : GroupCacheData
{
using (MongoDbContext mc = new MongoDbContext(Const.GroupsMongoDbConn))
{
Func <T, bool> func = g => g.GroupId == groupId;
if (mc.Collection <T>().Count(func) > 0)
{
mc.Collection <T>().Remove(func);
}
}
}
/// <summary>
/// 从存储中读取渠道信息
/// </summary>
/// <returns></returns>
private static IEnumerable <ChannelCodeKeyPair> GetChannelsFromStorage()
{
using (MongoDbContext mc = new MongoDbContext(Const.ConfigsMongoDbConn))
{
if (mc.Collection <ChannelCodeKeyPair>().Count() > 0)
{
return(mc.Collection <ChannelCodeKeyPair>().Linq().ToList());
}
return(null);
}
}
/// <summary>
/// 从存储中读取用户系统初始相关配置信息
/// </summary>
/// <returns></returns>
public static UserConfig GetUserConfigFromStorage()
{
using (MongoDbContext mc = new MongoDbContext(Const.MongoDbConn))
{
if (mc.Collection <UserConfig>().Count() > 0)
{
return(mc.Collection <UserConfig>().Linq().First());
}
}
return(null);
}
/// <summary>
/// 从存储中读取指定的群组信息
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="groupId"></param>
/// <returns></returns>
public static T GetGroupCacheFromStorage <T>(this int groupId) where T : GroupCacheData
{
using (MongoDbContext mc = new MongoDbContext(Const.GroupsMongoDbConn))
{
Func <T, bool> func = g => g.GroupId == groupId;
if (mc.Collection <T>().Count(func) > 0)
{
return(mc.Collection <T>().FindOne(func));
}
return(null);
}
}
/// <summary>
/// 从存储中读取用户缓存信息
/// </summary>
/// <param name="userId">待读取的目标用户编号</param>
/// <returns></returns>
public static UserCacheData GetUserCacheFromStorage(this int userId)
{
using (MongoDbContext mc = new MongoDbContext(Const.UsersMongoDbConn))
{
Func <UserCacheData, bool> func = u => u.UserId == userId;
if (mc.Collection <UserCacheData>().Count(func) > 0)
{
return(mc.Collection <UserCacheData>().FindOne(func));
}
return(null);
}
}
public async Task <IActionResult> List(string keyword)
{
var query = _mongoDbContext.Collection <Script, string>().AsQueryable();
if (!string.IsNullOrWhiteSpace(keyword))
{
query = query.Where(n => n.Id.Contains(keyword) || n.Description.Contains(keyword));
}
var scripts = await query.ToListAsync();
return(Ok(scripts));
}
/// <summary>
/// 存储渠道信息
/// </summary>
/// <param name="channels"></param>
public static void ChannelsStorage(this IEnumerable <ChannelCodeKeyPair> channels)
{
using (MongoDbContext mc = new MongoDbContext(Const.ConfigsMongoDbConn))
{
if (mc.Collection <ChannelCodeKeyPair>().Count() > 0)
{
mc.Collection <ChannelCodeKeyPair>().Remove(new Document());
}
foreach (var item in channels)
{
mc.Collection <ChannelCodeKeyPair>().Insert(item);
}
}
}
/// <summary>
/// 群组相关信息写入存储
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cacheData"></param>
public static void GroupCacheStorage <T>(this T cacheData) where T : GroupCacheData
{
using (MongoDbContext mc = new MongoDbContext(Const.GroupsMongoDbConn))
{
Func <T, bool> func = g => g.GroupId == cacheData.GroupId;
if (mc.Collection <T>().Count(func) > 0)
{
mc.Collection <T>().Update(cacheData, func);
}
else
{
mc.Collection <T>().Insert(cacheData);
}
}
}
/// <summary>
/// 将用户缓存信息写入存储
/// </summary>
/// <param name="cacheData">用户缓存信息数据</param>
public static void UserCacheStorage(this UserCacheData cacheData)
{
using (MongoDbContext mc = new MongoDbContext(Const.UsersMongoDbConn))
{
Func <UserCacheData, bool> func = u => u.UserId == cacheData.UserId;
if (mc.Collection <UserCacheData>().Count(func) > 0)
{
mc.Collection <UserCacheData>().Update(cacheData, func);
}
else
{
mc.Collection <UserCacheData>().Insert(cacheData);
}
}
}
/// <summary>
/// 将关键词列表写入存储
/// </summary>
/// <param name="filterWords"></param>
public static void SensitiveWordsStorage(this FilterWords filterWords)
{
using (MongoDbContext mc = new MongoDbContext(Const.ConfigsMongoDbConn))
{
FilterWords orgWords = mc.Collection <FilterWords>().Linq().FirstOrDefault();
if (null == orgWords)
{
mc.Collection <FilterWords>().Insert(filterWords);
}
else
{
mc.Collection <FilterWords>().Update(filterWords, orgWords);
}
}
}
/// <summary>
/// 用户系统初始相关配置信息写入存储
/// </summary>
/// <param name="config"></param>
public static void UserConfigStorage(this UserConfig config)
{
using (MongoDbContext mc = new MongoDbContext(Const.MongoDbConn))
{
if (mc.Collection <UserConfig>().Count() > 0)
{
UserConfig orgConfig = mc.Collection <UserConfig>().Linq().First();
mc.Collection <UserConfig>().Update(config, orgConfig);
}
else
{
mc.Collection <UserConfig>().Insert(config);
}
}
}
public void GetQueriesTest()
{
var mongoDbContext = new MongoDbContext("192.168.56.101", 27017, "myApplicationDb");
var productCollection = mongoDbContext.Collection <Product>("myProductsCollection");
var allproducts = productCollection.Find(x => x.ProductId > 0).ToList();
}
/// <summary>
/// 从存储中读取关键词列表
/// </summary>
/// <returns></returns>
private static FilterWords GetSensitiveWordsFromStorage()
{
using (MongoDbContext mc = new MongoDbContext(Const.ConfigsMongoDbConn))
{
return(mc.Collection <FilterWords>().Linq().FirstOrDefault());
}
}
public System.Threading.Tasks.Task StartAsync(CancellationToken cancellationToken)
{
var exchange = "Task";
var queue = "Task";
_channel.ExchangeDeclare(exchange, "direct", true);
_channel.QueueDeclare(queue, true, false, false);
_channel.QueueBind(queue, exchange, queue);
var consumer = new EventingBasicConsumer(_channel);
consumer.Received += (model, ea) =>
{
var index = (int)ea.BasicProperties.Headers["index"];
var id = (ea.BasicProperties.Headers["id"] as byte[]).BytesToString();
var timeFlag = (ea.BasicProperties.Headers["sendtime"] as byte[]).BytesToString();
_channel.QueueDelete($"PendingTask|Task:{id}_{index}_{timeFlag}", false, true);
var taskId = new ObjectId(id);
var task = _mongoDbContext.Collection <Task>().Find(n => n.Id == taskId).SingleOrDefault();
if (task == null || task.Status != TaskStatus.Normal)
{
_channel.BasicAck(ea.DeliveryTag, false);
return;
}
_logger.LogInformation($"[{DateTime.UtcNow}]执行任务...");
task.SubTasks[index].IsSent = true;
if (task.SubTasks.Count > index + 1)
{
PublishPendingMsg(_channel, task, index + 1);
}
else
{
task.Status = TaskStatus.Finished;
}
_mongoDbContext.Collection <Task>().ReplaceOne(n => n.Id == taskId, task);
_channel.BasicAck(ea.DeliveryTag, false);
};
_channel.BasicConsume(queue, false, consumer);
_logger.LogInformation("任务执行服务已启动...");
return(System.Threading.Tasks.Task.CompletedTask);
}
public void CollectionTest()
{
var mongoDbContext = new MongoDbContext("192.168.56.101", 27017, "myApplicationDb");
var productCollection = mongoDbContext.Collection <Product>("myProductsCollection");
var product = new Product();
//product.DocumentId = ObjectId.GenerateNewId();
product.ProductId = 2;
product.Sku = "hajk-34";
product.ThirdPartyIds = new List <ThirdPartyId>()
{
new ThirdPartyId()
{
Value = "3fda45r",
Type = "ASIN",
Platform = "Amazon"
}
};
productCollection.InsertOne(product);
var productRetrieved = productCollection.Find(x => x.ProductId == product.ProductId).FirstOrDefault();
Assert.IsNotNull(productRetrieved);
Assert.IsNotNull(productRetrieved.DocumentId);
Assert.AreEqual(product.ProductId, productRetrieved.ProductId);
var googleProdFilterCondition = Builders <Product> .Filter.ElemMatch(x => x.ThirdPartyIds,
t => t.Platform == "Google");
var googleProducts = productCollection.Find(googleProdFilterCondition).ToList();
Assert.IsNotNull(googleProducts);
var gp = googleProducts.Where(x => x.ThirdPartyIds.Exists(s => s.Platform == "Google"));
Assert.IsNotNull(gp);
}
public Task StartAsync(CancellationToken cancellationToken)
{
_channel.BasicQos(0, 1, false);
_channel.ExchangeDeclare("Exchange", "direct");
_channel.QueueDeclare("QueueAudit", true, false, false);
_channel.QueueBind("QueueAudit", "Exchange", "RouteA");
_channel.QueueBind("QueueAudit", "Exchange", "RouteB");
var consumer = new EventingBasicConsumer(_channel);
consumer.Received += (model, ea) =>
{
var isOk = true;
try
{
if (ea.BasicProperties.Headers == null || !ea.BasicProperties.Headers.ContainsKey("x-death"))
{
var message = new Message
{
MessageId = ea.BasicProperties.MessageId,
Body = ea.Body,
Exchange = ea.Exchange,
Route = ea.RoutingKey
};
if (ea.BasicProperties.Headers != null)
{
var headers = new Dictionary <string, object>();
foreach (var header in ea.BasicProperties.Headers)
{
if (header.Value is byte[] bytes)
{
headers[header.Key] = Encoding.UTF8.GetString(bytes);
}
else
{
headers[header.Key] = header.Value;
}
}
message.Headers = headers;
}
if (ea.BasicProperties.Timestamp.UnixTime > 0)
{
message.TimestampUnix = ea.BasicProperties.Timestamp.UnixTime;
var offset = DateTimeOffset.FromUnixTimeMilliseconds(ea.BasicProperties.Timestamp.UnixTime);
message.Timestamp = offset.UtcDateTime;
}
_mongoDbContext.Collection <Message>().InsertOne(message, cancellationToken: cancellationToken);
}
}
catch (Exception ex)
{
_logger.LogCritical(ex, "Error!");
isOk = false;
}
try
{
if (isOk)
{
_channel.BasicAck(ea.DeliveryTag, false);
}
else
{
_channel.BasicNack(ea.DeliveryTag, false, true);
}
}
catch (AlreadyClosedException ex)
{
_logger.LogCritical(ex, "RabbitMQ is closed!");
}
};
_channel.BasicConsume("QueueAudit", false, consumer);
_logger.LogInformation("Audit service started...");
return(Task.CompletedTask);
}
public async Task <IActionResult> Create([FromBody] TaskCreateForm form)
{
var task = new Task
{
Name = form.Name,
StartTime = form.StartTime,
EndTime = form.EndTime,
Interval = form.Interval,
SubTasks = new List <SubTask>()
};
var startTime = task.StartTime;
var endTime = task.EndTime;
while ((endTime - startTime).TotalMinutes >= 0)
{
var sendTime = startTime;
if (sendTime <= endTime && sendTime > DateTime.UtcNow)
{
task.SubTasks.Add(new SubTask {
Id = ObjectId.GenerateNewId(), SendTime = sendTime
});
}
startTime = startTime.AddMinutes(task.Interval);
}
await _mongoDbContext.Collection <Task>().InsertOneAsync(task);
var timeFlag = task.SubTasks[0].SendTime.ToString("yyyy-MM-dd HH:mm:ssZ");
var exchange = "Task";
var queue = "Task";
var index = 0;
var pendingExchange = "PendingTask";
var pendingQueue = $"PendingTask|Task:{task.Id}_{index}_{timeFlag}";
using (var channel = _rabbitConnection.CreateModel())
{
channel.ExchangeDeclare(exchange, "direct", true);
channel.QueueDeclare(queue, true, false, false);
channel.QueueBind(queue, exchange, queue);
var retryDic = new Dictionary <string, object>
{
{ "x-dead-letter-exchange", exchange },
{ "x-dead-letter-routing-key", queue }
};
channel.ExchangeDeclare(pendingExchange, "direct", true);
channel.QueueDeclare(pendingQueue, true, false, false, retryDic);
channel.QueueBind(pendingQueue, pendingExchange, pendingQueue);
var properties = channel.CreateBasicProperties();
properties.Headers = new Dictionary <string, object>
{
["index"] = index,
["id"] = task.Id.ToString(),
["sendtime"] = timeFlag
};
properties.Expiration = ((int)(task.SubTasks[0].SendTime - DateTime.UtcNow).TotalMilliseconds).ToString(CultureInfo.InvariantCulture);
channel.BasicPublish(pendingExchange, pendingQueue, properties, Encoding.UTF8.GetBytes(string.Empty));
}
return(Ok());
}