internal void WriteAuditLog()
{
if (AuditLogger != null)
{
using (IEnumerator <DbEntityEntry <ModelBase> > enumerator = ChangeTracker.Entries <ModelBase>().Where(delegate(DbEntityEntry <ModelBase> p)
{
if ((p.State != EntityState.Added) && (p.State != EntityState.Deleted))
{
return(p.State == EntityState.Modified);
}
return(true);
}).GetEnumerator())
{
while (enumerator.MoveNext())
{
DbEntityEntry <ModelBase> dbEntry = enumerator.Current;
string operaterName;
if (dbEntry.Entity.GetType().GetCustomAttributes(typeof(AuditableAttribute), false).SingleOrDefault() is AuditableAttribute)
{
operaterName = WCFContext.Current.Operater.Name;
Task.Factory.StartNew(delegate
{
TableAttribute attribute = dbEntry.Entity.GetType().GetCustomAttributes(typeof(TableAttribute), false).SingleOrDefault() as TableAttribute;
string tableName = (attribute != null) ? attribute.Name : dbEntry.Entity.GetType().Name;
string moduleName = dbEntry.Entity.GetType().FullName.Split('.').Skip(1).FirstOrDefault();
AuditLogger.WriteLog(dbEntry.Entity.ID, operaterName, moduleName, tableName, dbEntry.State.ToString(), dbEntry.Entity);
});
}
}
}
}
}
public ChangePersonalDetailsController(
IDataRepository dataRepository,
AuditLogger auditLogger)
{
this.dataRepository = dataRepository;
this.auditLogger = auditLogger;
}
public Configuration(DbContext context, DbContext audit)
{
IAuditLogger logger = new AuditLogger(audit, 0);
UnitOfWork = new UnitOfWork(context, logger);
Context = context;
}
public static ApplicationUserManager Create(IdentityFactoryOptions <ApplicationUserManager> options, IOwinContext context)
{
var dbContext = context.Get <EnergyNetworkDbContext>();
_audit = dbContext.BeginAudit(AuditLoggerConfig.GetConfiguredAuditLogger());
var manager = new ApplicationUserManager(new UserStore <UserProfile>(dbContext));
// Configure validation logic for usernames
manager.UserValidator = new UserValidator <UserProfile>(manager)
{
AllowOnlyAlphanumericUserNames = true,
RequireUniqueEmail = true
};
// Configure validation logic for passwords
manager.PasswordValidator = new PasswordValidator {
RequiredLength = 6,
RequireNonLetterOrDigit = false,
RequireDigit = false,
RequireLowercase = false,
RequireUppercase = false
};
manager.UserLockoutEnabledByDefault = true;
manager.EmailService = new EmailService();
var dataProtectionProvider = options.DataProtectionProvider;
if (dataProtectionProvider != null)
{
manager.UserTokenProvider = new DataProtectorTokenProvider <UserProfile>(dataProtectionProvider.Create("ASP.NET Identity"));
}
return(manager);
}
public AdminReturnLateFlagController(
IAdminService adminService,
AuditLogger auditLogger)
{
_adminService = adminService;
this.auditLogger = auditLogger;
}
public AdminUserContactPreferencesController(
IAdminService adminService,
AuditLogger auditLogger)
{
_adminService = adminService;
this.auditLogger = auditLogger;
}
public T Create(T entity)
{
using (var transaction = new TransactionScope())
{
var dbEntityEntry = _dbContext.Entry(entity);
if (dbEntityEntry.State != EntityState.Detached)
{
dbEntityEntry.State = EntityState.Added;
}
else
{
_dbSet.Add(entity);
}
var auditLogService = new AuditLogger(_dbContext, _userId);
auditLogService.AuditCreatedBefore(new List <IEntity> {
entity
});
_dbContext.SaveChanges();
auditLogService.AuditCreatedAfter(new List <IEntity> {
entity
});
transaction.Complete();
return(entity);
}
}
public void BeginAuditLog()
{
if (_auditLog == null)
{
_auditLog = _dbContext.BeginAudit();
}
}
public void ShouldPopulateWithHttpContext()
{
DefaultHttpContext ctx = new DefaultHttpContext();
ctx.Connection.RemoteIpAddress = new System.Net.IPAddress(new byte[] { 127, 0, 0, 1 });
AuditEvent expected = new AuditEvent()
{
ApplicationType = ApplicationType.Configuration,
ClientIP = "127.0.0.1",
Trace = ctx.TraceIdentifier,
TransactionName = @"\",
TransactionResultCode = AuditTransactionResult.Success,
TransactionVersion = ""
};
Mock <ILogger <IAuditLogger> > logger = new Mock <ILogger <IAuditLogger> >();
Mock <IWriteAuditEventDelegate> dbContext = new Mock <IWriteAuditEventDelegate>();
Mock <IConfiguration> config = new Mock <IConfiguration>();
AuditLogger auditLogger = new AuditLogger(logger.Object, dbContext.Object, config.Object);
AuditEvent actual = new AuditEvent();
auditLogger.PopulateWithHttpContext(ctx, actual);
Assert.True(expected.IsDeepEqual(actual));
}
public void Create(IEnumerable <T> entities)
{
using (var transaction = new TransactionScope())
{
foreach (var entity in entities)
{
var dbEntityEntry = _dbContext.Entry(entity);
if (dbEntityEntry.State != EntityState.Detached)
{
dbEntityEntry.State = EntityState.Added;
}
}
_dbSet.AddRange(entities);
var auditLogService = new AuditLogger(_dbContext, _userId);
auditLogService.AuditCreatedBefore(entities.ToList <IEntity>());
_dbContext.SaveChanges();
auditLogService.AuditCreatedAfter(entities.ToList <IEntity>());
transaction.Complete();
}
}
public AdminOrganisationSectorController(
IDataRepository dataRepository,
AuditLogger auditLogger)
{
this.dataRepository = dataRepository;
this.auditLogger = auditLogger;
}
public static void Main(string[] args)
{
var busoption = BusOptions.CreateFromEnvironment();
var builder = new DbContextOptionsBuilder <AuditContext>();
builder.UseSqlServer(Environment.GetEnvironmentVariable("dbconnectionstring"));
var options = builder.Options;
var eventRepo = new EventRepository(options);
var logService = new LogService(new DirectoryInfo(Path.Combine(Environment.GetEnvironmentVariable("logpath"), "RabbitMqLog")));
while (true)
{
try
{
using (var rabbit = new RabbitMqConnection(busoption))
using (var logger = new AuditLogger(eventRepo, rabbit, logService))
{
while (rabbit.Channel.IsOpen)
{
Thread.Sleep(60000);
}
logService.Log(new LogMessage("Lost connection with RabbitMq"));
}
}
catch (Exception e)
{
logService.LogException(new LogMessage(e.Message, e.StackTrace));
Thread.Sleep(5000);
}
}
}
/// <summary>
/// ctor
/// </summary>
public UnitOfWork(IBreezeValidator breezevalidator)
{
_contextProvider = new EFContextProvider <EnergyNetworkDbContext>();
_contextProvider.BeforeSaveEntitiesDelegate = breezevalidator.BeforeSaveEntities;
_contextProvider.BeforeSaveEntityDelegate = breezevalidator.BeforeSaveEntity;
_audit = _contextProvider.Context.BeginAudit(AuditLoggerConfig.GetConfiguredAuditLogger());
NetworkRepository = new Repository <Network>(_contextProvider.Context);
CompanyRepository = new Repository <Company>(_contextProvider.Context);
NetworkCompanyRepository = new Repository <NetworkCompany>(_contextProvider.Context);
MeasureRepository = new Repository <Measure>(_contextProvider.Context);
InvitationRepository = new Repository <Invitation>(_contextProvider.Context);
MeasureStateRepository = new Repository <MeasureState>(_contextProvider.Context);
EnergySourceRepository = new Repository <EnergySource>(_contextProvider.Context);
OutputUnitRepository = new Repository <OutputUnit>(_contextProvider.Context);
EnergySavingRepository = new Repository <EnergySaving>(_contextProvider.Context);
SurveyRepository = new Repository <Survey>(_contextProvider.Context);
UserProfileRepository = new Repository <UserProfile>(_contextProvider.Context);
DocumentContentRepository = new Repository <DocumentContent>(_contextProvider.Context);
DocumentRepository = new Repository <Document>(_contextProvider.Context);
InvestmentPlanRepository = new Repository <InvestmentPlan>(_contextProvider.Context);
ComparisonRepository = new Repository <Comparison>(_contextProvider.Context);
AreaRepository = new Repository <Area>(_contextProvider.Context);
ProductRepository = new Repository <Product>(_contextProvider.Context);
ProductionTimeRepository = new Repository <ProductionTime>(_contextProvider.Context);
ReadingRepository = new Repository <Reading>(_contextProvider.Context);
ImportantTopicRepository = new Repository <ImportantTopic>(_contextProvider.Context);
ChangeSetRepository = new Repository <ChangeSet>(_contextProvider.Context);
ChangeRepository = new Repository <Change>(_contextProvider.Context);
CompanySizeRepository = new Repository <CompanySize>(_contextProvider.Context);
FiscalYearRepository = new Repository <FiscalYear>(_contextProvider.Context);
OperationTimeRepository = new Repository <OperationTime>(_contextProvider.Context);
}
public AdminOrganisationScopeController(
IAdminService adminService,
AuditLogger auditLogger)
{
_adminService = adminService;
this.auditLogger = auditLogger;
}
private List <AuditEntity> CreateAuditTrail(AuditLogger audit, User currentUser)
{
var log = audit.LastLog;
//remove entities don't have properties changed
log.Entities = log.Entities.Where(e => e.Properties.Count > 0).ToList();
if (log.Entities.Count > 0)
{
//performance hack applied
bool acd = this.Configuration.AutoDetectChangesEnabled;
bool vos = this.Configuration.ValidateOnSaveEnabled;
this.Configuration.AutoDetectChangesEnabled = false;
this.Configuration.ValidateOnSaveEnabled = false;
this.Set <AuditTrail>().Add(new AuditTrail
{
CreatedDateTime = Clock.Now,
ModifiedDateTime = Clock.Now,
CreatedUser = currentUser.Name,
ModifiedUser = currentUser.Name,
Date = log.Date,
LogXml = log.ToXml()
});
base.SaveChanges();
this.Configuration.AutoDetectChangesEnabled = acd;
this.Configuration.ValidateOnSaveEnabled = vos;
}
return(log.Entities);
}
public static ApplicationRoleManager Create(IdentityFactoryOptions <ApplicationRoleManager> options, IOwinContext context)
{
var dbContext = context.Get <EnergyNetworkDbContext>();
_audit = dbContext.BeginAudit(AuditLoggerConfig.GetConfiguredAuditLogger());
return(new ApplicationRoleManager(new RoleStore <IdentityRole>(context.Get <EnergyNetworkDbContext>())));
}
protected override void Seed(Context context)
{
IAuditLogger logger = new AuditLogger(new Context(), 0);
UnitOfWork = new UnitOfWork(context, logger);
SeedData();
}
public void Dispose_Context()
{
TestingContext context = Substitute.For<TestingContext>();
AuditLogger logger = new AuditLogger(context);
logger.Dispose();
context.Received().Dispose();
}
public void AuditLogger_AccountId_DisablesChangesDetection()
{
TestingContext context = new TestingContext();
context.Configuration.AutoDetectChangesEnabled = true;
using (AuditLogger logger = new AuditLogger(context, "Test"))
Assert.False(context.Configuration.AutoDetectChangesEnabled);
}
public AdminOrganisationAddressController(
IDataRepository dataRepository,
ICompaniesHouseAPI companiesHouseApi,
AuditLogger auditLogger)
{
this.dataRepository = dataRepository;
this.companiesHouseApi = companiesHouseApi;
this.auditLogger = auditLogger;
}
public AdminUserResendVerificationEmailController(
IDataRepository dataRepository,
AuditLogger auditLogger,
EmailSendingService emailSendingService)
{
this.dataRepository = dataRepository;
this.auditLogger = auditLogger;
this.emailSendingService = emailSendingService;
}
public AdminRemoveUserFromOrganisationController(
IDataRepository dataRepository,
AuditLogger auditLogger,
EmailSendingService emailSendingService)
{
this.dataRepository = dataRepository;
this.auditLogger = auditLogger;
this.emailSendingService = emailSendingService;
}
public AdminUserResendVerificationEmailController(
IAdminService adminService,
AuditLogger auditLogger,
ILogger <AdminUserResendVerificationEmailController> logger, IWebService webService,
ISharedBusinessLogic sharedBusinessLogic) : base(logger, webService, sharedBusinessLogic)
{
_adminService = adminService;
this.auditLogger = auditLogger;
}
public void Dispose_Context()
{
TestingContext context = Substitute.For <TestingContext>();
AuditLogger logger = new AuditLogger(context);
logger.Dispose();
context.Received().Dispose();
}
public AdminOrganisationCompaniesHouseOptInOutController(IDataRepository dataRepository,
AuditLogger auditLogger,
ICompaniesHouseAPI companiesHouseApi,
UpdateFromCompaniesHouseService updateFromCompaniesHouseService)
{
this.dataRepository = dataRepository;
this.auditLogger = auditLogger;
this.companiesHouseApi = companiesHouseApi;
this.updateFromCompaniesHouseService = updateFromCompaniesHouseService;
}
public void Dispose_DisposesContext()
{
DbContext context = Substitute.For <DbContext>();
logger = Substitute.ForPartsOf <AuditLogger>(context);
logger.Dispose();
context.Received().Dispose();
}
public void Save_Logs()
{
TestingContext context = Substitute.For <TestingContext>();
logger = Substitute.ForPartsOf <AuditLogger>(context);
logger.Save();
context.Received().SaveChanges();
}
protected override void Seed(Context context)
{
IAuditLogger logger = new AuditLogger(new Context(), 0);
UnitOfWork = new UnitOfWork(context, logger);
SeedPermissions();
SeedRoles();
SeedAccounts();
}
public AuditLoggerTests()
{
context = new TestingContext();
logger = new AuditLogger(context, 1);
TestingContext dataContext = new TestingContext();
TestModel model = ObjectsFactory.CreateTestModel();
entry = dataContext.Entry <BaseModel>(dataContext.Add(model).Entity);
dataContext.SaveChanges();
}
private void Audit(IInvocation invocation)
{
AuditAttribute audit = invocation.GetAudit();
if (audit != null)
{
AuditLogger.Add(Session.UserId ?? Guid.Empty, Session.Application, Session.IP,
audit.Source, audit.Action.ToString(), invocation.Arguments);
}
}
public RegistrationRepository(
IDataRepository dataRepository,
AuditLogger auditLogger,
PinInThePostService pinInThePostService,
EmailSendingService emailSendingService)
{
this.dataRepository = dataRepository;
this.auditLogger = auditLogger;
this.pinInThePostService = pinInThePostService;
this.emailSendingService = emailSendingService;
}
public AuditLoggerTests()
{
context = new TestingContext();
dataContext = new TestingContext();
TestModel model = ObjectFactory.CreateTestModel();
logger = Substitute.ForPartsOf<AuditLogger>(context);
entry = dataContext.Entry<BaseModel>(dataContext.Set<TestModel>().Add(model));
dataContext.Set<TestModel>().RemoveRange(dataContext.Set<TestModel>());
dataContext.SaveChanges();
}
public void Save_Logs()
{
TestingContext context = Substitute.For<TestingContext>();
logger = Substitute.ForPartsOf<AuditLogger>(context);
logger.Save();
context.Received().SaveChanges();
}
public void Log_AddsLogToTheSet(String accountId, String identityName, String expectedAccountId)
{
HttpContext.Current = HttpContextFactory.CreateHttpContext();
HttpContext.Current.User.Identity.Name.Returns(identityName);
LoggableEntity entity = new LoggableEntity(entry);
logger = new AuditLogger(context, accountId);
logger.Log(entity);
AuditLog actual = context.ChangeTracker.Entries<AuditLog>().First().Entity;
LoggableEntity expected = entity;
Assert.Equal(expectedAccountId, actual.AccountId);
Assert.Equal(expected.ToString(), actual.Changes);
Assert.Equal(expected.Name, actual.EntityName);
Assert.Equal(expected.Action, actual.Action);
Assert.Equal(expected.Id, actual.EntityId);
}
