/// <summary>
/// Preencho o repositório com as HQs novas
/// </summary>
public void Dump(IComicRepository comicRepository, IAuthorRepository authorRepository,
IGenreRepository genreRepository, IPublisherRepository publisherRepository,
ILogRepository logRepository)
{
//Se já processei nesse período, retorno
DateTime lastSyncDate = logRepository.GetLastComicListUpdate();
if (lastSyncDate.AddHours(24) > DateTime.Now) return;
//Espero terminar de processar
while (_working) Thread.Sleep(10);
//Busco todas as HQs do banco
IList<Comic> repoList = comicRepository.Read();
//Comparo o que mudou
foreach (ComicVisitor cacheComic in _cache)
{
if (repoList.Any(c => c.ComicName.ToUpper().Equals(cacheComic.ComicName.ToUpper()))) continue;
//Se tem uma HQ nova, adiciono
Comic dbComic = ComicVisitor.ToComic(cacheComic);
comicRepository.Add(dbComic);
cacheComic.ComicId = dbComic.ComicId;
}
comicRepository.Save();
logRepository.SetLastComicListUpdate(DateTime.Now);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="publisherRepository">Instance that inherits from ICompanyRepository</param>
public PublisherService(IPublisherRepository publisherRepository, ISupportRepository supportRepository)
{
if (publisherRepository == null ||supportRepository == null)
throw new ArgumentNullException();
this.publisherRepository = publisherRepository;
this.supportRepository = supportRepository;
}
public ComicController()
{
DbContext sharedContext = new Data.ComiczillaDb();
_repository = new ComicRepository(sharedContext);
_authorRepository = new AuthorRepository(sharedContext);
_genreRepository = new GenreRepository(sharedContext);
_publisherRepository = new PublisherRepository(sharedContext);
_chapterRepository = new ChapterRepository(sharedContext);
_logRepository = new LogRepository(sharedContext);
}
public ComicController(IComicRepository repository, IAuthorRepository authorRepository,
IGenreRepository genreRepository, IPublisherRepository publisherRepository,
IChapterRepository chapterRepository, ILogRepository logRepository)
{
_repository = repository;
_authorRepository = authorRepository;
_genreRepository = genreRepository;
_publisherRepository = publisherRepository;
_chapterRepository = chapterRepository;
_logRepository = logRepository;
}
public JournalsImport(IJournalRepository journalRepository, ILanguageRepository languageRepository, ICountryRepository countryRepository, ISubjectRepository subjectRepository, IPublisherRepository publisherRepository, GeneralImportSettings importSettings)
{
Requires.NotNull(journalRepository, "journalRepository");
Requires.NotNull(languageRepository, "languageRepository");
Requires.NotNull(countryRepository, "countryRepository");
Requires.NotNull(subjectRepository, "subjectRepository");
Requires.NotNull(publisherRepository, "publisherRepository");
Requires.NotNull(importSettings, "importSettings");
this.journalRepository = journalRepository;
this.languageRepository = languageRepository;
this.countryRepository = countryRepository;
this.subjectRepository = subjectRepository;
this.publisherRepository = publisherRepository;
this.importSettings = importSettings;
}
public PublisherService(IPublisherRepository repository, IUnitOfWork unitOfWork)
{
_repository = repository;
_unitOfWork = unitOfWork;
}
public IntegrationServiceApplication(IParserApplication parserApplication, IBookRepository bookRepository, IAuthorRepository authorRepository, IPublisherRepository publisherRepository, IGenreRepository genreRepository, ISeriesRepository seriesRepository, IShelfRepository shelfRepository, IRackRepository rackRepository, ILogger logger, IUserRepository userRepository, IImporter importer, IFileReciever fileReciever)
{
_parserApplication = parserApplication;
_bookRepository = bookRepository;
_authorRepository = authorRepository;
_publisherRepository = publisherRepository;
_genreRepository = genreRepository;
_seriesRepository = seriesRepository;
_shelfRepository = shelfRepository;
_rackRepository = rackRepository;
_logger = logger;
_userRepository = userRepository;
_importer = importer;
_fileReciever = fileReciever;
}
public PublisherController(IPublisherRepository r)
{
repo = r;
}
public ValuesController(IMediator mediator, IAuthorRepository authorRepository, IPublisherRepository publisherRepository)
{
_mediator = mediator;
_authorRepository = authorRepository;
_publisherRepository = publisherRepository;
}
public HomeController(ILogger <HomeController> logger, IBookRepository bookRepository, IAuthorRepository authorRepository, UnitOfWork unitOfWork, IPublisherRepository publisherRepository)
{
_bookRepository = bookRepository;
_authorRepository = authorRepository;
UnitOfWork = unitOfWork;
_publisherRepository = publisherRepository;
_logger = logger;
}
// GET: Publisher
public PublisherController()
{
this._publisherRepository = new PublisherRepository(new PublisherContext());
}
public JournalsImport(IJournalRepository journalRepository, ILanguageRepository languageRepository, ICountryRepository countryRepository, ISubjectRepository subjectRepository, IPublisherRepository publisherRepository, GeneralImportSettings importSettings)
{
Requires.NotNull(journalRepository, nameof(journalRepository));
Requires.NotNull(languageRepository, nameof(languageRepository));
Requires.NotNull(countryRepository, nameof(countryRepository));
Requires.NotNull(subjectRepository, nameof(subjectRepository));
Requires.NotNull(publisherRepository, nameof(publisherRepository));
Requires.NotNull(importSettings, nameof(importSettings));
this.journalRepository = journalRepository;
this.languageRepository = languageRepository;
this.countryRepository = countryRepository;
this.subjectRepository = subjectRepository;
this.publisherRepository = publisherRepository;
this.importSettings = importSettings;
}
public PublisherControllerTests()
{
_publisherRepository = new PublisherRepository(GetContext());
}
public PublisherService(ILogger logger, IPublisherRepository repo) : base(logger)
{
_repo = repo;
}
public PublisherDomain()
{
_publisherRepository = new PublisherRepository();
}
public PublisherBusiness(IPublisherRepository publisherRepository)
{
_publisherRepository = publisherRepository;
}
public PublisherService(IPublisherRepository repository)
{
this._repository = repository;
}
public DefaultPublisherService(IPublisherRepository publisherRepository)
{
this._publisherRepository = publisherRepository;
}
public ApplicationService(IApplicationRepository ApplicationRepository, INotificationService notificationService, IPublisherRepository publisherRepository, IDatasetRepository datasetRepository, IUnitOfWork unitOfWork, ICoordinationRepository CoordinationRepository)
{
_applicationRepository = ApplicationRepository;
_coordinationRepository = CoordinationRepository;
_publisherRepository = publisherRepository;
_datasetRepository = datasetRepository;
_notificationService = notificationService;
_unitOfWork = unitOfWork;
}
public PublisherService(IPublisherRepository repositorio,
IApplicationUnitOfWork uow)
: base(uow)
{
_repository = repositorio;
}
public BookController(IBookRepository bookrepository, IWriterRepository writerrepository, IBookWriterRepository bookwriterrepository, ILibraryRepository libraryrepository, IBookLibraryRepository booklibraryrepository, IPublisherRepository publisherrepository, IBookPublisherRepository bookpublisherrepository)
{
IBookRepository = bookrepository;
IWriterRepository = writerrepository;
IBookWriterRepository = bookwriterrepository;
ILibraryRepository = libraryrepository;
IBookLibraryRepository = booklibraryrepository;
}
public PublisherController(IPublisherRepository publisherRepository)
{
_publisherRepository = publisherRepository ?? throw new ArgumentNullException(nameof(publisherRepository));
}
/// <summary>
/// Initializes a new instance of the <see cref="PublishersController"/> class.
/// </summary>
/// <param name="publisherRepository">The publisher repository.</param>
public PublishersController(IPublisherRepository publisherRepository)
{
this._publisherRepository = publisherRepository;
}
public PublisherService(IPublisherRepository publisherRepository, IUnityOfWork unityOfWork)
{
_publisherRepository = publisherRepository;
_unityOfWork = unityOfWork;
}
public AdminPublisherController(IPublisherRepository publisherRepository)
{
_publisherRepository = publisherRepository;
}
/// <summary>
/// Preencho a HQ com a id passada
/// </summary>
public async void Dump(IComicRepository comicRepository, IAuthorRepository authorRepository,
IGenreRepository genreRepository, IPublisherRepository publisherRepository,
IChapterRepository chapterRepository, ILogRepository logRepository, int id)
{
//Se já processei nesse período, retorno
DateTime lastSyncDate = logRepository.GetLastComicListUpdate();
if (lastSyncDate.AddHours(24) > DateTime.Now) return;
//Espero terminar de processar
while (_working) Thread.Sleep(10);
//Busco a HQ do repositório
Comic dbComic = comicRepository.Get(id);
//Se não tem no repositório, retorno
if (dbComic == null) return;
//Busco a HQ do cache
ComicVisitor cacheComic = _cache.FirstOrDefault(c => c.ComicUrl == dbComic.ComicUrl);
//Se não existe a HQ no cache ou já foi processada, retorno
if (cacheComic == null) return;
if (cacheComic.ComicState != ComicState.Empty) return;
cacheComic.ComicId = id;
//Se não processei a HQ ainda
//Preencho a HQ
cacheComic.ComicState = ComicState.Working;
cacheComic = (ComicVisitor)_comicCrawler.Edit(cacheComic);
AddAuthor(dbComic, authorRepository, cacheComic.DirtyStateAuthor);
AddGenre(dbComic, genreRepository, cacheComic.DirtyStateGenre);
AddPublisher(dbComic, publisherRepository, cacheComic.DirtyStatePublisher);
AddChapters(id, chapterRepository, cacheComic.Chapters);
//Libero a HQ
cacheComic.ComicState = ComicState.Visited;
}
public EditionsController(IEditionRepository repository, IBookRepository bookRepository, IPublisherRepository publisherRepository, IMapper mapper)
{
_repository = repository;
_mapper = mapper;
_bookRepository = bookRepository;
_publisherRepository = publisherRepository;
}
private void AddPublisher(Comic comic, IPublisherRepository publisherRepository, string publisherStr)
{
if (string.IsNullOrEmpty(publisherStr)) return;
string[] publishers = publisherStr.Split(',');
foreach (string publisher in publishers)
{
string publisherTrim = publisher.Trim();
Publisher publisherDb = publisherRepository.Find(g => g.PublisherName.Equals(publisherTrim)).FirstOrDefault();
if (publisherDb == null)
{
publisherDb = new Publisher
{
PublisherName = publisherTrim,
Comics = new List<Comic>()
};
publisherDb.Comics.Add(comic);
publisherRepository.Add(publisherDb);
}
else
{
if (publisherDb.Comics == null) publisherDb.Comics = new List<Comic>();
if (publisherDb.Comics.Any(c => c.ComicUrl.Equals(comic.ComicUrl))) continue;
publisherDb.Comics.Add(comic);
publisherRepository.Edit(publisherDb);
}
if (comic.Publishers == null) comic.Publishers = new List<Publisher>();
if (!comic.Publishers.Any(g => g.PublisherName.Equals(publisherTrim)))
{
comic.Publishers.Add(publisherDb);
}
publisherRepository.Save();
}
}
public PublisherManager(IPublisherRepository repository) : base(repository)
{
}
public PublisherService(IPublisherRepository publisherRepository, IMapper mapper)
{
_publisherRepository = publisherRepository;
_mapper = mapper;
}
protected PublisherCommandValidatorBase(IPublisherRepository publisherRepository)
{
_publisherRepository = publisherRepository;
ValidateNameIsUnique();
ValidateName();
}
public PublisherService(IPublisherRepository repo)
{
this.repo = repo;
}
public PublisherController()
{
publisherRepository = UnityFactory.ResolveObject <IPublisherRepository>();
userRepository = UnityFactory.ResolveObject <IUserRepository>();
}
public PublisherService(IPublisherRepository publisherRepository)
{
_publisherRepository = publisherRepository;
}
public PublisherValidator()
{
this.PublisherRepository = new PublisherRepository(new StoreContext());
}
public GetAllPublishersQueryHandler(IPublisherRepository publisherRepository, IMapper mapper)
{
_publisherRepository = publisherRepository;
_mapper = mapper;
}
public GvaPublisherController(
IPublisherRepository publisherRepository)
{
this.publisherRepository = publisherRepository;
}
public PublisherController(IPublisherRepository _publisherRepo)
{
publisherRepository = _publisherRepo;
}
