private void UpdateProcessStatus(object op, Task task)
{
var op2 = (OperationInfo)op;
op2.FinishedOn = DateTime.UtcNow;
switch (task.Status)
{
case TaskStatus.RanToCompletion:
op2.Status = OperationStatus.Completed;
op2.StatusInfo = string.Format("Scraping done. Torrents saved: {0}", op2.ExtraData["updated"]);
break;
case TaskStatus.Faulted:
op2.Status = OperationStatus.Faulted;
op2.Error = task.Exception != null?task.Exception.ToString() : "Unexpected error";
break;
case TaskStatus.Canceled:
op2.Status = OperationStatus.Cancelled;
break;
}
var opsRepo = new OperationsRepository();
this.UpdateOperationInfo(op2, opsRepo, true);
}
public async System.Threading.Tasks.Task <OperationResult <Operation> > CreateOperation(Operation operation)
{
return(await System.Threading.Tasks.Task.Factory.StartNew <OperationResult <Operation> >(() =>
{
OperationResult <Operation> result = new OperationResult <Operation>();
try
{
if (IsInCompany())
{
operation.CompanyId = CurrentUser.CompanyId.Value;
Operation newOperation = OperationsRepository.CreateOrUpdate(operation);
if (newOperation.Id > 0)
{
result.SingleResult = newOperation;
result.Result = true;
}
}
}
catch (Exception ex)
{
LoggingService.Log(ex);
}
return result;
}));
}
private bool _disposedValue; // To detect redundant calls
public GererMesCompteTestContext(PostScenarioCleaner cleaner)
{
Cleaner = cleaner;
GmcClient = new GererMesComptesClient(h => new LoggingHandler(h));
GmcAccounts = new AccountInfoRepository(GmcClient);
GmcOperations = new OperationsRepository(GmcClient);
}
public async System.Threading.Tasks.Task <OperationResult <Operation> > GetOperations(int pageSize, int pageNumber, bool descending)
{
return(await System.Threading.Tasks.Task.Factory.StartNew <OperationResult <Operation> >(() =>
{
OperationResult <Operation> result = new OperationResult <Operation>();
try
{
if (IsInCompany())
{
result.Count = OperationsRepository.Count("CompanyId = @CompanyId", new { CompanyId = CurrentUser.CompanyId.Value });
if (result.Count > 0)
{
result.MultipleResult = OperationsRepository.Search("CompanyId = @CompanyId",
new { PageSize = pageSize, PageNumber = pageNumber, CompanyId = CurrentUser.CompanyId.Value }, descending);
}
result.Result = true;
}
}
catch (Exception ex)
{
LoggingService.Log(ex);
}
return result;
}));
}
public void Setup()
{
this.testDir = "TestFiles";
Directory.CreateDirectory(this.testDir);
var formatter = new BinaryFormatter();
this.operationDataAccess = new FormatterDataAccess <Operation>(formatter);
this.operationIndexDataAccess =
new FormatterDataAccess <OperationsIndex>(formatter);
this.configurationMock = new Mock <IConfiguration>();
var section = EConfigSection.SAROMSettings.ToString();
this.configurationMock
.Setup(c => c.GetSection(section)[EConfigKey.StoragePath.ToString()])
.Returns(this.testDir);
this.configurationMock
.Setup(c => c.GetSection(section)[EConfigKey.FileExtension.ToString()])
.Returns(".dat");
this.configurationMock
.Setup(c => c.GetSection(section)[EConfigKey.IndexFile.ToString()])
.Returns(Path.Combine(this.testDir, "TestOperationIndex.dat"));
this.repository = new OperationsRepository(
operationDataAccess,
operationIndexDataAccess,
configurationMock.Object);
}
public MainViewModel()
{
// Initialize Data layer
var fs = new MyAccounts.Business.IO.WindowsFileSystem();
var workingCopy = new WorkingCopy(fs, Properties.Settings.Default.WorkingFolder);
var accountsRepository = new AccountsRepository(workingCopy);
var accountCommandRepository = new AccountCommandRepository(workingCopy);
var placesRepository = new PlacesRepository();
var placeProvider = PlaceProvider.Load(placesRepository);
var placeInfoResolver = new PlaceInfoResolver(placeProvider);
var operationPatternTransformer = new UnifiedAccountOperationPatternTransformer(placeInfoResolver);
var operationsRepository = new OperationsRepository(workingCopy, new CsvAccountOperationManager(), operationPatternTransformer);
// Initialize Managers
var operationsManager = new OperationsManager(App.CacheManager, operationsRepository);
var accountsManager = new AccountsManager(App.CacheManager, accountsRepository);
var importManager = new ImportManager(App.CacheManager, accountCommandRepository, operationsManager);
// Initialize View Models
BusyIndicator = new BusyIndicatorViewModel();
ImportsManagerViewModel = new ImportsManagerViewModel(BusyIndicator, fs, importManager);
OperationsManagerViewModel = new OperationsManagerViewModel(BusyIndicator, operationsManager, importManager);
AccountsManagerViewModel = new AccountsManagerViewModel(BusyIndicator, accountsManager, operationsManager, importManager);
DashboardViewModel = new DashboardViewModel(BusyIndicator);
GmcManager = new GmcManager(BusyIndicator, App.CacheManager, operationsManager);
_settingsManager = new SettingsManager(App.CacheManager);
MessengerInstance.Register <Properties.Settings>(this, OnSettingsUpdated);
_asyncMessageReceiver = new AsyncMessageReceiver(MessengerInstance);
_asyncMessageReceiver.RegisterAsync <AccountDataInvalidated>(this, data => Refresh());
if (!IsInDesignMode)
{
LoadCommand = new AsyncCommand(Load);
RefreshCommand = new AsyncCommand(Refresh);
}
else
{
AccountsManagerViewModel.Accounts.Add(
new AccountViewModel
{
Name = "Blaise CC",
Status =
{
Operations = 7,
Balance = 2541.7345M,
LastImportedOperation = "2012-0001"
}
});
AccountsManagerViewModel.CurrentAccount = AccountsManagerViewModel.Accounts.First();
}
}
private void UpdateOperationInfo(OperationInfo op, OperationsRepository opsRepo, bool forceUpdate = false)
{
if (this.updateProgressInDatabase || forceUpdate)
{
var o = opsRepo.Find(op.Id);
o.Info = op;
o.LastUpdatedOn = DateTime.UtcNow;
opsRepo.Save(o);
}
}
public async void Counts_Operations()
{
//Act
var result = await OperationsRepository.Object.Count();
var expected = Context.Operations.Count();
//Assert
result.Should()
.Equals(expected);
OperationsRepository.Verify();
DbContextFactory.Destroy(Context);
}
public ClassificationStepsContext()
{
CsvAccountOperationManager = new CsvAccountOperationManager();
Transformer = new UnifiedAccountOperationPatternTransformer(
new PlaceInfoResolver(PlaceProvider.Load(new PlacesRepository())));
WorkingCopy = new WorkingCopy(new FileSystemAdapter(new MockFileSystem()), @"c:\WorkingCopy");
AccountCommandRepository = new AccountCommandRepository(WorkingCopy);
var operationsRepository = new OperationsRepository(WorkingCopy, CsvAccountOperationManager, Transformer);
var cacheManager = new CacheManager(new NoCache());
OperationsManager = new OperationsManager(cacheManager, operationsRepository);
ImportManager = new ImportManager(cacheManager, AccountCommandRepository, OperationsManager);
AccountId = Guid.NewGuid();
}
public async void Deletes_Operation_Successfully()
{
//Arrange
var user = Context.Users.First();
var operation = Context.Operations.First();
OperationsRepository.Setup(x => x.Delete(It.IsAny <DateTime>(), user.Id)).ReturnsAsync(true).Verifiable();
//Act
var result = await OperationsRepository.Object.Delete(operation.Date, user.Id);
//Assert
result.Should()
.BeTrue();
OperationsRepository.Verify();
DbContextFactory.Destroy(Context);
}
public async void Starts_Sale_Process()
{
//Arrange
var contact = new Contact
{
Id = Guid.Empty,
Name = "Contact",
Type = "Client",
Company = "Contact co.",
PhoneNumber = "000",
Email = "Contact@",
Notes = "ABC",
Status = "Inactive",
Source = "Social Media"
};
var user = new User
{
Id = "1U",
UserName = "******",
DisplayName = "TestUser ",
Email = "@test",
Level = "mid"
};
UserAccessor.Setup(x => x.GetLoggedUser()).ReturnsAsync(user).Verifiable();
OperationsRepository.Setup(x => x.Add(It.IsAny <Operation>(), user)).ReturnsAsync(true).Verifiable();
Mediator.Setup(x => x.Send(It.IsAny <StartSaleProcessCommand>(), new CancellationToken()))
.ReturnsAsync(Unit.Value);
//Act
var addContactCommand = new StartSaleProcessCommand(contact);
var handler = new StartSaleProcessCommandHandler(Context, UserAccessor.Object, OperationsRepository.Object);
var result = await handler.Handle(addContactCommand, new CancellationToken());
//Assert
result.Should()
.BeOfType <Unit>()
.Equals(Unit.Value);
UserAccessor.Verify();
OperationsRepository.Verify();
DbContextFactory.Destroy(Context);
}
public async System.Threading.Tasks.Task <OperationResult <Operation> > UpdateOperation(Operation operation)
{
return(await System.Threading.Tasks.Task.Factory.StartNew <OperationResult <Operation> >(() =>
{
OperationResult <Operation> result = new OperationResult <Operation>();
try
{
if (IsInCompany(operation.CompanyId))
{
result.Result = OperationsRepository.Update(operation);
}
}
catch (Exception ex)
{
LoggingService.Log(ex);
}
return result;
}));
}
public async void Adds_New_Operation_Successfully()
{
//Arrange
var user = Context.Users.First();
var operation = new Operation
{
Opportunity = true,
Date = DateTime.Now,
};
OperationsRepository.Setup(x => x.Add(It.IsAny <Operation>(), user)).ReturnsAsync(true).Verifiable();
//Act
var result = await OperationsRepository.Object.Add(operation, user);
//Assert
result.Should()
.BeTrue();
OperationsRepository.Verify();
DbContextFactory.Destroy(Context);
}
private void UpdateMovies(MoviesRepository moviesRepo, OperationInfo op, OperationsRepository opsRepo)
{
op.StatusInfo = "Scraping movies";
this.UpdateOperationInfo(op, opsRepo);
var scraper = new ImdbScraper();
var moviesScraped = 0;
var moviesToUpdate = moviesRepo.GetMoviesToUpdate();
foreach (var movie in moviesToUpdate)
{
scraper.UpdateMovieDetails(movie);
moviesRepo.Save(movie);
moviesScraped++;
op.ExtraData["moviesScraped"] = moviesScraped.ToString(CultureInfo.InvariantCulture);
this.UpdateOperationInfo(op, opsRepo);
op.CancellationTokenSource.Token.ThrowIfCancellationRequested();
}
}
public async void Deletes_Order_Successfully()
{
//Arrange
var order = Context.Orders.First();
OperationsRepository.Setup(x => x.Delete(It.IsAny<DateTime>(), order.UserId)).ReturnsAsync(true).Verifiable();
Mediator.Setup(x => x.Send(It.IsAny<DeleteOrderCommand>(), new CancellationToken()))
.ReturnsAsync(Unit.Value);
//Act
var deleteOrderCommand = new DeleteOrderCommand(order.Client, order);
var handler = new DeleteOrderCommandHandler(Context, OperationsRepository.Object);
var result = await handler.Handle(deleteOrderCommand, new CancellationToken());
//Assert
result.Should()
.BeOfType<Unit>()
.Equals(Unit.Value);
OperationsRepository.Verify();
DbContextFactory.Destroy(Context);
}
public static void Initialize(TestContext testContext)
{
IDbContext context = new DbContext();
IRepository <Certificate, int> certificatesRepository = new CertificateRepository(context);
IRepository <Company, int> companiesRepository = new CompaniesRepository(context);
IRepository <Equipment, int> equipmentsRepository = new EquipmentRepository(context);
IRepository <Event, int> eventsRepository = new EventsRepository(context);
IRepository <Game, int> gamesRepository = new GamesRepository(context);
IRepository <GameType, int> gameTypesRepository = new GameTypesRepository(context);
IRepository <News, int> newsRepository = new NewsRepository(context);
IRepository <Operation, int> operationsRepository = new OperationsRepository(context);
IRepository <Playground, int> playgroundsRepository = new PlaygroundsRepository(context);
IRepository <Task, int> tasksRepository = new TasksRepository(context);
IRepository <EquipmentOrder, int> equipmentOrdersRepository = new EquipmentOrdersRepository(context);
UserStore <IdentityUser> userStore = new UserStore <IdentityUser>(context);
RoleStore <IdentityRole> roleStore = new RoleStore <IdentityRole>(context);
_loggingService = new TestLoggingService();
_manager = new PaintballManager(context,
certificatesRepository,
companiesRepository,
equipmentsRepository,
eventsRepository,
gamesRepository,
gameTypesRepository,
newsRepository,
operationsRepository,
playgroundsRepository,
equipmentOrdersRepository,
tasksRepository,
userStore,
roleStore,
_loggingService
);
_firstUser = _manager.UserStore.Users.FirstOrDefault();
}
public void ProcessTorrentNews(int maxPages, string age, OperationInfo operation)
{
Task.Factory.StartNew(
(op) =>
{
var op2 = (OperationInfo)op;
op2.CancellationTokenSource.Token.ThrowIfCancellationRequested();
op2.Status = OperationStatus.Running;
op2.StartedOn = DateTime.UtcNow;
op2.ExtraData.Add("removed", "N/A");
op2.ExtraData.Add("updated", "N/A");
op2.ExtraData.Add("scraped", "N/A");
op2.ExtraData.Add("moviesScraped", "N/A");
op2.ExtraData.Add("unwantedMoviesRemoved", "N/A");
op2.ExtraData.Add("scoresUpdated", "N/A");
var torrentsRepo = new TorrentsRepository();
var moviesRepo = new MoviesRepository();
var opsRepo = new OperationsRepository();
var o = new Operation {
Id = op2.Id, Info = op2, AddedOn = DateTime.UtcNow
};
opsRepo.Save(o);
this.RemoveOldTorrents(op2, torrentsRepo, opsRepo);
this.UpdateTorrents(maxPages, age, torrentsRepo, op2, moviesRepo, opsRepo);
this.UpdateMovies(moviesRepo, op2, opsRepo);
this.RemoveUnwantedTorrents(moviesRepo, torrentsRepo, op2, opsRepo);
this.UpdateAwards(moviesRepo, torrentsRepo, op2, opsRepo);
},
operation,
operation.CancellationTokenSource.Token)
.ContinueWith(
(task, op) => this.UpdateProcessStatus(op, task),
operation);
}
public void Setup()
{
this.configurationMock = new Mock <IConfiguration>();
var section = EConfigSection.SAROMSettings.ToString();
this.configurationMock
.Setup(c => c.GetSection(section)[EConfigKey.StoragePath.ToString()])
.Returns("./");
this.configurationMock
.Setup(c => c.GetSection(section)[EConfigKey.FileExtension.ToString()])
.Returns(".sod");
this.configurationMock
.Setup(c => c.GetSection(section)[EConfigKey.IndexFile.ToString()])
.Returns("TestOperationIndex.dat");
this.dataAccessMock = new Mock <IFileDataAccess <Operation> >();
this.indexDataAccessMock = new Mock <IFileDataAccess <OperationsIndex> >();
this.repository = new OperationsRepository(
this.dataAccessMock.Object,
this.indexDataAccessMock.Object,
configurationMock.Object);
}
public async System.Threading.Tasks.Task <OperationResult <Operation> > DeleteOperation(int id)
{
return(await System.Threading.Tasks.Task.Factory.StartNew <OperationResult <Operation> >(() =>
{
OperationResult <Operation> result = new OperationResult <Operation>();
try
{
Operation operation = OperationsRepository.Read(id);
if (operation != null)
{
if (IsInCompany(operation.CompanyId))
{
result.Result = OperationsRepository.Delete(id);
}
}
}
catch (Exception ex)
{
LoggingService.Log(ex);
}
return result;
}));
}
public async void Adds_New_Order_Successfully()
{
//Arrange
var contact = Context.Contacts.First();
var user = Context.Users.First();
UserAccessor.Setup(x => x.GetLoggedUser()).ReturnsAsync(user);
OperationsRepository.Setup(x => x.Add(It.IsAny <Operation>(), user)).ReturnsAsync(true).Verifiable();
Mediator.Setup(x => x.Send(It.IsAny <AddOrderCommand>(), new CancellationToken()))
.ReturnsAsync(Unit.Value);
//Act
var addOrderCommand = new AddOrderCommand(contact, true, "test", 10, 100, "");
var handler = new AddOrderCommandHandler(Context, UserAccessor.Object, OperationsRepository.Object);
var result = await handler.Handle(addOrderCommand, new CancellationToken());
//Assert
result.Should()
.BeOfType <Unit>()
.Equals(Unit.Value);
DbContextFactory.Destroy(Context);
}
public async void Closes_Order_Successfully()
{
//Arrange
var order = Context.Orders.First();
var user = Context.Users.FirstOrDefault(x => x.Id == order.UserId);
UserAccessor.Setup(x => x.GetLoggedUser()).ReturnsAsync(user).Verifiable();
OperationsRepository.Setup(x => x.Add(It.IsAny <Operation>(), It.IsAny <User>())).ReturnsAsync(true).Verifiable();
Mediator.Setup(x => x.Send(It.IsAny <CloseOrderCommand>(), new CancellationToken()))
.ReturnsAsync(Unit.Value);
//Act
var closeOrderCommand = new CloseOrderCommand(order);
var handler = new CloseOrderCommandHandler(Context, UserAccessor.Object, OperationsRepository.Object);
var result = await handler.Handle(closeOrderCommand, new CancellationToken());
//Assert
result.Should()
.BeOfType <Unit>()
.Equals(Unit.Value);
OperationsRepository.Verify();
DbContextFactory.Destroy(Context);
}
public HttpResponseMessage GetOperationsLog(string secret)
{
var opsRepo = new OperationsRepository();
return(this.Request.CreateResponse(HttpStatusCode.Accepted, opsRepo.FindAll().OrderByDescending(item => item.AddedOn)));
}
public IMT_Operations(PDMHelpers.ILoggerManager loggerManager, OperationsRepository repository) : base(repository.Connection)
{
trace = loggerManager.CreateTracer(GetType());
this.repository = repository;
this.repository.Trace = trace;
}
private void UpdateAwards(MoviesRepository moviesRepo, TorrentsRepository torrentsRepo, OperationInfo op, OperationsRepository opsRepo)
{
op.StatusInfo = "Updating awards";
this.UpdateOperationInfo(op, opsRepo);
//Logic for updating Latest
torrentsRepo.UpdateLatestToFalse();
var moviesCache = new Dictionary <string, Movie>();
var torrents = torrentsRepo.GetAllSortedByImdbIdAndAddedOn();
var i = 0;
string previousImdbId = null;
int previousId = 0;
Torrent current = null;
foreach (var t in torrents)
{
current = t;
//Logic for updating Latest
if (previousImdbId != null)
{
if (previousImdbId != current.ImdbId)
{
var previous = torrentsRepo.Find(previousId);
previous.Latest = true;
torrentsRepo.Save(previous);
}
}
previousImdbId = current.ImdbId;
previousId = current.Id;
//
var isDirty = false;
Movie movie = null;
if (current.HasImdbId())
{
if (!moviesCache.TryGetValue(current.ImdbId, out movie))
{
movie = moviesRepo.Find(current.ImdbId);
moviesCache.Add(current.ImdbId, movie);
}
}
if (movie != null)
{
current.ImdbAward = this.GetValue(current.ImdbAward, movie.ImdbVotes >= 1000 && movie.ImdbRating >= 70, ref isDirty);
current.MetacriticAward = this.GetValue(current.MetacriticAward, movie.McMetascore >= 70, ref isDirty);
}
else
{
current.ImdbAward = this.GetValue(current.ImdbAward, false, ref isDirty);
current.MetacriticAward = this.GetValue(current.MetacriticAward, false, ref isDirty);
}
current.SuperPopularityAward = this.GetValue(current.SuperPopularityAward, current.Seed >= 3000 || current.CommentsCount >= 100, ref isDirty);
current.PopularityAward = this.GetValue(current.PopularityAward, !current.SuperPopularityAward && (current.Seed >= 1000 || current.CommentsCount >= 20), ref isDirty);
current.Score = this.GetValue(current.Score, this.CalcScore(current), ref isDirty);
if (isDirty)
{
torrentsRepo.Save(current);
}
i++;
op.ExtraData["scoresUpdated"] = i.ToString(CultureInfo.InvariantCulture);
this.UpdateOperationInfo(op, opsRepo);
op.CancellationTokenSource.Token.ThrowIfCancellationRequested();
}
//Logic for updating Latest
if (current != null)
{
current.Latest = true;
torrentsRepo.Save(current);
}
}
private void RemoveUnwantedTorrents(MoviesRepository moviesRepo, TorrentsRepository torrentsRepo, OperationInfo op, OperationsRepository opsRepo)
{
op.StatusInfo = "Removing unwanted torrents";
this.UpdateOperationInfo(op, opsRepo);
var i = 0;
var moviesToRemove = moviesRepo.GetUnwantedMovies();
foreach (var m in moviesToRemove)
{
torrentsRepo.RemoveByImdbId(m.Id);
moviesRepo.Remove(m.Id);
i++;
op.ExtraData["unwantedMoviesRemoved"] = i.ToString(CultureInfo.InvariantCulture);
this.UpdateOperationInfo(op, opsRepo);
op.CancellationTokenSource.Token.ThrowIfCancellationRequested();
}
}
private void RemoveOldTorrents(OperationInfo op, TorrentsRepository torrentsRepo, OperationsRepository opsRepo)
{
op.StatusInfo = "Removing old torrents";
this.UpdateOperationInfo(op, opsRepo);
var torrentsRemoved = torrentsRepo.RemoveOldTorrents();
op.ExtraData["removed"] = torrentsRemoved.ToString(CultureInfo.InvariantCulture);
this.UpdateOperationInfo(op, opsRepo);
}
private void UpdateTorrents(int maxPages, string age, TorrentsRepository torrentsRepo, OperationInfo op, MoviesRepository moviesRepo, OperationsRepository opsRepo)
{
var counter = 0;
var scraper = new KassScraper(torrentsRepo, maxPages, age);
var torrents = scraper.GetLatestTorrents(op, o => this.UpdateOperationInfo(o, opsRepo));
foreach (var t in torrents)
{
torrentsRepo.Save(t);
if (t.ImdbId != "NA")
{
var movie = moviesRepo.Find(t.ImdbId);
if (movie == null)
{
var newMovie = new Movie {
Id = t.ImdbId
};
if (!string.IsNullOrEmpty(t.Poster))
{
newMovie.Poster = t.Poster;
}
moviesRepo.Save(newMovie);
}
else
{
if (!string.IsNullOrEmpty(t.Poster) && !t.Poster.Equals(movie.Poster))
{
movie.Poster = t.Poster;
moviesRepo.Save(movie);
}
}
}
counter++;
op.ExtraData["updated"] = counter.ToString(CultureInfo.InvariantCulture);
this.UpdateOperationInfo(op, opsRepo);
op.CancellationTokenSource.Token.ThrowIfCancellationRequested();
}
}
