public GenresService(IGenresRepository genresRepository, ISaveRepository unitOfWork, IMemoryCache cache, ILogger <GenresService> logger)
{
this._genresRepository = genresRepository;
this._unitOfWork = unitOfWork;
this._cache = cache;
this._logger = logger;
}
public MoviesService(IMoviesRepository moviesRepository, ISaveRepository unitOfWork, IMemoryCache cache, ILogger <MoviesService> logger)
{
this._moviesRepository = moviesRepository;
this._unitOfWork = unitOfWork;
this._cache = cache;
this._logger = logger;
}
public void Initialize()
{
_builder = new DbContextOptionsBuilder <AppDbContext>().UseInMemoryDatabase(Guid.NewGuid().ToString());
_appDbContext = new AppDbContext(_builder.Options);
_lookupRepository = new LookupRepository(_appDbContext);
_saveRepository = new SaveRepository(_appDbContext);
}
private void Repo_CreateOrUpdateLogEntry(ISaveRepository repo, LogEntryViewModel Entry)
{
var en = mapper.Map <LogEntryViewModel, LogEntry>(Entry);
en = repo.CreateOrUpdateLogEntry(en).Result;
Entry.Id = en.Id;
}
public ModerController(UserManager <User> userManager,
ApplicationDbContext dbContext,
ISaveRepository saveRepository)
{
_userManager = userManager;
_dbContext = dbContext;
_saveRepository = saveRepository;
}
public TradeService(
ITradeRepository tradeRepository,
ISaveRepository unitOfWork,
ILogger <TradeService> logger)
{
_tradeRepository = tradeRepository;
_unitOfWork = unitOfWork;
_logger = logger;
}
protected PostController(ISaveRepository <TEntity> entityRepository)
{
_entityRepository = entityRepository;
var config = new MapperConfiguration(GetMappingExpression);
config.AssertConfigurationIsValid();
Mapper = new Mapper(config);
}
public EventController(UserManager <User> userManager,
ApplicationDbContext dbContext,
IFileManager fileManager,
ISaveRepository saveRepository)
{
_userManager = userManager;
_dbContext = dbContext;
_fileManager = fileManager;
_saveRepository = saveRepository;
}
public TravelReviewService()
{
IRepository <TravelReview> repository = RepositoryFactory.GetRepository <TravelReview>();
this._saveRepository = repository;
this._getRepository = repository;
this._transportService = new TransportService();
this._travelFeelingService = new TravelFeelingService();
}
public CategoryService(
ICategoryRepository categoryRepository,
ISaveRepository unitOfWork,
IMemoryCache cache,
ILogger <CategoryService> logger)
{
_categoryRepository = categoryRepository;
_unitOfWork = unitOfWork;
_cache = cache;
_logger = logger;
}
public LookupService(
ILookupRepository lookupsRepository
, ISaveRepository unitOfWork
, IMemoryCache cache
, ILogger <LookupService> logger)
{
_lookupRepository = lookupsRepository;
_unitOfWork = unitOfWork;
_cache = cache;
_logger = logger;
}
public PetService(
IPetRepository petRepository
, ISaveRepository unitOfWork
, IMemoryCache cache
, ILogger <PetService> logger)
{
_petRepository = petRepository;
_unitOfWork = unitOfWork;
_cache = cache;
_logger = logger;
}
public static ISaveRepository <T> BuildAndGetSaveRepository <T>(Tech tech, IConfiguration configuration)
{
ISaveRepository <T> saveRepository = null;
switch (tech)
{
case Tech.Mongodb:
saveRepository = new MongodbSaveRepository <T>(GetMongoDatabase(configuration));
break;
}
return(saveRepository);
}
public UpdateBioHandler(ISaveRepository <User> saveRepository, IUserRepository userRepository)
{
this.saveRepository = saveRepository;
this.userRepository = userRepository;
}
public void Connect(ISaveRepository repo)
{
///////////////////
// Boards AutoSaver
///////////////////
var boardsChanges = Boards.Connect().Publish();
SubscribeChanged(boardsChanges,
bvm =>
{
mon.LogicVerbose($"Box.Boards.ItemChanged {bvm.Id}::{bvm.Name}::{bvm.Modified}");
var bi = mapper.Map <BoardViewModel, Board>(bvm);
repo.CreateOrUpdateBoard(bi).Wait();
});
SubscribeAdded(boardsChanges,
bvm =>
{
mon.LogicVerbose($"Box.Boards.Add {bvm.Id}::{bvm.Name}");
var bi = mapper.Map <BoardViewModel, Board>(bvm);
bi = repo.CreateOrUpdateBoard(bi).Result;
bvm.Id = bi.Id;
});
SubscribeRemoved(boardsChanges,
bvm =>
{
mon.LogicVerbose($"Box.Boards.Remove {bvm.Id}::{bvm.Name}");
repo.DeleteBoard(bvm.Id).Wait();
});
boardsChanges.Connect();
////////////////////
// Columns AutoSaver
////////////////////
var columnsChanges = Columns.Connect().Publish();
SubscribeChanged(columnsChanges,
cvm =>
{
mon.LogicVerbose($"Box.Columns.ItemChanged {cvm.Id}::{cvm.Name}::{cvm.Order}");
var ci = mapper.Map <ColumnViewModel, Column>(cvm);
repo.CreateOrUpdateColumn(ci).Wait();
});
SubscribeAdded(columnsChanges,
cvm =>
{
mon.LogicVerbose($"Box.Columns.Add {cvm.Id}::{cvm.Name}::{cvm.Order}");
var ci = mapper.Map <ColumnViewModel, Column>(cvm);
ci = repo.CreateOrUpdateColumn(ci).Result;
cvm.Id = ci.Id;
});
SubscribeRemoved(columnsChanges,
cvm =>
{
mon.LogicVerbose($"Box.Columns.Remove {cvm.Id}::{cvm.Name}::{cvm.Order}");
repo.DeleteColumn(cvm.Id).Wait();
});
columnsChanges.Connect();
/////////////////
// Rows AutoSaver
/////////////////
var rowsChanges = Rows.Connect().Publish();
SubscribeChanged(rowsChanges,
rvm =>
{
mon.LogicVerbose($"Box.Rows.ItemChanged {rvm.Id}::{rvm.Name}::{rvm.Order}");
var row = mapper.Map <RowViewModel, Row>(rvm);
repo.CreateOrUpdateRow(row).Wait();
});
SubscribeAdded(rowsChanges,
rvm =>
{
mon.LogicVerbose($"Box.Rows.Add {rvm.Id}::{rvm.Name}::{rvm.Order}");
var ri = mapper.Map <RowViewModel, Row>(rvm);
ri = repo.CreateOrUpdateRow(ri).Result;
rvm.Id = ri.Id;
});
SubscribeRemoved(rowsChanges,
rvm =>
{
mon.LogicVerbose($"Box.Rows.Remove {rvm.Id}::{rvm.Name}::{rvm.Order}");
repo.DeleteRow(rvm.Id).Wait();
});
rowsChanges.Connect();
//////////////////
// Cards AutoSaver
//////////////////
var cardsChanges = Cards.Connect().Publish();
SubscribeChanged(cardsChanges,
cvm =>
{
mon.LogicVerbose($"Box.Cards.ItemChanged {cvm.Id}::{cvm.Header}");
var iss = mapper.Map <CardViewModel, Card>(cvm);
repo.CreateOrUpdateCard(iss).Wait();
});
SubscribeAdded(cardsChanges,
cvm =>
{
mon.LogicVerbose($"Box.Cards.Add {cvm.Id}::{cvm.Header}");
var ci = mapper.Map <CardViewModel, Card>(cvm);
ci = repo.CreateOrUpdateCard(ci).Result;
cvm.Id = ci.Id;
});
SubscribeRemoved(cardsChanges,
cvm =>
{
mon.LogicVerbose($"Box.Cards.Remove {cvm.Id}::{cvm.Header}");
repo.DeleteCard(cvm.Id).Wait();
});
cardsChanges.Connect();
}
public SaveServiceTests()
{
_saveRepositoryMock = new SaveRepositoryMock();
}
public BoostRequestService(IConfiguration configuration)
{
this._getRepository = RepositoryFactory.BuildAndGetGetRepository <BoostRequest>(RepositoryFactory.Tech.Mongodb, configuration);
this._saveRepository = RepositoryFactory.BuildAndGetSaveRepository <BoostRequest>(RepositoryFactory.Tech.Mongodb, configuration);
}
public void TestInit()
{
context = new RedPandaContext();
_sut = new RedPandaSaveRepository <Client>(context);
context.Database.BeginTransaction();
}
public RegisterUserHandler(IUserRepository userRepository, IEncrypter encrypter, ISaveRepository <User> saveRepository)
{
this.userRepository = userRepository;
this.encrypter = encrypter;
this.saveRepository = saveRepository;
}
public void LogCardChanges(CardViewModel cvm, ISaveRepository repo)
{
List <String> notLogging = new List <string>()
{
"Modified", "Order", "ShowDescription"
};
cvm.Changing.Subscribe(c =>
{
if (notLogging.Contains(c.PropertyName))
{
return;
}
LogEntries.Add(
new LogEntryViewModel()
{
CardId = cvm.Id,
Property = c.PropertyName,
OldValue = cvm.GetType().GetProperty(c.PropertyName).GetValue(cvm, null)?.ToString(),
});
});
cvm.Changed.Subscribe(c =>
{
if (notLogging.Contains(c.PropertyName))
{
return;
}
var Entry = LogEntries.Items.Where(x => { return((x.Property == c.PropertyName) & (x.CardId == cvm.Id)); }).Last();
bool noEntryfound = (Entry == null);
if (noEntryfound) // Should not happen
{
Entry = new LogEntryViewModel()
{
Property = c.PropertyName,
OldValue = "",
};
}
;
Entry.Time = DateTime.Now;
Entry.Topic = "Card Changed";
Entry.ColumnId = cvm.ColumnDeterminant;
Entry.RowId = cvm.RowDeterminant;
Entry.BoardId = cvm.BoardId;
Entry.CardId = cvm.Id;
Entry.Column = Columns.Items.Where(x => { return(x.Id == Entry.ColumnId); }).First().Name;
Entry.Row = Rows.Items.Where(x => { return(x.Id == Entry.RowId); }).First().Name;
Entry.Board = Boards.Items.Where(x => { return(x.Id == Entry.BoardId); }).First().Name;
Entry.NewValue = cvm.GetType().GetProperty(c.PropertyName).GetValue(cvm, null)?.ToString();
Entry.Note = "Card #" + cvm.Id.ToString() + ": " + cvm.Header + "\r\n" +
c.PropertyName + ": " + Entry.OldValue + " -> " + Entry.NewValue;
if (Entry.Property == "ColumnDeterminant")
{
Entry.Note = "Card #" + cvm.Id.ToString() + ": " + cvm.Header + "\r\n" +
"Column: " + Columns.Items.Where(x => { return(x.Id.ToString() == Entry.OldValue); }).First().Name + " -> " + Entry.Column;
}
if (Entry.Property == "RowDeterminant")
{
Entry.Note = "Card #" + cvm.Id.ToString() + ": " + cvm.Header + "\r\n" +
"Row: " + Rows.Items.Where(x => { return(x.Id.ToString() == Entry.OldValue); }).First().Name + " -> " + Entry.Row;
}
if (noEntryfound)
{
LogEntries.Add(Entry);
}
});
}
public Test(ISaveRepository userRepository)
{
_userRepository = userRepository;
}
public void InitializeLogger(ISaveRepository repo)
{
/////////////////////////////////////////
/// Mirror LogEntries to repo
/////////////////////////////////////////
LogEntries
.Connect()
.WhereReasonsAre(ListChangeReason.Add)
.Subscribe(ch =>
{
foreach (Change <LogEntryViewModel> c in ch)
{
LogEntryViewModel Entry = c.Item.Current;
if (Entry != null)
{
Repo_CreateOrUpdateLogEntry(repo, Entry);
Entry.PropertyChanged += Entry_PropertyChanged;
}
if (c.Range != null)
{
foreach (LogEntryViewModel REntry in c.Range.ToList())
{
Repo_CreateOrUpdateLogEntry(repo, REntry);
REntry.PropertyChanged += Entry_PropertyChanged;
}
}
}
});
LogEntries
.Connect()
.WhereReasonsAre(ListChangeReason.AddRange)
.Subscribe(ch =>
{
foreach (Change <LogEntryViewModel> c in ch)
{
LogEntryViewModel Entry = c.Item.Current;
if (Entry != null)
{
Entry.PropertyChanged += Entry_PropertyChanged;
}
if (c.Range != null)
{
foreach (LogEntryViewModel REntry in c.Range.ToList())
{
REntry.PropertyChanged += Entry_PropertyChanged;
}
}
}
});
LogEntries
.Connect()
.WhereReasonsAre(ListChangeReason.Remove)
.Subscribe(ch =>
{
foreach (Change <LogEntryViewModel> c in ch)
{
LogEntryViewModel Entry = c.Item.Current;
if (Entry != null)
{
Repo_CreateOrUpdateLogEntry(repo, Entry);
repo.RemoveLogEntry(Entry.Id);
}
if (c.Range != null)
{
foreach (LogEntryViewModel REntry in c.Range.ToList())
{
repo.RemoveLogEntry(REntry.Id);
}
}
}
});
/////////////////////////////////////////
/// Log Cards
/////////////////////////////////////////
var CardChanges = Cards.Connect();
CardChanges.WhereReasonsAre(ListChangeReason.Add)
.Subscribe(c =>
{
foreach (Change <CardViewModel> ccvm in c)
{
LogCardChanges(ccvm.Item.Current, repo);
LogEntryViewModel Entry = new LogEntryViewModel()
{
Time = DateTime.Now,
ColumnId = ccvm.Item.Current.ColumnDeterminant,
RowId = ccvm.Item.Current.RowDeterminant,
CardId = ccvm.Item.Current.Id,
BoardId = ccvm.Item.Current.BoardId,
Topic = ccvm.Reason.ToString(),
Note = ccvm.Item.Current.Header
};
Entry.Note = "Add Card #" + ccvm.Item.Current.Id.ToString() + ": " + ccvm.Item.Current.Header + "\r\n";
Entry.Column = Columns.Items.Where(x => { return(x.Id == Entry.ColumnId); }).First().Name;
Entry.Row = Rows.Items.Where(x => { return(x.Id == Entry.RowId); }).First().Name;
Entry.Board = Boards.Items.Where(x => { return(x.Id == Entry.BoardId); }).First().Name;
LogEntries.Add(Entry);
}
;
});
CardChanges.WhereReasonsAre(ListChangeReason.AddRange)
.Subscribe(c =>
{
foreach (Change <CardViewModel> ccvm in c)
{
foreach (CardViewModel cvm in ccvm.Range.ToList())
{
LogCardChanges(cvm, repo); // Add Observer
// Don't generate Log Entry, since AddRange is issued only at loading of Box.
}
}
});
CardChanges.WhereReasonsAre(ListChangeReason.Remove)
.Subscribe(c =>
{
foreach (Change <CardViewModel> ccvm in c)
{
LogEntryViewModel Entry = new LogEntryViewModel()
{
Time = DateTime.Now,
ColumnId = ccvm.Item.Current.ColumnDeterminant,
RowId = ccvm.Item.Current.RowDeterminant,
BoardId = ccvm.Item.Current.BoardId,
Topic = ccvm.Reason.ToString(),
Note = ccvm.Item.Current.Header
};
Entry.Note = "Remove Card #" + ccvm.Item.Current.Id.ToString() + ": " + ccvm.Item.Current.Header + "\r\n";
Entry.Column = Columns.Items.Where(x => { return(x.Id == Entry.ColumnId); }).First().Name;
Entry.Row = Rows.Items.Where(x => { return(x.Id == Entry.RowId); }).First().Name;
Entry.Board = Boards.Items.Where(x => { return(x.Id == Entry.BoardId); }).First().Name;
LogEntries.Add(Entry);
}
});
CardChanges.WhereReasonsAre(ListChangeReason.RemoveRange)
.Subscribe(c =>
{
foreach (Change <CardViewModel> ccvm in c)
{
foreach (CardViewModel cvm in ccvm.Range.ToList())
{
LogEntryViewModel Entry = new LogEntryViewModel()
{
Time = DateTime.Now,
ColumnId = cvm.ColumnDeterminant,
RowId = cvm.RowDeterminant,
BoardId = cvm.BoardId,
Topic = ccvm.Reason.ToString()
};
Entry.Note = "Remove Card #" + ccvm.Item.Current.Id.ToString() + ": " + ccvm.Item.Current.Header + "\r\n";
Entry.Column = Columns.Items.Where(x => { return(x.Id == Entry.ColumnId); }).First().Name;
Entry.Row = Rows.Items.Where(x => { return(x.Id == Entry.RowId); }).First().Name;
Entry.Board = Boards.Items.Where(x => { return(x.Id == Entry.BoardId); }).First().Name;
LogEntries.Add(Entry);
}
}
});
}
public SaveService(ISaveRepository repository)
{
_repository = repository;
}
