public void HandlesSavesDeliveredMessageWithProperData(string id, string topic, long timestamp, string text)
{
// Arrange
var repoMock = new Mock <IAuditLogItemRepository>();
var listener = new AuditEventLoggingListener(repoMock.Object, new NullLoggerFactory());
AuditLogItem resultItem = null;
repoMock.Setup(e => e.Save(It.IsAny <AuditLogItem>()))
.Callback <AuditLogItem>(item => resultItem = item);
var inputObject = new
{
Id = id,
TimeStamp = timestamp,
Data = text,
Topic = topic
};
string input = JsonConvert.SerializeObject(inputObject);
// Act
listener.Handle(input);
// Assert
Assert.AreEqual(input, resultItem.Data);
}
public void FetchedLogItemsArePublishedProperly(string data, string topic, string type, long timestamp)
{
// Arrange
Mock <IAuditLogItemRepository> repositoryMock = new Mock <IAuditLogItemRepository>(MockBehavior.Strict);
Mock <IEventPublisher> eventPublisherMock = new Mock <IEventPublisher>();
AuditLogItem auditLogItem = new AuditLogItem
{
Id = Guid.NewGuid().ToString(),
TimeStamp = timestamp,
Data = data,
Topic = topic,
Type = type
};
repositoryMock.Setup(e => e.FindBy(It.IsAny <AuditLogItemCriteria>()))
.Returns(new List <AuditLogItem> {
auditLogItem
});
ReplayCommandListener commandListener = new ReplayCommandListener(repositoryMock.Object, eventPublisherMock.Object, new LoggerFactory());
ReplayEventsCommand command = new ReplayEventsCommand(0);
// Act
commandListener.Handle(command);
Thread.Sleep(WaitTime);
// Assert
eventPublisherMock.Verify(e => e.PublishAsync(timestamp, $"replay_{topic}", It.IsAny <Guid>(), type, data));
}
public async Task LogMessageDeletedAsync(Cacheable <IMessage, ulong> message, ISocketMessageChannel channel, SocketGuild guild)
{
var deletedMessage = message.HasValue ? message.Value : MessageCache.TryRemove(message.Id);
var entity = new AuditLogItem()
{
Type = AuditLogType.MessageDeleted,
CreatedAt = DateTime.Now,
GuildIdSnowflake = guild.Id,
};
if (deletedMessage == null)
{
entity.SetData(MessageDeletedAuditData.Create(channel));
}
else
{
await ProcessMessageDeletedWithCacheAsync(entity, channel, deletedMessage, guild);
}
if (MessageCache.Exists(message.Id))
{
MessageCache.TryRemove(message.Id);
}
await MessageCache.AppendAroundAsync(channel, message.Id, 100);
await GrillBotRepository.AddAsync(entity);
await GrillBotRepository.CommitAsync();
}
public async Task LogMessageEditedAsync(Cacheable <IMessage, ulong> before, SocketMessage after, ISocketMessageChannel channel, SocketGuild guild)
{
var oldMessage = before.HasValue ? before.Value : MessageCache.Get(before.Id);
if (!IsMessageEdited(oldMessage, after))
{
return;
}
var userId = await UserSearchService.GetUserIDFromDiscordUserAsync(guild, after.Author);
var entity = new AuditLogItem()
{
Type = AuditLogType.MessageEdited,
CreatedAt = DateTime.Now,
GuildIdSnowflake = guild.Id,
UserId = userId
};
entity.SetData(MessageEditedAuditData.Create(channel, oldMessage, after));
await GrillBotRepository.AddAsync(entity);
await GrillBotRepository.CommitAsync();
MessageCache.Update(after);
}
private async Task ProcessMessageDeletedWithCacheAsync(AuditLogItem entity, ISocketMessageChannel channel, IMessage message, SocketGuild guild)
{
entity.SetData(MessageDeletedAuditData.Create(channel, message));
var auditLog = (await guild.GetAuditLogDataAsync(actionType: ActionType.MessageDeleted)).Find(o =>
{
var data = (MessageDeleteAuditLogData)o.Data;
return(data.Target.Id == message.Author.Id && data.ChannelId == channel.Id);
});
entity.UserId = await UserSearchService.GetUserIDFromDiscordUserAsync(guild, auditLog?.User ?? message.Author);
if (message.Attachments.Count > 0)
{
foreach (var attachment in message.Attachments.Where(o => o.Size < 10 * 1024 * 1024)) // Max 10MB
{
var fileContent = await attachment.DownloadFileAsync();
if (fileContent == null)
{
continue;
}
entity.Files.Add(new Database.Entity.File()
{
Content = fileContent,
Filename = $"{Path.GetFileNameWithoutExtension(attachment.Filename)}_{attachment.Id}{Path.GetExtension(attachment.Filename)}"
});
}
}
}
public static AuditLogItem Find(Type t)
{
lock (s_DomainTypesSyncObj)
{
AuditLogItem result;
if (t != typeof(AuditLog))
{
if (!s_DomainTypes.TryGetValue(t, out result))
{
result = new AuditLogItem();
PPWAuditLogAttribute auditLogAttribute = t.GetCustomAttributes(true).OfType<PPWAuditLogAttribute>().FirstOrDefault();
if (auditLogAttribute != null)
{
result.AuditLogAction = auditLogAttribute.AuditLogAction;
result.Properties = new Dictionary<string, PPWAuditLogActionEnum>();
foreach (PropertyInfo pi in t.GetProperties().Where(o => o.CanWrite))
{
PPWAuditLogPropertyIgnoreAttribute auditLogPropertyIgnore = pi.GetCustomAttributes(true).OfType<PPWAuditLogPropertyIgnoreAttribute>().FirstOrDefault();
result.Properties.Add(pi.Name, auditLogPropertyIgnore != null ? auditLogPropertyIgnore.AuditLogAction : PPWAuditLogActionEnum.NONE);
}
}
s_DomainTypes.Add(t, result);
}
}
else
{
result = new AuditLogItem();
}
return result;
}
}
public void SavingAnItemWorks(string data, string topic)
{
// Arrange
using (var context = new AuditLogContext(_options))
{
var repository = new AuditLogItemRepository(context);
var item = new AuditLogItem
{
Data = data,
Topic = topic,
Id = Guid.NewGuid().ToString()
};
// Act
repository.Save(item);
}
// Assert
using var controlContext = new AuditLogContext(_options);
var resultData = controlContext.AuditLogItems.ToArray();
Assert.AreEqual(1, resultData.Length);
var firstItem = resultData.First();
Assert.AreEqual(data, firstItem.Data);
Assert.AreEqual(topic, firstItem.Topic);
}
public void TestConstructionWithoutTime()
{
DateTime now = DateTime.Now;
AuditLogItem logItem = new AuditLogItem(documentId, actor, action, info);
Assert.True(logItem.LogTime >= now);
}
public virtual void OnPostUpdate(PostUpdateEvent @event)
{
AuditLogItem auditLogItem = AuditLogItem.Find(@event.Entity.GetType());
if ((auditLogItem.AuditLogAction & AuditLogActionEnum.UPDATE) == AuditLogActionEnum.UPDATE)
{
string identityName = IdentityProvider.IdentityName;
DateTime now = TimeProvider.Now.ToUniversalTime();
string entityName = @event.Entity.GetType().Name;
if (@event.OldState == null)
{
throw new ProgrammingError(
string.Format(
"No old state available for entity type '{1}'.{0}Make sure you're loading it into Session before modifying and saving it.",
Environment.NewLine,
entityName));
}
List <TAuditEntity> auditLogs = new List <TAuditEntity>();
int[] fieldIndices = @event.Persister.FindDirty(@event.State, @event.OldState, @event.Entity, @event.Session);
foreach (int dirtyFieldIndex in fieldIndices)
{
string oldValue = GetStringValueFromStateArray(@event.OldState, dirtyFieldIndex);
string newValue = GetStringValueFromStateArray(@event.State, dirtyFieldIndex);
if (oldValue != newValue)
{
string propertyName = @event.Persister.PropertyNames[dirtyFieldIndex];
AuditLogActionEnum auditLogAction;
if (auditLogItem.Properties.TryGetValue(propertyName, out auditLogAction))
{
if ((auditLogAction & AuditLogActionEnum.UPDATE) == AuditLogActionEnum.NONE)
{
auditLogs.Add(
new TAuditEntity
{
EntryType = "U",
EntityName = entityName,
EntityId = @event.Id.ToString(),
PropertyName = propertyName,
OldValue = oldValue,
NewValue = newValue,
CreatedBy = identityName,
CreatedAt = now,
});
}
}
}
}
if (auditLogs.Count > 0)
{
ISession session = @event.Session.GetSession(EntityMode.Poco);
auditLogs.ForEach(o => session.Save(o));
}
}
}
public void TestConstruction()
{
AuditLogItem logItem = new AuditLogItem(time, documentId, actor, action, info);
Assert.Equal(time, logItem.LogTime);
Assert.Equal(documentId, logItem.DocumentId);
Assert.Equal(actor, logItem.Actor);
Assert.Equal(action, logItem.Action);
Assert.Equal(info, logItem.AdditionalInformation);
}
public void TestSerializedNames()
{
AuditLogItem logItem = new AuditLogItem(time, documentId, actor, action, info);
string json = JsonConvert.SerializeObject(logItem);
JObject obj = JObject.Parse(json);
Assert.True(obj.ContainsKey("logTime"));
Assert.True(obj.ContainsKey("documentId"));
Assert.True(obj.ContainsKey("actor"));
Assert.True(obj.ContainsKey("action"));
Assert.True(obj.ContainsKey("additionalInformation"));
}
public Dictionary <Guid, QueryResponse> QueryDomains(IGlymaSession glymaSession)
{
using (IDbConnectionAbstraction mapDbConnection = glymaSession.ConnectionFactory.CreateMapDbConnection())
{
SqlCommand queryDomainMapCommand = new SqlCommand("SELECT [DomainUid], [NodeUid] FROM [Nodes] WHERE NodeTypeUid = '263754C2-2F31-4D21-B9C4-6509E00A5E94'", mapDbConnection.Connection);
queryDomainMapCommand.CommandType = CommandType.Text;
mapDbConnection.Open();
SqlDataReader queryMapResults = queryDomainMapCommand.ExecuteReader();
Dictionary <Guid, QueryResponse> domainResponses = new Dictionary <Guid, QueryResponse>();
if (queryMapResults.HasRows)
{
while (queryMapResults.Read())
{
Guid domainId = queryMapResults.GetGuid(0);
Guid nodeId = queryMapResults.GetGuid(1);
QueryResponse response = QueryMap(glymaSession, domainId, nodeId, 0, false, null, null, 0, false);
domainResponses[domainId] = response;
}
}
mapDbConnection.Close();
try
{
mapDbConnection.Open();
AuditLogItem logItem = new AuditLogItem(mapDbConnection.Connection);
logItem.OperationName = "QueryDomains";
//logItem.CallingUrl = callingUrl;
logItem.DomainUid = null;
logItem.NodeUid = null;
logItem.RootMapUid = null;
logItem.MaxDepth = null;
logItem.ObjectIndex = null;
logItem.EdgeConditions = null;
logItem.FilterConditions = null;
logItem.SearchConditions = null;
logItem.PageNumber = null;
logItem.PageSize = null;
logItem.Commit();
mapDbConnection.Close();
}
catch
{
/// Don't do anything. This is here because audit logging is a very low importance task and we don't want it potentially killing the more important tasks at hand.
}
return(domainResponses);
}
}
public QueryResponse QueryMapByDomain(IGlymaSession glymaSession, Guid domainId, int maxDepth, EdgeConditions edgeConditions, FilterConditions filterConditions)
{
using (IDbConnectionAbstraction mapDbConnection = glymaSession.ConnectionFactory.CreateMapDbConnection())
{
SqlCommand queryDomainMapCommand = new SqlCommand("SELECT [NodeUid] FROM [Nodes] WHERE DomainUid = @DomainId AND NodeTypeUid = '263754C2-2F31-4D21-B9C4-6509E00A5E94'", mapDbConnection.Connection);
queryDomainMapCommand.CommandType = CommandType.Text;
queryDomainMapCommand.Parameters.Add(new SqlParameter("@DomainId", domainId));
Guid domainNodeId = Guid.Empty;
mapDbConnection.Open();
SqlDataReader queryMapResults = queryDomainMapCommand.ExecuteReader();
if (queryMapResults.HasRows)
{
queryMapResults.Read();
domainNodeId = queryMapResults.GetGuid(0);
}
mapDbConnection.Close();
try
{
mapDbConnection.Open();
AuditLogItem logItem = new AuditLogItem(mapDbConnection.Connection);
logItem.OperationName = "QueryMapByDomain";
//logItem.CallingUrl = callingUrl;
logItem.DomainUid = domainId;
logItem.NodeUid = null;
logItem.RootMapUid = null;
logItem.MaxDepth = maxDepth;
logItem.ObjectIndex = null;
logItem.EdgeConditions = null;
logItem.FilterConditions = null;
logItem.SearchConditions = null;
logItem.PageNumber = null;
logItem.PageSize = null;
logItem.Commit();
mapDbConnection.Close();
}
catch
{
/// Don't do anything. This is here because audit logging is a very low importance task and we don't want it potentially killing the more important tasks at hand.
}
return(QueryMap(glymaSession, domainId, domainNodeId, maxDepth, true, edgeConditions, filterConditions, 0));
}
}
public virtual void OnPostInsert(PostInsertEvent @event)
{
AuditLogItem auditLogItem = AuditLogItem.Find(@event.Entity.GetType());
if ((auditLogItem.AuditLogAction & AuditLogActionEnum.CREATE) == AuditLogActionEnum.CREATE)
{
string identityName = IdentityProvider.IdentityName;
DateTime now = TimeProvider.Now.ToUniversalTime();
string entityName = @event.Entity.GetType().Name;
List <TAuditEntity> auditLogs = new List <TAuditEntity>();
int length = @event.State.Count();
for (int fieldIndex = 0; fieldIndex < length; fieldIndex++)
{
string newValue = GetStringValueFromStateArray(@event.State, fieldIndex);
string propertyName = @event.Persister.PropertyNames[fieldIndex];
AuditLogActionEnum auditLogAction;
if (auditLogItem.Properties.TryGetValue(propertyName, out auditLogAction))
{
if ((auditLogAction & AuditLogActionEnum.CREATE) == AuditLogActionEnum.NONE)
{
auditLogs.Add(
new TAuditEntity
{
EntryType = "I",
EntityName = entityName,
EntityId = @event.Id.ToString(),
PropertyName = propertyName,
OldValue = null,
NewValue = newValue,
CreatedBy = identityName,
CreatedAt = now,
});
}
}
}
if (auditLogs.Count > 0)
{
ISession session = @event.Session.GetSession(EntityMode.Poco);
auditLogs.ForEach(o => session.Save(o));
}
}
}
public async Task LogUserLeftAsync(SocketGuildUser user)
{
if (user == null)
{
return;
}
var ban = await user.Guild.FindBanAsync(user);
RestAuditLogEntry dcAuditLogItem;
if (ban != null)
{
dcAuditLogItem = (await user.Guild.GetAuditLogDataAsync(actionType: ActionType.Ban))?
.FirstOrDefault(o => (o.Data as BanAuditLogData)?.Target.Id == user.Id);
}
else
{
dcAuditLogItem = (await user.Guild.GetAuditLogDataAsync(actionType: ActionType.Kick))?
.FirstOrDefault(o => (o.Data as KickAuditLogData)?.Target.Id == user.Id);
}
long?executor = null;
if (dcAuditLogItem != null)
{
executor = await UserSearchService.GetUserIDFromDiscordUserAsync(user.Guild, dcAuditLogItem.User);
}
var entity = new AuditLogItem()
{
Type = AuditLogType.UserLeft,
CreatedAt = DateTime.Now,
GuildIdSnowflake = user.Guild.Id,
UserId = executor
};
entity.SetData(UserLeftAuditData.Create(user.Guild, user, ban != null, ban?.Reason));
await GrillBotRepository.AddAsync(entity);
await GrillBotRepository.CommitAsync();
}
public void Handle(string evt)
{
_logger.LogDebug($"Deserializing event with data {evt}");
try
{
AuditLogItem item = JsonConvert.DeserializeObject <AuditLogItem>(evt);
item.TimeStamp = new DateTime(item.TimeStamp).ToFileTimeUtc();
item.Data = evt;
_repository.Save(item);
}
catch (JsonReaderException exception)
{
_logger.LogCritical($"Json Exception occured while handling incoming event! {exception.Message}. " +
$"This means that this item IS NOT saved! Item {evt}");
throw;
}
}
public virtual void OnPostDelete(PostDeleteEvent @event)
{
AuditLogItem auditLogItem = AuditLogItem.Find(@event.Entity.GetType());
if ((auditLogItem.AuditLogAction & AuditLogActionEnum.DELETE) == AuditLogActionEnum.DELETE)
{
string identityName = IdentityProvider.IdentityName;
DateTime now = TimeProvider.Now.ToUniversalTime();
string entityName = @event.Entity.GetType().Name;
ISession session = @event.Session.GetSession(EntityMode.Poco);
session.Save(
new TAuditEntity
{
EntryType = "D",
EntityName = entityName,
EntityId = @event.Id.ToString(),
CreatedBy = identityName,
CreatedAt = now,
});
}
}
public async Task LogCommandAsync(Optional <CommandInfo> command, ICommandContext context)
{
if (context.Guild == null || !command.IsSpecified)
{
return;
}
var userId = await UserSearchService.GetUserIDFromDiscordUserAsync(context.Guild, context.User);
var entity = new AuditLogItem()
{
Type = AuditLogType.Command,
CreatedAt = DateTime.Now,
GuildIdSnowflake = context.Guild.Id,
UserId = userId
};
entity.SetData(CommandAuditData.CreateDbItem(context, command.Value));
await GrillBotRepository.AddAsync(entity);
await GrillBotRepository.CommitAsync();
}
public static AuditLogItem Find(Type t)
{
AuditLogItem result = s_DomainTypes
.GetOrAdd(
t,
@type =>
{
result = new AuditLogItem();
if (@type != typeof(TAuditEntity))
{
AuditLogAttribute auditLogAttribute =
@type
.GetCustomAttributes(true)
.OfType <AuditLogAttribute>()
.FirstOrDefault();
if (auditLogAttribute != null)
{
result.AuditLogAction = auditLogAttribute.AuditLogAction;
result.Properties = new Dictionary <string, AuditLogActionEnum>();
foreach (PropertyInfo propertyInfo in t.GetProperties().Where(o => o.CanWrite))
{
AuditLogPropertyIgnoreAttribute auditLogPropertyIgnore =
propertyInfo
.GetCustomAttributes(true)
.OfType <AuditLogPropertyIgnoreAttribute>()
.FirstOrDefault();
result
.Properties
.Add(propertyInfo.Name, auditLogPropertyIgnore != null ? auditLogPropertyIgnore.AuditLogAction : AuditLogActionEnum.NONE);
}
}
}
return(result);
});
return(result);
}
/// <summary>
/// Converts an IDataReader to a list of AuditLogItems.
/// </summary>
/// <typeparam name="U"></typeparam>
/// <param name="reader"></param>
/// <returns></returns>
protected List <AuditLogItem> ConvertDataReaderToList(IDataReader reader)
{
List <AuditLogItem> list = new List <AuditLogItem>();
while (reader.Read())
{
AuditLogItem item = new AuditLogItem();
item.ID = long.Parse(reader["audit_log_id"].ToString());
item.ChangedTime = DateTime.Parse(reader["changed_time"].ToString());
item.ChangedBy = reader["changed_by"].ToString();
item.ContractID = long.Parse(reader["contract_id"].ToString());
item.Contract = reader["contract_descr"].ToString();
item.Source1 = reader["source1"].ToString();
item.Source2 = reader["source2"].ToString();
item.PkValue = reader["pk_value"].ToString();
item.AuditAction = reader["audit_action"].ToString();
item.Description = reader["descr"].ToString();
item.OldValue = reader["old_value"].ToString();
item.NewValue = reader["new_value"].ToString();
list.Add(item);
}
reader.Dispose();
return(list);
}
public async Task LogUserJoinAsync(SocketGuildUser user)
{
if (user == null || !user.IsUser())
{
return;
}
var userEntity = await GrillBotRepository.UsersRepository.GetOrCreateUserAsync(user.Guild.Id, user.Id, UsersIncludes.None);
await GrillBotRepository.CommitAsync();
var entity = new AuditLogItem()
{
Type = AuditLogType.UserJoined,
CreatedAt = DateTime.Now,
GuildIdSnowflake = user.Guild.Id,
UserId = userEntity.ID
};
entity.SetData(UserJoinedAuditData.Create(user.Guild));
await GrillBotRepository.AddAsync(entity);
await GrillBotRepository.CommitAsync();
}
/// <summary>
/// Save a log item to the database
/// </summary>
public void Save(AuditLogItem item)
{
_auditLogContext.AuditLogItems.Add(item);
_auditLogContext.SaveChanges();
}
public async Task TriggerBackgroundTaskAsync(object data)
{
if (data is not DownloadAuditLogBackgroundTask task)
{
return;
}
var guild = Client.GetGuild(task.GuildId);
if (guild == null)
{
return;
}
if (!AuditServiceHelper.IsTypeDefined(task.ActionType))
{
return;
}
var logs = await guild.GetAuditLogDataAsync(100, task.ActionType);
if (logs.Count == 0)
{
return;
}
var auditLogType = AuditServiceHelper.AuditLogTypeMap[task.ActionType];
var logIds = (await GrillBotRepository.AuditLogs.GetLastAuditLogIdsQuery(guild.Id, auditLogType).ToListAsync())
.ConvertAll(o => Convert.ToUInt64(o));
foreach (var log in logs)
{
if (logIds.Contains(log.Id))
{
continue;
}
var userId = await GetOrCreateUserId(guild, log.User);
var item = new AuditLogItem()
{
CreatedAt = log.CreatedAt.LocalDateTime,
DcAuditLogIdSnowflake = log.Id,
UserId = userId,
GuildIdSnowflake = guild.Id,
Type = auditLogType
};
var logMappingMethod = AuditServiceHelper.AuditLogDataMap[task.ActionType];
if (logMappingMethod != null)
{
var mappedItem = logMappingMethod(log.Data);
if (mappedItem != null)
{
item.SetData(mappedItem);
}
}
await GrillBotRepository.AddAsync(item);
}
await GrillBotRepository.CommitAsync();
}
public static async Task <AuditItem> CreateAsync(SocketGuild guild, AuditLogItem dbItem, DiscordUser user, IMessageCache cache)
{
var item = new AuditItem()
{
CreatedAt = dbItem.CreatedAt,
Id = dbItem.Id,
Type = dbItem.Type,
User = user,
AttachmentNames = dbItem.Files.Select(o => o.Filename).ToList()
};
switch (dbItem.Type)
{
case AuditLogType.BotAdded:
item.BotAdded = JsonConvert.DeserializeObject <AuditBotAdded>(dbItem.JsonData);
break;
case AuditLogType.ChannelCreated:
case AuditLogType.ChannelDeleted:
item.ChannelInfo = JsonConvert.DeserializeObject <AuditChannelInfo>(dbItem.JsonData);
break;
case AuditLogType.ChannelUpdated:
item.ChannelUpdated = JsonConvert.DeserializeObject <AuditChannelUpdated>(dbItem.JsonData);
break;
case AuditLogType.Command:
item.CommandAuditData = JsonConvert.DeserializeObject <CommandAuditData>(dbItem.JsonData).GetFilledModel(guild);
break;
case AuditLogType.EmojiCreated:
case AuditLogType.EmojiDeleted:
item.EmoteInfo = JsonConvert.DeserializeObject <AuditEmoteInfo>(dbItem.JsonData);
break;
case AuditLogType.EmojiUpdated:
item.EmoteUpdated = JsonConvert.DeserializeObject <AuditEmoteUpdated>(dbItem.JsonData);
break;
case AuditLogType.GuildUpdated:
item.GuildUpdated = JsonConvert.DeserializeObject <GuildUpdated>(dbItem.JsonData).GetFilledModel(guild);
break;
case AuditLogType.MemberRoleUpdated:
case AuditLogType.MemberUpdated:
item.MemberUpdated = await JsonConvert.DeserializeObject <AuditMemberUpdated>(dbItem.JsonData).GetFilledModelAsync(guild);
break;
case AuditLogType.MessageDeleted:
item.MessageDeletedAuditData = JsonConvert.DeserializeObject <MessageDeletedAuditData>(dbItem.JsonData).GetFilledModel(guild);
break;
case AuditLogType.MessageEdited:
item.MessageEditedAuditData = JsonConvert.DeserializeObject <MessageEditedAuditData>(dbItem.JsonData).GetFilledModel(guild);
break;
case AuditLogType.MessagePinned:
case AuditLogType.MessageUnpinned:
item.PinInfo = await JsonConvert.DeserializeObject <AuditMessagePinInfo>(dbItem.JsonData).GetFilledModelAsync(guild, cache);
break;
case AuditLogType.OverwriteCreated:
case AuditLogType.OverwriteDeleted:
item.OverwriteInfo = JsonConvert.DeserializeObject <AuditOverwriteInfo>(dbItem.JsonData).GetFilledModel(guild);
break;
case AuditLogType.OverwriteUpdated:
item.OverwriteUpdated = JsonConvert.DeserializeObject <AuditOverwriteUpdated>(dbItem.JsonData).GetFilledModel(guild);
break;
case AuditLogType.Prune:
item.PruneMembers = JsonConvert.DeserializeObject <AuditPruneMembers>(dbItem.JsonData);
break;
case AuditLogType.RoleCreated:
case AuditLogType.RoleDeleted:
item.Role = JsonConvert.DeserializeObject <Role>(dbItem.JsonData);
break;
case AuditLogType.RoleUpdated:
item.RoleUpdated = JsonConvert.DeserializeObject <RoleUpdated>(dbItem.JsonData);
break;
case AuditLogType.Unban:
item.Unban = JsonConvert.DeserializeObject <AuditUnban>(dbItem.JsonData);
break;
case AuditLogType.UserJoined:
item.UserJoinedAuditData = JsonConvert.DeserializeObject <UserJoinedAuditData>(dbItem.JsonData).GetFilledModel(user);
break;
case AuditLogType.UserLeft:
item.UserLeftAuditData = JsonConvert.DeserializeObject <UserLeftAuditData>(dbItem.JsonData);
break;
case AuditLogType.WebhookCreated:
case AuditLogType.WebhookDeleted:
item.Webhook = JsonConvert.DeserializeObject <Webhook>(dbItem.JsonData);
break;
case AuditLogType.WebhookUpdated:
item.WebhookUpdated = JsonConvert.DeserializeObject <WebhookUpdated>(dbItem.JsonData).GetFilledModel(guild);
break;
}
return(item);
}
public QueryResponse QueryMap(IGlymaSession glymaSession, Guid domainId, Guid nodeId, int maxDepth, bool isFullDomainSearch, EdgeConditions edgeConditions, FilterConditions filterConditions, int objectIndex, bool isCompressed)
{
if (!isCompressed)
{
TransactionalMappingToolServiceCommonBase.SoftObjectLimit = 3000;
TransactionalMappingToolServiceCommonBase.HardObjectLimit = 4000;
}
else
{
TransactionalMappingToolServiceCommonBase.SoftObjectLimit = 5500;
TransactionalMappingToolServiceCommonBase.HardObjectLimit = 6500;
}
using (IDbConnectionAbstraction mapDbConnection = glymaSession.ConnectionFactory.CreateMapDbConnection())
{
SqlCommand queryMapCommand = new SqlCommand("QueryMap", mapDbConnection.Connection);
queryMapCommand.CommandType = CommandType.StoredProcedure;
queryMapCommand.Parameters.Add(new SqlParameter("@DomainId", domainId));
queryMapCommand.Parameters.Add(new SqlParameter("@NodeId", nodeId));
queryMapCommand.Parameters.Add(new SqlParameter("@Depth", maxDepth));
queryMapCommand.Parameters.Add(new SqlParameter("@FullDomain", isFullDomainSearch));
mapDbConnection.Open();
SqlDataReader queryMapResults = queryMapCommand.ExecuteReader();
QueryResponse queryResponse = new QueryResponse();
List <Node>[] orderedNodes = new List <Node> [maxDepth + 1];
do
{
while (queryMapResults.Read())
{
if (queryMapResults.GetSchemaTable().Select("ColumnName = 'Level'").Length > 0)
{
Node node = new Node();
node.LoadElement(queryMapResults);
List <Node> nodes;
if (orderedNodes[node.Depth] != null)
{
nodes = orderedNodes[node.Depth];
}
else
{
nodes = new List <Node>();
orderedNodes[node.Depth] = nodes;
}
nodes.Add(node);
queryResponse.AddNode(node);
}
else if (queryMapResults.GetSchemaTable().Select("ColumnName = 'MetadataId'").Length > 0)
{
Metadata metadata = new Metadata();
metadata.LoadElement(queryMapResults);
queryResponse.AddMetadata(metadata);
}
else if (queryMapResults.GetSchemaTable().Select("ColumnName = 'DescriptorUid'").Length > 0)
{
Descriptor descriptor = new Descriptor();
descriptor.LoadElement(queryMapResults);
queryResponse.AddDescriptor(descriptor);
}
else if (queryMapResults.GetSchemaTable().Select("ColumnName = 'RelationshipUid'").Length > 0)
{
Relationship relationship = new Relationship();
relationship.LoadElement(queryMapResults);
queryResponse.AddRelationship(relationship);
}
}
}while (queryMapResults.NextResult());
mapDbConnection.Close();
try
{
mapDbConnection.Open();
AuditLogItem logItem = new AuditLogItem(mapDbConnection.Connection);
logItem.OperationName = "QueryMap";
//logItem.CallingUrl = callingUrl;
logItem.DomainUid = domainId;
logItem.NodeUid = nodeId;
logItem.RootMapUid = null;
logItem.MaxDepth = maxDepth;
logItem.ObjectIndex = objectIndex;
logItem.EdgeConditions = null;
logItem.FilterConditions = null;
logItem.SearchConditions = null;
logItem.PageNumber = null;
logItem.PageSize = null;
logItem.Commit();
mapDbConnection.Close();
}
catch
{
/// Don't do anything. This is here because audit logging is a very low importance task and we don't want it potentially killing the more important tasks at hand.
}
if (!queryResponse.Nodes.ContainsKey(nodeId))
{
queryResponse.ErrorId = 1;
queryResponse.ErrorMessage = "Provided node ID context doesn't exist";
return(queryResponse);
}
queryResponse.AttachElements();
queryResponse.NodeContext = queryResponse.Nodes[nodeId];
if (maxDepth > 0 && edgeConditions != null && edgeConditions.EdgeCondition != null)
{
List <Guid> nodesToRemove = new List <Guid>();
List <Guid> relationshipsToRemove = new List <Guid>();
List <Guid> boundaryNodes = new List <Guid>();
List <Guid> boundaryRelationships = new List <Guid>();
for (int i = 1; i <= maxDepth; i++)
{
List <Node> nodes = orderedNodes[i];
foreach (Node node in nodes)
{
bool isBoundaryNode = false;
bool isBoundaryRelationship = false;
bool isNodeIncluded = true;
bool isRelationshipIncluded = true;
Relationship connectingRelationship = queryResponse.Relationships[node.ConnectingRelationship];
if (boundaryNodes.Contains(node.Origin))
{
isBoundaryNode = true;
isBoundaryRelationship = true;
isNodeIncluded = false;
isRelationshipIncluded = false;
}
else
{
EdgeResult relationshipEvalResult = edgeConditions.EdgeCondition.EvaluateCondition(connectingRelationship);
if (relationshipEvalResult.IsEdge.HasValue && relationshipEvalResult.IsEdge.Value)
{
// THis means the relationship was evaluated to be a boundary edge.
isBoundaryRelationship = true;
isRelationshipIncluded = relationshipEvalResult.IsIncluded;
}
EdgeResult nodeEvalResult = edgeConditions.EdgeCondition.EvaluateCondition(node);
if (nodeEvalResult.IsEdge.HasValue && nodeEvalResult.IsEdge.Value)
{
// This means the node was evaluated to be a boundary edge.
isBoundaryNode = true;
isNodeIncluded = nodeEvalResult.IsIncluded;
// The inclusion value for the node trumps the relationship value as the relationship is dependent on the node existing anyway.
isRelationshipIncluded = isNodeIncluded;
}
else if (isBoundaryRelationship)
{
// If the relationship was discovered to be a boundary then this node will be a boundary edge too.
isBoundaryNode = true;
isNodeIncluded = isRelationshipIncluded;
}
}
if (isBoundaryNode)
{
boundaryNodes.Add(node.NodeUid);
}
if (isBoundaryRelationship)
{
boundaryRelationships.Add(connectingRelationship.RelationshipUid);
}
if (!isNodeIncluded)
{
nodesToRemove.Add(node.NodeUid);
}
if (!isRelationshipIncluded)
{
relationshipsToRemove.Add(connectingRelationship.RelationshipUid);
}
}
}
foreach (Guid nodeIdToRemove in nodesToRemove)
{
queryResponse.Nodes.Remove(nodeIdToRemove);
}
foreach (Guid relationshipIdToRemove in relationshipsToRemove)
{
queryResponse.Relationships.Remove(relationshipIdToRemove);
}
}
int totalObjects = queryResponse.CountObjects();
queryResponse.Domain = new Domain();
queryResponse.Domain.DomainUid = domainId;
if (totalObjects > TransactionalMappingToolServiceCommonBase.HardObjectLimit || objectIndex > 0)
{
return(queryResponse.GetPage(objectIndex));
}
return(queryResponse);
}
}
/// <summary>
/// TODO: This method needs to be moved from here as it makes calls to schema specific methods.
/// </summary>
/// <param name="callingUrl"></param>
/// <param name="domainId"></param>
/// <param name="conditions"></param>
/// <param name="pageNumber"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public SearchMapResult SearchMap(IGlymaSession glymaSession, Guid domainId, Guid rootMapUid, SearchConditions conditions, int pageNumber = 1, int pageSize = 5)
{
SearchMapResult result = new SearchMapResult();
using (IDbConnectionAbstraction mapDbConnection = glymaSession.ConnectionFactory.CreateMapDbConnection())
{
mapDbConnection.Open();
SqlCommand findMetadata = conditions.BuildSearchQuery(mapDbConnection.Connection, rootMapUid, pageNumber, pageSize);
SqlDataReader matchingMetadata = findMetadata.ExecuteReader();
matchingMetadata.Read();
int totalMetadataCount = (int)matchingMetadata[0];
matchingMetadata.NextResult();
int currentMetadataPagePosition = pageNumber * pageSize;
DataTable nodesList;
result.Count = totalMetadataCount;
if (currentMetadataPagePosition > totalMetadataCount && pageNumber > 1)
{
int itemsToRemove = currentMetadataPagePosition - totalMetadataCount;
if (itemsToRemove >= pageSize)
{
result = new SearchMapResult();
return(result);
}
else
{
nodesList = new DataTable("NodesList");
nodesList.Load(matchingMetadata);
for (int i = 0; i < itemsToRemove; i++)
{
nodesList.Rows.RemoveAt(0);
}
nodesList.Columns.Remove("Modified");
}
}
else
{
nodesList = new DataTable("NodesList");
nodesList.Load(matchingMetadata);
nodesList.Columns.Remove("Modified");
}
QueryNodes queryNodes = new QueryNodes(mapDbConnection);
Dictionary <Guid, SearchedNode> nodes = queryNodes.GetNodes(nodesList);
result.SearchedNodes = nodes;
mapDbConnection.Close();
try
{
mapDbConnection.Open();
AuditLogItem logItem = new AuditLogItem(mapDbConnection.Connection);
logItem.OperationName = "SearchMap";
//logItem.CallingUrl = callingUrl;
logItem.DomainUid = domainId;
logItem.NodeUid = null;
logItem.RootMapUid = rootMapUid;
logItem.MaxDepth = null;
logItem.ObjectIndex = null;
logItem.EdgeConditions = null;
logItem.FilterConditions = null;
logItem.SearchConditions = null;
logItem.PageNumber = pageNumber;
logItem.PageSize = pageSize;
logItem.Commit();
mapDbConnection.Close();
}
catch
{
/// Don't do anything. This is here because audit logging is a very low importance task and we don't want it potentially killing the more important tasks at hand.
}
return(result);
}
}