public AnalyzeResult Audit(AuditMessage message, Configuration.Action setting)
{
var address = setting.GetSetting("address");
var format = setting.GetSetting("format");
var headers = setting.GetSetting("headers");
var webClient = new WebClient();
if (headers != null)
{
foreach (var header in headers.Split(';'))
{
var kvp = header.Split('=');
webClient.Headers.Add(kvp[0], kvp[1]);
}
}
webClient.UploadStringCompleted += (sender, args) => {
if (args.Error != null)
{
Log.LogError(args.Error.ToString());
}
};
webClient.UploadStringAsync(new System.Uri(address), Formatter.Format(message, format));
return(AnalyzeResult.Ok);
}
public async Task Audit(AuditMessage message)
{
if (!Directory.Exists(_outputDirectory))
{
Directory.CreateDirectory(_outputDirectory);
}
var filePrefix = DateTime.Now.ToString("yyyy-MM-dd-HHmmss");
var fileCounter = 1;
var path = Path.Combine(_outputDirectory, $"{filePrefix}-{fileCounter:000}.json");
while (File.Exists(path))
{
fileCounter++;
path = Path.Combine(_outputDirectory, $"{filePrefix}-{fileCounter:000}.json");
}
using (var stream = new FileStream(path, FileMode.CreateNew, FileAccess.Write))
using (var writer = new StreamWriter(stream))
{
await writer.WriteAsync(JsonConvert.SerializeObject(message, Formatting.Indented));
await writer.FlushAsync();
writer.Close();
}
}
public static AuditMessageModel ToModel(this AuditMessage entity)
{
var model = new AuditMessageModel()
{
Id = entity.Id,
Type = (AuditMessageType)entity.Type,
Message = entity.Message,
UserId = entity.UserId,
Status = !entity.Status.HasValue ? AuditMessageStatus.Unread : (AuditMessageStatus)entity.Status.Value,
CreatedTime = entity.CreatedTime.HasValue ? entity.CreatedTime.Value : DateTime.MinValue
};
using (var dbContext = new MissionskyOAEntities())
{
//Get english name
var userEntity = dbContext.Users.FirstOrDefault(it => it.Id == entity.UserId);
if (userEntity != null)
{
model.UserEnglishName = userEntity.EnglishName;
}
}
return(model);
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req, ILogger log)
{
var reqBody = await new StreamReader(req.Body).ReadToEndAsync();
var auditDetail = JsonConvert.DeserializeObject <AuditDetail>(reqBody);
var auditMessage = new AuditMessage
{
CreatedOn = DateTime.UtcNow,
Id = Guid.NewGuid(),
Email = auditDetail.Email,
ActionName = auditDetail.ActionName,
ControllerName = auditDetail.ControllerName,
SenderName = auditDetail.SenderName,
Name = auditDetail.Name,
ClientId = auditDetail.ClientId,
OrganisationId = auditDetail.OrganisationId,
PayLoad = JsonConvert.SerializeObject(auditDetail.Content)
};
string messageBody = JsonConvert.SerializeObject(auditMessage);
await _messagingGateway.SendMessageAsync(Encoding.UTF8.GetBytes(messageBody));
log.LogInformation("C# HTTP trigger InssAuditMessaging function processed a request.");
return(new OkResult());
}
/// <summary>
/// 添加初始审批信息
/// </summary>
private void AddAuditMessages(MissionskyOAEntities dbContext, OrderModel order, UserModel currentUser)
{
//添加初始审批信息，请假为Apply_Leave_Application_Message，加班为Apply_OT_Application_Message
var auditMessageType = (int)AuditMessageType.Apply_Leave_Application_Message;
if (order.OrderType == OrderType.Overtime)
{
auditMessageType = (int)AuditMessageType.Apply_OT_Application_Message;
}
var detail = order.OrderDets.FirstOrDefault();
var auditMessageEntitry = new AuditMessage()
{
Type = auditMessageType,
Message = detail != null && !string.IsNullOrEmpty(detail.Description) ? detail.Description : string.Empty,
UserId = currentUser.Id,
Status = (int)AuditMessageStatus.Unread,
CreatedTime = DateTime.Now
};
// 将审核消息保存到表[MissionskyOA_DEV].[dbo].[AuditMessage]
dbContext.AuditMessages.Add(auditMessageEntitry);
}
public async Task <bool> CreateAsync(CreateAuditMessage message)
{
using (var context = _contextFactory.CreateDataContext())
{
try
{
var entity = new AuditMessage
{
CreationTimestamp = message.Timestamp,
MessageId = message.MessageId,
MessageType = message.MessageType,
CustomerId = message.CustomerId,
SubjectTemplateId = message.SubjectTemplateId,
MessageTemplateId = message.MessageTemplateId,
Source = message.Source,
CallType = message.CallType,
FormattingStatus = message.FormattingStatus,
FormattingComment = message.FormattingComment,
DeliveryStatus = DeliveryStatus.Pending
};
context.AuditMessages.Add(entity);
await context.SaveChangesAsync();
return(true);
}
catch (DbUpdateException e)
{
_log.Warning("Error creating audit message entry", e);
return(false);
}
}
}
void AuditMessageQueueTransport_TransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
var message = e.Message;
// Get the xml content of the message in the audit Q that's being stored.
var doc = new XmlDocument();
doc.Load(new MemoryStream(message.Body));
var messageBodyXml = doc.InnerXml;
// Get the header list as a key value dictionary...
Dictionary <string, string> headerDictionary = message.Headers.ToDictionary(k => k.Key, v => v.Value);
var enclosedMessageType = headerDictionary["NServiceBus.EnclosedMessageTypes"];
string messageType = enclosedMessageType;
if (!String.IsNullOrWhiteSpace(enclosedMessageType))
{
messageType = enclosedMessageType.Split(new char[] { ',' }, StringSplitOptions.None)[0];
}
AuditMessage messageToStore = new AuditMessage
{
MessageId = message.Id,
OriginalMessageId = message.GetOriginalId(),
Body = messageBodyXml,
Headers = headerDictionary,
MessageType = messageType,
ReceivedTime = DateTime.ParseExact(headerDictionary["NServiceBus.TimeSent"], "yyyy-MM-dd HH:mm:ss:ffffff Z", System.Globalization.CultureInfo.InvariantCulture)
};
// Save the message
Console.WriteLine("Saving {0}", messageType);
Persister.Persist(messageToStore);
}
public async Task InsertAsync(AuditMessage auditMessage)
{
var entity = new AuditMessageEntity(GetPartitionKey(auditMessage.CreationDate), GetRowKey(auditMessage.Id));
Mapper.Map(auditMessage, entity);
await _storage.InsertAsync(entity);
}
public static string Format(AuditMessage message, string format)
{
foreach (var prop in typeof(AuditMessage).GetProperties())
{
format = format.ReplaceCaseInsensitive($"{{{prop.Name}}}", prop.GetValue(message)?.ToString());
}
return(format);
}
public void Persist(AuditMessage message)
{
using (var session = DocumentStore.OpenSession())
{
string id = message.MessageId;
session.Store(message);
session.SaveChanges();
}
}
public void Persist(AuditMessage message)
{
using (var session = DocumentStore.OpenSession())
{
string id = message.MessageId;
session.Store(message);
session.SaveChanges();
}
}
public async Task WriteAudit(AuditMessage message)
{
foreach (var builder in _builders)
{
builder.Build(message);
}
await _client.Audit(message);
}
public async Task Audit(AuditMessage message)
{
var baseUrl = _configuration.ApiBaseUrl.EndsWith("/")
? _configuration.ApiBaseUrl
: _configuration.ApiBaseUrl + "/";
var url = $"{baseUrl}api/audit";
await _httpClient.PostAsync(url, message);
}
/// <summary>
/// Logs the audit message.
/// </summary>
/// <param name="message">The message.</param>
public void LogAudit(string message)
{
using (ISession session = this.sessionFactory.OpenSession())
{
AuditMessage auditMessage = new AuditMessage();
auditMessage.Message = message;
session.Save(auditMessage);
}
}
private string GetInstrument(AuditMessage auditMessage)
{
var instrument = auditMessage.CurrentValues?.ContainsKey("InstrumentId") ?? false
? $"{auditMessage.CurrentValues["InstrumentId"]}"
: (auditMessage.PreviousValues?.ContainsKey("InstrumentId") ?? false
? $"{auditMessage.PreviousValues["InstrumentId"]}"
: "UNKNOWN_INSTRUMENT");
return(instrument);
}
private string GetAsset(AuditMessage auditMessage)
{
var asset = auditMessage.CurrentValues?.ContainsKey("Asset") ?? false
? $"{auditMessage.CurrentValues["Asset"]}"
: (auditMessage.PreviousValues?.ContainsKey("Asset") ?? false
? $"{auditMessage.PreviousValues["Asset"]}"
: "UNKNOWN_ASSET");
return(asset);
}
private void persistAudit(AuditMessage message)
{
var audit = new Audit
{
Message = message,
Timestamp = _systemTime.UtcNow()
};
_transaction.Execute <IDocumentSession>(x => x.Store(audit));
}
private void persistAudit(AuditMessage message)
{
var audit = new Audit
{
Message = message,
Timestamp = _systemTime.UtcNow()
};
_transaction.WithRepository(repo => repo.Update(audit));
}
private string GetAssetDisplayId(AuditMessage auditMessage)
{
var asset = auditMessage.CurrentValues?.ContainsKey("DisplayId") ?? false
? $"{auditMessage.CurrentValues["DisplayId"]}"
: (auditMessage.PreviousValues?.ContainsKey("DisplayId") ?? false
? $"{auditMessage.PreviousValues["DisplayId"]}"
: null);
return(asset);
}
private string GetAssetPairName(AuditMessage auditMessage)
{
var asset = auditMessage.CurrentValues?.ContainsKey("Name") ?? false
? $"{auditMessage.CurrentValues["Name"]}"
: (auditMessage.PreviousValues?.ContainsKey("Name") ?? false
? $"{auditMessage.PreviousValues["Name"]}"
: null);
return(asset);
}
private async Task ProcessMessageAsync(AuditMessage auditMessage)
{
try
{
await _handler.Publish(auditMessage);
}
catch (Exception ex)
{
await _log.WriteErrorAsync(nameof(NettingEngineAuditSubscriber), nameof(ProcessMessageAsync), $"auditMessage {auditMessage.ToJson()}", ex);
}
}
public async Task DoAudit(
[ServiceBusTrigger(Endpoints.AuditMessage, Connection = "ServiceBusConnectionString")]
AuditMessage message,
Microsoft.Azure.WebJobs.ExecutionContext context,
ILogger log)
{
// Map the integration message to a command for our handler
var command = mapper.Map <CreateAuditCommand>(message);
// execute command
await this.ExecuteAsync <CreateAuditCommand>(context, command);
}
/// <summary>
/// Send the audit
/// </summary>
private static void SendAudit(AuditMessage message)
{
var endpoint = new Uri(ConfigurationManager.AppSettings["arrEndpoint"]);
IPEndPoint ipep = new IPEndPoint(IPAddress.Parse(endpoint.Host), endpoint.Port);
ITransporter transport = null;
switch (endpoint.Scheme)
{
case "udp":
transport = new UdpSyslogTransport(ipep);
break;
case "tcp":
transport = new TcpSyslogTransport(ipep);
break;
case "stcp":
String localCertHash = ConfigurationManager.AppSettings["myCertificateHash"],
remoteCertHash = ConfigurationManager.AppSettings["remoteCertificateHash"];
// Certs
X509Certificate2 localCert = null, remoteCert = null;
if (localCertHash != null)
{
string[] parts = localCertHash.Split(',');
StoreLocation loc = (StoreLocation)Enum.Parse(typeof(StoreLocation), parts[0]);
StoreName name = (StoreName)Enum.Parse(typeof(StoreName), parts[1]);
localCert = MllpMessageSender.FindCertificate(name, loc, X509FindType.FindByThumbprint, parts[2]);
}
if (remoteCertHash != null)
{
string[] parts = remoteCertHash.Split(',');
StoreLocation loc = (StoreLocation)Enum.Parse(typeof(StoreLocation), parts[0]);
StoreName name = (StoreName)Enum.Parse(typeof(StoreName), parts[1]);
remoteCert = MllpMessageSender.FindCertificate(name, loc, X509FindType.FindByThumbprint, parts[2]);
}
transport = new STcpSyslogTransport(ipep)
{
ClientCertificate = localCert,
ServerCertificate = remoteCert
};
break;
}
// Now now now... we send
transport.SendMessage(message);
}
static async Task GenerateMessages(string destination, QueueInfo queueInfo, CancellationToken token)
{
var throttle = new SemaphoreSlim(SettingsReader <int> .Read(ConfigRoot, "ConcurrentSends", 32));
var bodySize = SettingsReader <int> .Read(ConfigRoot, "BodySize", 0);
var random = new Random();
var sendMeter = Metric.Meter(destination, Unit.Custom("audits"));
while (!token.IsCancellationRequested)
{
await throttle.WaitAsync(token).ConfigureAwait(false);
// We don't need to wait for this task
// ReSharper disable once UnusedVariable
var sendTask = Task.Run(async() =>
{
try
{
var ops = new SendOptions();
ops.SetHeader(Headers.HostId, HostId);
ops.SetHeader(Headers.HostDisplayName, "Load Generator");
ops.SetHeader(Headers.ProcessingMachine, RuntimeEnvironment.MachineName);
ops.SetHeader(Headers.ProcessingEndpoint, "LoadGenerator");
var now = DateTime.UtcNow;
ops.SetHeader(Headers.ProcessingStarted, DateTimeExtensions.ToWireFormattedString(now));
ops.SetHeader(Headers.ProcessingEnded, DateTimeExtensions.ToWireFormattedString(now));
ops.SetDestination(destination);
var auditMessage = new AuditMessage();
auditMessage.Data = new byte[bodySize];
random.NextBytes(auditMessage.Data);
await endpointInstance.Send(auditMessage, ops).ConfigureAwait(false);
queueInfo.Sent();
sendMeter.Mark();
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
throttle.Release();
}
}, token);
}
}
public void CreateEmployeeAudit()
{
context.Employees.Add(new Employee()
{
Name = "Test User",
Position = "Tester"
});
context.SaveChanges();
AuditMessage message = context.AuditMessages.OrderByDescending(x => x.Date).First();
Assert.AreEqual("Employee \"Test User\" (Tester) was added.", message.Message);
}
public void Build(AuditMessage message)
{
var name = Assembly.GetExecutingAssembly();
message.Source = new Audit.Types.Source
{
System = "SFA.DAS.Tools.Servicebus.Support.Web",
Component = name.GetName().Name,
Version = name.GetName().Version.ToString()
};
message.ChangeAt = DateTime.UtcNow;
}
public virtual async Task PostAsync(string url, AuditMessage message)
{
var authenticationResult = await GetAuthenticationResult(_configuration.ClientId, _configuration.ClientSecret, _configuration.IdentifierUri, _configuration.Tenant);
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", authenticationResult.AccessToken);
client.DefaultRequestHeaders.Add("api-version", "1");
client.DefaultRequestHeaders.Add("accept", "application/json");
var response = await client.PostAsync(url, new StringContent(JsonConvert.SerializeObject(message), Encoding.UTF8, "application/json"));
}
}
public FormatterTest()
{
auditMessage = new AuditMessage
{
Administrator = true,
ApplicationName = "app",
ComputerName = "comp",
ContentPath = "ps1",
DomainName = "domain",
Rule = "rule",
Script = "script"
};
}
public AnalyzeResult Audit(AuditMessage message, Configuration.Action setting)
{
var path = setting.GetSetting("Path");
var format = setting.GetSetting("Format");
path = Environment.ExpandEnvironmentVariables(path);
var output = Formatter.Format(message, format);
File.AppendAllText(path, output + Environment.NewLine);
return(AnalyzeResult.Ok);
}
public void Arrange()
{
_auditRepository = new Mock <IWritableAuditRepository>();
_auditRepository.Setup(r => r.StoreAsync(It.IsAny <AuditMessage>()))
.Returns(Task.FromResult <object>(null));
_handler = new SaveAuditMessageCommandHandler(_auditRepository.Object);
_auditMessage = new AuditMessage();
_command = new SaveAuditMessageCommand
{
Message = _auditMessage
};
}
public AuditMessage Build()
{
var message = new AuditMessage
{
ChangeAt = DateTime.UtcNow
};
foreach (var builder in MessageBuilders)
{
builder.Invoke(message);
}
return(message);
}
static void Main(string[] args)
{
string m_UserName = "******"; //TODO: For BatchSvc, you must authenticate with username/password.
string m_PassWord = "******"; //TODO: That credential set must have Admin-level access.
string m_Url = "https://development.avalara.net"; //Service URL
int m_CompanyID = 49275; //This should be your CompanyID (not company code!)
BatchSvc svc = new BatchSvc(m_Url, m_UserName, m_PassWord); //Create the service object
AuditMessage msg = new AuditMessage();
msg.Message = "Testing of imports/batchsvc"; //An audit message is required, but will only be visible on internal Avalara server audits.
svc.AuditMessageValue = msg;
loadBatch(svc, m_CompanyID);
Console.ReadLine();
}
void AuditMessageQueueTransport_TransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
var message = e.Message;
// Get the xml content of the message in the audit Q that's being stored.
var doc = new XmlDocument();
doc.Load(new MemoryStream(message.Body));
var messageBodyXml = doc.InnerXml;
// Get the header list as a key value dictionary...
Dictionary<string, string> headerDictionary = message.Headers.ToDictionary(k => k.Key, v => v.Value);
var enclosedMessageType = headerDictionary["NServiceBus.EnclosedMessageTypes"];
string messageType = enclosedMessageType;
if (!String.IsNullOrWhiteSpace(enclosedMessageType))
{
messageType = enclosedMessageType.Split(new char[] { ',' }, StringSplitOptions.None)[0];
}
AuditMessage messageToStore = new AuditMessage
{
MessageId = message.Id,
OriginalMessageId = message.GetOriginalId(),
Body = messageBodyXml,
Headers = headerDictionary,
MessageType = messageType,
ReceivedTime = DateTime.ParseExact(headerDictionary["NServiceBus.TimeSent"], "yyyy-MM-dd HH:mm:ss:ffffff Z", System.Globalization.CultureInfo.InvariantCulture)
};
// Save the message
Console.WriteLine("Saving {0}", messageType);
Persister.Persist(messageToStore);
}
