public override void Init()
{
auditFactory = AuditFactory.CreateSingleton();
if (config.AuditConnectionString != null &&
config.AuditConnectionString.Contains("DefaultEndpointsProtocol"))
{
auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "messageaudit"),
AuditType.Message);
auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "useraudit"), AuditType.User);
}
else if (config.AuditConnectionString != null)
{
auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.Message);
auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.User);
}
messageAuditor = auditFactory.GetAuditor(AuditType.Message);
userAuditor = auditFactory.GetAuditor(AuditType.User);
logger?.LogDebugAsync("MQTT adapter audit factory added.").GetAwaiter();
forcePerReceiveAuthn = Channel as UdpChannel != null;
session.OnPublish += Session_OnPublish;
session.OnSubscribe += Session_OnSubscribe;
session.OnUnsubscribe += Session_OnUnsubscribe;
session.OnDisconnect += Session_OnDisconnect;
;
session.OnConnect += Session_OnConnect;
logger?.LogInformationAsync($"MQTT adpater on channel '{Channel.Id}' is initialized.").GetAwaiter();
}
/// <summary>
/// adds the new users and clients to userClients
/// </summary>
/// <param name="users"></param>
/// <param name="clients"></param>
private static void Allocate(IEnumerable <int> users, IEnumerable <int> clients, int actionUser)
{
using (EverestPortalContext context = new EverestPortalContext())
{
foreach (var userId in users)
{
foreach (var clientId in clients)
{
if (!context.userClient.Any(x => (x.UserID == userId && x.ClientID == clientId)))//Checks If already User Assigned to Client
{
context.userClient.Add(new UserClient {
UserID = userId, ClientID = clientId
});
}
}
;
}
context.SaveChanges();
foreach (var userId in users)
{
var objClient = context.Users.SingleOrDefault(p => p.UserID == userId);
IAuditLog log = AuditFactory.GetInstance(typeof(User).Name);
log.SaveVersion <User>(objClient, actionUser);
}
}
}
public AzureQueueStorageSink(SubscriptionMetadata metadata, ILog logger = null)
: base(metadata, logger)
{
loadQueue = new ConcurrentQueue <EventMessage>();
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
uri = new Uri(metadata.NotifyAddress);
NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query);
queue = nvc["queue"];
string ttlString = nvc["ttl"];
if (!string.IsNullOrEmpty(ttlString))
{
ttl = TimeSpan.Parse(ttlString);
}
Uri.TryCreate(metadata.SymmetricKey, UriKind.Absolute, out Uri sasUri);
if (sasUri == null)
{
storage = QueueStorage.New(
$"DefaultEndpointsProtocol=https;AccountName={uri.Authority.Split(new[] { '.' })[0]};AccountKey={metadata.SymmetricKey};",
10000, 1000);
}
else
{
string connectionString = $"BlobEndpoint={queue};SharedAccessSignature={metadata.SymmetricKey}";
storage = QueueStorage.New(connectionString, 1000, 5120000);
}
}
public WsnProtocolAdapter(PiraeusConfig config, GraphManager graphManager, IChannel channel, HttpContext context, ILog logger = null)
{
this.config = config;
this.graphManager = graphManager;
this.Channel = channel;
this.logger = logger;
IdentityDecoder decoder = new IdentityDecoder(config.ClientIdentityNameClaimType, context, config.GetClientIndexes());
identity = decoder.Id;
localIndexes = decoder.Indexes;
MessageUri messageUri = new MessageUri(context.Request);
this.contentType = messageUri.ContentType;
this.cacheKey = messageUri.CacheKey;
this.resource = messageUri.Resource;
this.subscriptions = messageUri.Subscriptions != null ? new List <string>(messageUri.Subscriptions) : null;
this.indexes = messageUri.Indexes != null ? new List <KeyValuePair <string, string> >(messageUri.Indexes) : null;
auditFactory = AuditFactory.CreateSingleton();
if (config.AuditConnectionString != null && config.AuditConnectionString.Contains("DefaultEndpointsProtocol"))
{
auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "messageaudit"), AuditType.Message);
auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "useraudit"), AuditType.User);
}
else if (config.AuditConnectionString != null)
{
auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.Message);
auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.User);
}
messageAuditor = auditFactory.GetAuditor(AuditType.Message);
userAuditor = auditFactory.GetAuditor(AuditType.User);
}
public override void Init()
{
Trace.TraceInformation("{0} - MQTT Protocol Adapter intialization on Channel '{1}'.", DateTime.UtcNow.ToString("yyyy-MM-ddTHH-MM-ss.fffff"), Channel.Id);
auditFactory = AuditFactory.CreateSingleton();
if (config.AuditConnectionString != null && config.AuditConnectionString.Contains("DefaultEndpointsProtocol"))
{
auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "messageaudit"), AuditType.Message);
auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "useraudit"), AuditType.User);
}
else if (config.AuditConnectionString != null)
{
auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.Message);
auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.User);
}
messageAuditor = auditFactory.GetAuditor(AuditType.Message);
userAuditor = auditFactory.GetAuditor(AuditType.User);
forcePerReceiveAuthn = Channel as UdpChannel != null;
session.OnPublish += Session_OnPublish;
session.OnSubscribe += Session_OnSubscribe;
session.OnUnsubscribe += Session_OnUnsubscribe;
session.OnDisconnect += Session_OnDisconnect;;
session.OnConnect += Session_OnConnect;
logger?.LogInformation($"MQTT adpater on channel '{Channel.Id}' is initialized.");
}
public EventGridSink(SubscriptionMetadata metadata)
: base(metadata)
{
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
uri = new Uri(metadata.NotifyAddress);
NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query);
topicHostname = uri.Authority;
topicKey = metadata.SymmetricKey;
string uriString = new Uri(metadata.SubscriptionUriString).ToString();
resourceUriString = uriString.Replace("/" + uri.Segments[uri.Segments.Length - 1], "");
if (!int.TryParse(nvc["clients"], out clientCount))
{
clientCount = 1;
}
ServiceClientCredentials credentials = new TopicCredentials(topicKey);
clients = new EventGridClient[clientCount];
for (int i = 0; i < clientCount; i++)
{
clients[i] = new EventGridClient(credentials);
}
}
public IoTHubSink(SubscriptionMetadata metadata, ILog logger = null)
: base(metadata, logger)
{
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
uri = new Uri(metadata.NotifyAddress);
NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query);
string keyName = nvc["keyname"];
deviceId = nvc["deviceid"];
methodName = nvc["method"];
propertyName = nvc["propname"];
propertyValue = nvc["propvalue"];
if (string.IsNullOrEmpty(methodName))
{
deviceClient = DeviceClient.CreateFromConnectionString(string.Format(
"HostName={0};DeviceId={1};SharedAccessKey={2}", uri.Authority, deviceId, metadata.SymmetricKey));
}
else
{
serviceClient = ServiceClient.CreateFromConnectionString(string.Format(
"HostName={0};SharedAccessKeyName={1};SharedAccessKey={2}", uri.Authority, keyName,
metadata.SymmetricKey));
}
}
public void DeleteUser(UserDTO uObj)
{
User Objuser = dbContext.Users.SingleOrDefault(p => p.UserID == uObj.UserID);
var userRoles = dbContext.userRole.Where(u => u.UserID == uObj.UserID);
var userClients = dbContext.userClient.Where(item => item.UserID == uObj.UserID).ToList();
var passwords = dbContext.PasswordHistories.Where(item => item.UserID == uObj.UserID).ToList();
var tokens = dbContext.ResetTokens.Where(item => item.UserID == uObj.UserID).ToList();
using (var transaction = dbContext.Database.BeginTransaction())
{
//delete from UserClients
dbContext.userClient.RemoveRange(userClients);
//delete from UserRole
dbContext.userRole.RemoveRange(userRoles);
//delete password history entries
dbContext.PasswordHistories.RemoveRange(passwords);
//delete password history entries
dbContext.ResetTokens.RemoveRange(tokens);
//delete from Users
dbContext.Users.Remove(Objuser);
//add entry in audit
IAuditLog log = AuditFactory.GetInstance(typeof(User).Name);
log.SaveVersion <User>(Objuser, uObj.ActionUser);
dbContext.SaveChanges();
transaction.Commit();
}
}
private void InitializeAuditor(PiraeusConfig config)
{
if (!string.IsNullOrEmpty(config.AuditConnectionString) &&
AuditFactory.CreateSingleton().GetAuditor(AuditType.User) == null)
{
auditFactory = AuditFactory.CreateSingleton();
if (config.AuditConnectionString.ToLowerInvariant().Contains("AccountName="))
{
auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "messageaudit"),
AuditType.Message);
auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "useraudit"), AuditType.User);
}
else
{
string pathString =
config.AuditConnectionString.LastIndexOf("/") == config.AuditConnectionString.Length - 1
? config.AuditConnectionString
: config.AuditConnectionString + "/";
auditFactory.Add(new FileAuditor(string.Format($"{pathString}messageaudit.txt")),
AuditType.Message);
auditFactory.Add(new FileAuditor(string.Format($"{pathString}useraudit.txt")), AuditType.User);
}
}
}
public RedisSink(SubscriptionMetadata metadata, ILog logger = null)
: base(metadata, logger)
{
tqueue = new TaskQueue();
cqm = new ConcurrentQueueManager();
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
uri = new Uri(metadata.NotifyAddress);
connectionString = $"{uri.Authority}:6380,password={metadata.SymmetricKey},ssl=True,abortConnect=False";
NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query);
if (!int.TryParse(nvc["db"], out dbNumber))
{
dbNumber = -1;
}
if (TimeSpan.TryParse(nvc["expiry"], out TimeSpan expiration))
{
expiry = expiration;
}
if (string.IsNullOrEmpty(metadata.ClaimKey))
{
cacheClaimType = metadata.ClaimKey;
}
connection = ConnectionMultiplexer.ConnectAsync(connectionString).GetAwaiter().GetResult();
database = connection.GetDatabase(dbNumber);
}
public WebHookSink(SubscriptionMetadata metadata, ILog logger)
: base(metadata, logger)
{
this.logger = logger;
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
address = new Uri(metadata.NotifyAddress).ToString();
}
public void SubmitMarketbaseDetailsInformation(int MarketBaseId)
{
var identity = (ClaimsIdentity)User.Identity;
int uid = Convert.ToInt32(identity.Claims.FirstOrDefault(c => c.Type == "userid").Value.ToString());
var objClient = _db.MarketBases.Where(u => u.Id == MarketBaseId).ToList <MarketBase>().FirstOrDefault();
IAuditLog log = AuditFactory.GetInstance(typeof(MarketBase).Name);
log.SaveVersion <MarketBase>(objClient, uid);
}
public static IAuditFactory CreateSingleton()
{
if (instance == null)
{
instance = new AuditFactory();
}
return(instance);
}
public void UseCaseShouldCallGatewayToInsertAuditData()
{
var auditRequest = TestHelpers.CreateAuditRequestObject(_faker);
_mockGateway.Setup(x => x.GenerateAdminAuditRecord(AuditFactory.ToAdminAuditRequest(auditRequest)));
_classUnderTest.CreateAdminAudit(auditRequest);
_mockGateway.Verify(x => x.GenerateAdminAuditRecord(It.IsAny <MyRentAccountAdminAudit>()), Times.Once);
}
public void CanMapInputToGenerateResidentAuditRequestObject()
{
var auditRequest = TestHelpers.CreateResidentAuditRequestObject(_faker, true);
var factoryResponse = AuditFactory.ToResidentAuditRequest(auditRequest);
factoryResponse.hackney_accountnumber.Should().Be(auditRequest.RentAccountNumber);
factoryResponse.hackney_postcode.Should().Be(auditRequest.PostCode);
}
public async Task <GetAllAuditsResponse> GetAuditByUser(string userEmail)
{
var envRecordLimit = Environment.GetEnvironmentVariable("AUDIT_RECORD_LIMIT");
int recordLimit = envRecordLimit != null?int.Parse(envRecordLimit) : 20;
var auditRecords = await _gateway.GetAuditByUser(userEmail.ToLower(), recordLimit);
//TODO: check querstring values are correct
return(AuditFactory.ToGetAllAuditsResponse(auditRecords));
}
public HttpResponseMessage SubmitMarketBase(int[] MarketBaseIds, int userId)
{
foreach (int MarketBaseId in MarketBaseIds)
{
var objClient = _db.MarketBases.Where(u => u.Id == MarketBaseId).ToList <MarketBase>().FirstOrDefault();
IAuditLog log = AuditFactory.GetInstance(typeof(MarketBase).Name);
log.SaveVersion <MarketBase>(objClient, userId);
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
public void CanMapInputToGenerateResidentAuditRequestObjectForAnonUser()
{
var auditRequest = TestHelpers.CreateResidentAuditRequestObject(_faker, false);
var factoryResponse = AuditFactory.ToResidentAuditRequest(auditRequest);
factoryResponse.hackney_accountnumber.Should().Be(auditRequest.RentAccountNumber);
factoryResponse.hackney_postcode.Should().Be(auditRequest.PostCode);
factoryResponse.hackney_name.Should().Equals("Anonymous Rent Account Audit History");
}
public CoapRequestDispatcher(CoapSession session, IChannel channel)
{
this.channel = channel;
this.session = session;
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
coapObserved = new Dictionary <string, byte[]>();
coapUnobserved = new HashSet <string>();
adapter = new OrleansAdapter(session.Identity, channel.TypeId, "CoAP");
adapter.OnObserve += Adapter_OnObserve;
LoadDurablesAsync().LogExceptions();
}
public async Task UseCaseShouldCallGatewayToInsertResidentAuditData()
{
var token = "12345";
var auditRequest = TestHelpers.CreateResidentAuditRequestObject(_faker, true);
_mockCrmTokenGateway.Setup(x => x.GetCRMToken()).ReturnsAsync(token);
_mockCrmGateway.Setup(x => x.GenerateResidentAuditRecord(AuditFactory.ToResidentAuditRequest(auditRequest), token)).ReturnsAsync(true);
await _classUnderTest.CreateResidentAudit(auditRequest).ConfigureAwait(true);
_mockCrmGateway.Verify(x => x.GenerateResidentAuditRecord(It.IsAny <MyRentAccountResidentAudit>(), token), Times.Once);
}
public MachineLearningSink(SubscriptionMetadata metadata, ILog logger = null)
: base(metadata, logger)
{
this.logger = logger;
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
uri = new Uri(metadata.NotifyAddress);
token = metadata.SymmetricKey;
NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query);
outputPiSystem = nvc["r"];
}
public HttpResponseMessage SubmitSubscription(int[] subscriptionIds, int UserId)
{
foreach (int subscriptionId in subscriptionIds)
{
var objClient = dbContext.subscription.Where(u => u.SubscriptionId == subscriptionId).ToList().FirstOrDefault();
IAuditLog log = AuditFactory.GetInstance(typeof(Subscription).Name);
log.SaveVersion <Subscription>(objClient, UserId);
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
public EventGridSink(SubscriptionMetadata metadata, ILog logger = null)
: base(metadata, logger)
{
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
uri = new Uri(metadata.NotifyAddress);
NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query);
topicHostname = uri.Authority;
topicKey = metadata.SymmetricKey;
string uriString = new Uri(metadata.SubscriptionUriString).ToString();
resourceUriString = uriString.Replace("/" + uri.Segments[^ 1], "");
public OrleansAdapter(string identity, string channelType, string protocolType, HttpContext context = null)
{
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
this.identity = identity;
this.channelType = channelType;
this.protocolType = protocolType;
this.context = context;
container = new Dictionary <string, Tuple <string, string> >();
ephemeralObservers = new Dictionary <string, IMessageObserver>();
durableObservers = new Dictionary <string, IMessageObserver>();
}
public void CanMapInputToGenerateAdminAuditRequestObject()
{
var auditRequest = TestHelpers.CreateAuditRequestObject(_faker);
var factoryResponse = AuditFactory.ToAdminAuditRequest(auditRequest);
factoryResponse.User.Should().Be(auditRequest.User);
factoryResponse.RentAccountNumber.Should().Be(auditRequest.RentAccountNumber);
factoryResponse.AuditAction.Should().Be(auditRequest.AuditAction);
factoryResponse.CSSOLogin.Should().Be(auditRequest.CSSOLogin.ToString());
factoryResponse.TimeStamp.Should().NotBeNullOrEmpty();
}
public ServiceBusTopicSink(SubscriptionMetadata metadata)
: base(metadata)
{
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
uri = new Uri(metadata.NotifyAddress);
NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query);
keyName = nvc["keyname"];
topic = nvc["topic"];
string symmetricKey = metadata.SymmetricKey;
connectionString = String.Format("Endpoint=sb://{0}/;SharedAccessKeyName={1};SharedAccessKey={2}", uri.Authority, keyName, symmetricKey);
}
public CoapRequestDispatcher(CoapSession session, IChannel channel, PiraeusConfig config, GraphManager graphManager, ILog logger = null)
{
this.channel = channel;
this.session = session;
this.config = config;
this.graphManager = graphManager;
this.logger = logger;
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
coapObserved = new Dictionary <string, byte[]>();
coapUnobserved = new HashSet <string>();
adapter = new OrleansAdapter(session.Identity, channel.TypeId, "CoAP", graphManager, logger);
adapter.OnObserve += Adapter_OnObserve;
LoadDurablesAsync().LogExceptions(logger);
}
public ServiceBusTopicSink(SubscriptionMetadata metadata, ILog logger = null)
: base(metadata, logger)
{
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
uri = new Uri(metadata.NotifyAddress);
NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query);
keyName = nvc["keyname"];
topic = nvc["topic"];
string symmetricKey = metadata.SymmetricKey;
connectionString =
$"Endpoint=sb://{uri.Authority}/;SharedAccessKeyName={keyName};SharedAccessKey={symmetricKey}";
}
public void CanMapAuditRecordsToGetAllAdminAuditsResponseObject()
{
var auditRecords = new List <AdminAuditRecord>
{
TestHelpers.CreateAuditRecordObject(_faker),
TestHelpers.CreateAuditRecordObject(_faker)
};
var factoryResponse = AuditFactory.ToGetAllAuditsResponse(auditRecords);
factoryResponse.Should().NotBeNull();
factoryResponse.AuditRecords.Count.Should().Equals(auditRecords.Count);
factoryResponse.AuditRecords[0].User.Should().Equals(auditRecords[0].User);
factoryResponse.AuditRecords[0].CSSOLogin.ToString().Should().Equals(auditRecords[0].CSSOLogin);
}
private void InitializeAuditor(PiraeusConfig config)
{
auditFactory = AuditFactory.CreateSingleton();
if (config.AuditConnectionString != null && config.AuditConnectionString.Contains("DefaultEndpointsProtocol"))
{
auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString), AuditType.Message);
auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString), AuditType.User);
}
else if (config.AuditConnectionString != null)
{
auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.Message);
auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.User);
}
userAuditor = auditFactory.GetAuditor(AuditType.User);
}
