public MediaFileProvider(IChapterRepository chapterRepository, ICacheService cacheService,
MediaFileProviderSettings settings)
{
_cacheService = cacheService;
_chapterRepository = chapterRepository;
_settings = settings;
}
public SuttaController()
{
//..TB TODO implement windsor
var database = new DBConnect().Connect();
chapterRepository = new ChapterRepository(database);
}
public LoggingService(ILogger logger, ILoggingRepository loggingRepository,
IChapterRepository chapterRepository)
{
_chapterRepository = chapterRepository;
_logger = logger;
_loggingRepository = loggingRepository;
}
public static void UpdateProfile_EmptyRequiredMemberProperty_ThrowsException()
{
ChapterProperty[] chapterProperties =
{
CreateMockChapterProperty("required", required: true),
CreateMockChapterProperty("optional", required: false)
};
MemberProperty[] memberProperties =
{
CreateMockMemberProperty(chapterProperties[0].Id, ""),
CreateMockMemberProperty(chapterProperties[1].Id, "optional")
};
Member member = CreateMockMember();
IChapterRepository chapterRepository = CreateMockChapterRepository(chapterProperties: chapterProperties);
IMemberRepository memberRepository = CreateMockMemberRepository(member, memberProperties);
MemberService service = CreateService(memberRepository, chapterRepository);
UpdateMemberProfile profile = new UpdateMemberProfile
{
FirstName = "first",
LastName = "last",
Properties = memberProperties.Select(x => new UpdateMemberProperty
{
ChapterPropertyId = x.ChapterPropertyId,
Value = x.Value
})
};
Assert.ThrowsAsync <OdkServiceException>(() => service.UpdateMemberProfile(Guid.NewGuid(), profile));
}
public KitabController()
{
this.imamRepository = new ImamRepository();
kitabRepository = new KitabRepository();
chapterRepository = new ChapterRepository();
this.translationRepository = new TranslationRepository();
}
/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
public MainViewModel(IChapterRepository chapterRepository ,IBookRepository bookRepository, ICategoryRepository categoryRepository)
{
_chapterRepository = chapterRepository;
_bookRepository = bookRepository;
_categoryRepository = categoryRepository;
Chapters = new ObservableCollection<Chapter>(_chapterRepository.FindAll());
Books = new ObservableCollection<Book>(_bookRepository.FindAll());
Categories = new ObservableCollection<Category>(_categoryRepository.FindAll());
SelectedBook = new Book();
SelectedCategory = new Category();
SelectedChapter = new Chapter();
//
Books.Add(new Book(1,"Cánh đồng bất tận", "Nguyễn Ngọc Tư","2011","NXB Tuổi Trẻ",new Media(),new Media()));
Books.Add(new Book(1, "Sống để kể lại", "Nguyễn Ngọc Tư", "2011", "NXB Tuổi Trẻ", new Media(), new Media()));
Categories.Add(new Category(1, "Cuộc sống", new Media()));
Categories.Add(new Category(1, "Tình yêu", new Media()));
Categories.Add(new Category(1, "Kỹ năng", new Media()));
Chapters.Add(new Chapter(1, "Giới thiệu sách nói", new Media(), new Media()));
Chapters.Add(new Chapter(1, "Trở thành biên tập viên ở El Espectador", new Media(), new Media()));
Chapters.Add(new Chapter(1, "Thử lửa với công việc phóng viên xung kích", new Media(), new Media()));
Chapters.Add(new Chapter(1, "Công việc viết phê bình điện ảnh", new Media(), new Media()));
}
public VerseAnalysisController(
IChapterRepository chapterRepository,
IVerseAnalysisRepository verseAnalysisRepository)
{
ChapterRepository = chapterRepository;
VerseAnalysisRepository = verseAnalysisRepository;
}
public QuoteController()
{
var database = new DBConnect().Connect();
_chapterRepository = new ChapterRepository(database);
_bookRepository = new BookRepository();
}
/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
public MainViewModel(IChapterRepository chapterRepository, IBookRepository bookRepository, ICategoryRepository categoryRepository)
{
_chapterRepository = chapterRepository;
_bookRepository = bookRepository;
_categoryRepository = categoryRepository;
Chapters = new ObservableCollection <Chapter>(_chapterRepository.FindAll());
Books = new ObservableCollection <Book>(_bookRepository.FindAll());
Categories = new ObservableCollection <Category>(_categoryRepository.FindAll());
SelectedBook = new Book();
SelectedCategory = new Category();
SelectedChapter = new Chapter();
//
Books.Add(new Book(1, "Cánh đồng bất tận", "Nguyễn Ngọc Tư", "2011", "NXB Tuổi Trẻ", new Media(), new Media()));
Books.Add(new Book(1, "Sống để kể lại", "Nguyễn Ngọc Tư", "2011", "NXB Tuổi Trẻ", new Media(), new Media()));
Categories.Add(new Category(1, "Cuộc sống", new Media()));
Categories.Add(new Category(1, "Tình yêu", new Media()));
Categories.Add(new Category(1, "Kỹ năng", new Media()));
Chapters.Add(new Chapter(1, "Giới thiệu sách nói", new Media(), new Media()));
Chapters.Add(new Chapter(1, "Trở thành biên tập viên ở El Espectador", new Media(), new Media()));
Chapters.Add(new Chapter(1, "Thử lửa với công việc phóng viên xung kích", new Media(), new Media()));
Chapters.Add(new Chapter(1, "Công việc viết phê bình điện ảnh", new Media(), new Media()));
}
public AuthorizationService(IMemberRepository memberRepository, ICacheService cacheService,
IChapterRepository chapterRepository)
{
_cacheService = cacheService;
_chapterRepository = chapterRepository;
_memberRepository = memberRepository;
}
public MemberAdminService(IChapterRepository chapterRepository, IMemberRepository memberRepository,
IMemberService memberService, ICacheService cacheService)
: base(chapterRepository)
{
_cacheService = cacheService;
_memberRepository = memberRepository;
_memberService = memberService;
}
public VenueAdminService(IChapterRepository chapterRepository, IVenueRepository venueRepository,
ICacheService cacheService, IEventRepository eventRepository)
: base(chapterRepository)
{
_cacheService = cacheService;
_eventRepository = eventRepository;
_venueRepository = venueRepository;
}
public ChapterService(IChapterRepository chapterRepository, ICacheService cacheService, IEmailService emailService,
IAuthorizationService authorizationService)
{
_authorizationService = authorizationService;
_cacheService = cacheService;
_chapterRepository = chapterRepository;
_emailService = emailService;
}
public PublishBookRequestHandler(IBookRepository bookRepository,
IChapterRepository chapterRepository,
IBookPageRepository bookPageRepository)
{
_bookRepository = bookRepository;
_chapterRepository = chapterRepository;
_bookPageRepository = bookPageRepository;
}
public MailProvider(IChapterRepository chapterRepository, IMemberRepository memberRepository, ILoggingService loggingService,
IEmailRepository emailRepository)
{
_chapterRepository = chapterRepository;
_emailRepository = emailRepository;
_loggingService = loggingService;
_memberRepository = memberRepository;
}
public PaymentService(IChapterRepository chapterRepository, IPaymentProvider paymentProvider, ICountryRepository countryRepository,
IPaymentRepository paymentRepository)
{
_chapterRepository = chapterRepository;
_countryRepository = countryRepository;
_paymentProvider = paymentProvider;
_paymentRepository = paymentRepository;
}
public EmailService(IChapterRepository chapterRepository, IEmailRepository emailRepository,
IMailProvider mailProvider, IMemberRepository memberRepository)
{
_chapterRepository = chapterRepository;
_emailRepository = emailRepository;
_mailProvider = mailProvider;
_memberRepository = memberRepository;
}
public VerseHadithsController(
IChapterRepository chapterRepository,
IHadithRepository hadithRepository,
IHadithViewModelFactory hadithViewModelFactory)
{
ChapterRepository = chapterRepository;
HadithRepository = hadithRepository;
HadithViewModelFactory = hadithViewModelFactory;
}
public CommentariesForVerseFactory(
IChapterRepository chapterRepository,
ICommentatorRepository commentatorRepository,
ICommentaryRepository commentaryRepository)
{
ChapterRepository = chapterRepository;
CommentatorRepository = commentatorRepository;
CommentaryRepository = commentaryRepository;
}
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 SelectChapterAndVerseFactory(
IChapterRepository chapterRepository,
IVerseRepository verseRepository,
ICommentaryRepository commentaryRepository)
{
ChapterRepository = chapterRepository;
VerseRepository = verseRepository;
CommentaryRepository = commentaryRepository;
ResultByCommentatorCode =
new ConcurrentDictionary <string, SelectChapterAndVerse>(StringComparer.InvariantCultureIgnoreCase);
}
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 AuthenticationService(IMemberRepository memberRepository, IEmailService emailService, AuthenticationServiceSettings settings,
IAuthorizationService authorizationService, IChapterRepository chapterRepository,
IAuthenticationTokenFactory authenticationTokenFactory)
{
_authenticationTokenFactory = authenticationTokenFactory;
_authorizationService = authorizationService;
_chapterRepository = chapterRepository;
_emailService = emailService;
_memberRepository = memberRepository;
_settings = settings;
}
public AdminController(
IAdminRepository adminRepository,
IBookRepository bookRepository,
IChapterRepository chapterRepository,
ILanguageRepository languageRepository
)
{
_adminRepository = adminRepository;
_bookRepository = bookRepository;
_chapterReposotory = chapterRepository;
_languageRepository = languageRepository;
}
public CourseController(ICourseService courseService,
IChapterService chapterService,
IChapterRepository chapterRepository,
IAssignmentService assignmentService,
ICourseConverter courseConverter)
{
_courseService = courseService;
_chapterService = chapterService;
_chapterRepository = chapterRepository;
_assignmentService = assignmentService;
_courseConverter = courseConverter;
}
public EventAdminService(IEventRepository eventRepository, IChapterRepository chapterRepository,
EventAdminServiceSettings settings, IMemberRepository memberRepository, IVenueRepository venueRepository,
IEmailService emailService)
: base(chapterRepository)
{
_chapterRepository = chapterRepository;
_emailService = emailService;
_eventRepository = eventRepository;
_memberRepository = memberRepository;
_settings = settings;
_venueRepository = venueRepository;
}
public ChapterController(IChapterService chapterService,
IChapterRepository chapterRepository,
IChapterConverter chapterConverter,
UserManager <User> userManager,
IMemoryCache memoryCache)
{
_chapterService = chapterService;
_chapterRepository = chapterRepository;
_chapterConverter = chapterConverter;
_userManager = userManager;
_memoryCache = memoryCache;
}
private static MemberService CreateService(IMemberRepository memberRepository = null,
IChapterRepository chapterRepository = null, ICacheService cacheService = null)
{
return(new MemberService(memberRepository ?? CreateMockMemberRepository(CreateMockMember()),
chapterRepository ?? CreateMockChapterRepository(),
CreateMockAuthorizationService(),
CreateMockMailService(),
new MemberServiceSettings(),
CreateMockImageService(),
Mock.Of <IPaymentService>(),
cacheService ?? CreateMockCacheService(new Member(Guid.NewGuid(), Guid.NewGuid(), "email", true, "first", "last", DateTime.Today, true, false, 0))));
}
public ChapterService(IChapterRepository chapterRepository,
ICourseRepository courseRepository,
IPeriodRepository periodRepository,
ITestResultRepository testResultRepository,
IAssignmentWitResultsConverter assignmentWitResultsConverter)
{
_chapterRepository = chapterRepository;
_courseRepository = courseRepository;
_periodRepository = periodRepository;
_testResultRepository = testResultRepository;
_assignmentWitResultsConverter = assignmentWitResultsConverter;
}
public FictionsController(
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IFictionRepository fictionRepository,
IChapterRepository chapterRepository,
ApplicationDbContext context)
{
_context = context;
_userManager = userManager;
_signInManager = signInManager;
_fictionRepository = fictionRepository;
_chapterRepository = chapterRepository;
}
public MemberService(IMemberRepository memberRepository, IChapterRepository chapterRepository, IAuthorizationService authorizationService,
IEmailService emailService, MemberServiceSettings settings, IImageService imageService, IPaymentService paymentService,
ICacheService cacheService)
{
_authorizationService = authorizationService;
_cacheService = cacheService;
_chapterRepository = chapterRepository;
_emailService = emailService;
_imageService = imageService;
_memberRepository = memberRepository;
_paymentService = paymentService;
_settings = settings;
}
/// <summary>
/// Recebe o repositório do Crawler e inicia a thread de pesquisa
/// </summary>
public void Start(IComicRepository comicCrawler, IChapterRepository chapterCrawler)
{
if (Started) return;
_comicCrawler = comicCrawler;
_chapterCrawler = chapterCrawler;
_cache = new List<ComicVisitor>();
_watcherThread = new Thread(Watch);
_watcherThread.Start();
Started = true;
}
private static EventAdminService CreateService(IEmailRepository memberEmailRepository = null,
IChapterRepository chapterRepository = null, IEventRepository eventRepository = null,
IVenueRepository venueRepository = null)
{
return(new EventAdminService(
eventRepository ?? CreateMockEventRepository(CreateMockEvent()),
chapterRepository ?? CreateMockChapterRepository(chapter: CreateMockChapter()),
new EventAdminServiceSettings {
BaseUrl = BaseUrl, EventRsvpUrlFormat = EventRsvpUrlFormat, EventUrlFormat = EventUrlFormat
},
GetMockMemberRepository(),
venueRepository ?? CreateMockVenueRepository(new Venue(Guid.NewGuid(), Guid.NewGuid(), "Name", "Address", "", 0)),
Mock.Of <IEmailService>()));
}
public UnitOfWork(LibraryContext libraryContext, IReaderRepository readerRepository,
IReaderCardRepository readerCardRepository, IRecordRepository recordRepository,
IBookRepository bookRepository, IChapterRepository chapterRepository,
IAuthorBookRepository authorBookRepository, IAuthorRepository authorRepository)
{
_libraryContext = libraryContext;
ReaderRepository = readerRepository;
ReaderCardRepository = readerCardRepository;
RecordRepository = recordRepository;
BookRepository = bookRepository;
ChapterRepository = chapterRepository;
AuthorBookRepository = authorBookRepository;
AuthorRepository = authorRepository;
}
private void AddChapters(int comicId, IChapterRepository chapterRepository, ICollection<Chapter> chapters)
{
if (chapters == null) return;
foreach (Chapter chapter in chapters)
{
chapter.ComicId = comicId;
if (chapter.ReleaseDate < new DateTime(1910, 1, 1))
{
chapter.ReleaseDate = new DateTime(1910, 1, 1);
}
Chapter chapterDb = chapterRepository.Find(c => c.ChapterUrl.Equals(chapter.ChapterUrl)).FirstOrDefault();
if (chapterDb == null)
{
chapterRepository.Add(chapter);
}
}
chapterRepository.Save();
}
/// <summary>
/// Preencho o capítulo passado por parâmetro
/// </summary>
internal void Dump(IChapterRepository chapterRepository, IChapterPageRepository pageRepository, int id)
{
Chapter chapter = chapterRepository.Get(id);
//Se não existe o capítulo, não faço nada
if (chapter == null) return;
//Se esse capítulo já tem as páginas dele, não faço nada
if (chapter.Pages != null && chapter.Pages.Count > 0) return;
if (pageRepository.Find(p => p.ChapterId == chapter.ChapterId).Any()) return;
VisitChapter(chapter);
List<ChapterPage> pages = chapter.Pages.ToList();
foreach (ChapterPage page in pages)
{
page.ChapterId = chapter.ChapterId;
pageRepository.Add(page);
}
if (locker == null) locker = new object();
lock (locker)
{
pageRepository.Save();
}
}
/// <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;
}
