public CategoryController(IBookService bookService, ICategoryService categoryService, IAuthorService authorService, IPublisherService publisherService)
{
_bookService = bookService;
_categoryService = categoryService;
_authorService = authorService;
_publisherService = publisherService;
}
public PublisherListPageViewModel(INavigationService navigationService, IPublisherService publisherService)
{
_navigationService = navigationService;
_publisherService = publisherService;
Publishers = _publisherService.LoadListPublisher();
ItemTappedCommand = new DelegateCommand <object>(ListView_ItemTappedMethod);
}
public VideoGameService(IVideoGameRepository videoGameRepo, IPlateform_VideoGameService plateform_VideoGameService, IDeveloperService developerService, IPublisherService publisherService)
{
_videoGameRepo = videoGameRepo;
_plateform_VideoGameService = plateform_VideoGameService;
_developerService = developerService;
_publisherService = publisherService;
}
public void Initialize()
{
_publisherService = A.Fake<IPublisherService>();
var logger = A.Fake<ILogger<GatePublisherMiddleware>>();
_next = A.Fake<RequestDelegate>();
_middleware = new GatePublisherMiddleware(_publisherService, logger, _next);
}
public PublisherController(IPublisherService publisherRepository, IUserInfoService userInfoService)
{
_publisherRepository = publisherRepository
?? throw new ArgumentNullException(nameof(publisherRepository));
_userInfoService = userInfoService
?? throw new ArgumentNullException(nameof(userInfoService));
}
public PublisherController( IPublisherService publisherService, ILogger logger )
{
_logger = logger;
_publisherService = publisherService;
Mapper.CreateMap<PublisherDTO, PublisherViewModel>();
Mapper.CreateMap<PublisherViewModel, PublisherDTO>();
}
public PublisherController(IMapper mapper, IUserService userService, IImageService imageService, IPublisherService publisherService)
{
_mapper = mapper;
_imageService = imageService;
_userService = userService;
_publisherService = publisherService;
}
public PublisherRootType(IPublisherService publisherService)
{
this.publisherService = publisherService;
RegisterGetPublishers();
RegisterGetPublisherById();
}
public HomeController(ILogger <HomeController> logger, IBookService bookService, IPublisherService publisherService, IAuthorService authorService)
{
_logger = logger;
this.publisherService = publisherService;
this.bookService = bookService;
this.authorService = authorService;
}
public PublisherPageViewModel(INavigationService navigationService, IPublisherService publisherService, IEventAggregator eventAggregator)
{
_navigationService = navigationService;
_publisherService = publisherService;
_eventAggregator = eventAggregator;
IsDeleteVisible = false;
}
public GetPublisherByIdQueryHandler(
ILogger <GetPublisherByIdQuery> logger,
IPublisherService service)
: base(logger)
{
_service = service;
}
///<summary>
/// Creates a publisher process
///</summary>
public void ExecutePublisherCommand(
String processName,
String siteName,
String processURL,
String brokerURL)
{
lock (stateList) {
stateList.Add(processName, ProcessState.OFFLINE);
String arguments = processName + " " + siteName + " " + processURL + " " + brokerURL;
Process publisher = Process.Start(PUBLISHERFILE, arguments);
publisher.Attach(); //DebugTools
Thread.Sleep(1);
try {
IPublisherService processService = (IPublisherService)Activator.GetObject(
typeof(IPublisherService),
processURL);
processService.ConnectToPuppetMaster(serviceURL);
publisherTable.Add(processName, processService);
}
catch (Exception)
{
throw;
}
stateList[processName] = ProcessState.UNFROZEN;
}
}
public BookController(IBookService bookService, IAuthorService authorService, IPublisherService publisherService, IWebHostEnvironment webHostEnvironment)
{
this.bookService = bookService;
this.authorService = authorService;
this.publisherService = publisherService;
this.webHostEnvironment = webHostEnvironment;
}
public RemoveExerciseFromRoutineHandler(IUnitOfWork unitOfWork, IPublisherService publisherService, IUserService userService, IConfiguration configuration)
{
_unitOfWork = unitOfWork;
_publisherService = publisherService;
_userService = userService;
Configuration = configuration;
}
public CopyArticleService(IArticleService articleService,
IArticleAttributeService articleAttributeService,
ILanguageService languageService,
ILocalizedEntityService localizedEntityService,
ILocalizationService localizationService,
IPictureService pictureService,
ICategoryService categoryService,
IPublisherService publisherService,
ISpecificationAttributeService specificationAttributeService,
IDownloadService downloadService,
IArticleAttributeParser articleAttributeParser,
IUrlRecordService urlRecordService,
IStoreMappingService storeMappingService)
{
this._articleService = articleService;
this._articleAttributeService = articleAttributeService;
this._languageService = languageService;
this._localizedEntityService = localizedEntityService;
this._localizationService = localizationService;
this._pictureService = pictureService;
this._categoryService = categoryService;
this._publisherService = publisherService;
this._specificationAttributeService = specificationAttributeService;
this._downloadService = downloadService;
this._articleAttributeParser = articleAttributeParser;
this._urlRecordService = urlRecordService;
this._storeMappingService = storeMappingService;
}
protected void Page_Load(object sender, EventArgs e)
{
var serviceProvider = new ServiceCollection()
.AddSingleton <IPublisherService, PublisherService>()
.AddSingleton <IChannelService, ChannelService>()
.AddSingleton <ISubscriberService, SubscriberService>()
.BuildServiceProvider();
publisherService = serviceProvider.GetService <IPublisherService>();
channelService = serviceProvider.GetService <IChannelService>();
subscriberService = serviceProvider.GetService <ISubscriberService>();
var channelCentre = new Channel();
var publisher = new Publisher("Publisher");
for (int i = 0; i < 5; i++)
{
channelService.SubscribeChannel(channelCentre, new Subscriber());
}
publisherService.Post(publisher, new Message("Update from Publisher"), channelCentre);
channelService.Broadcast(channelCentre);
int subno = 0;
StringBuilder html = new StringBuilder();
foreach (var subscriber in channelCentre.Subscribers)
{
subno += 1;
RetrieveMessages(html, subscriber, subno);
}
SubscriberMessage.Controls.Add(new Literal {
Text = html.ToString()
});
}
public void SetUp()
{
_publisherService = A.Fake <IPublisherService>();
_logger = A.Fake <ILogger <PublisherController> >();
_mapper = A.Fake <IMapper>();
_publisherController = new PublisherController(_publisherService, _logger, _mapper);
}
public BooksController(IBookService bookService, ICategoryService categoryService, IPublisherService publisherService, IWriterService writerService)
{
this.bookService = bookService;
this.categoryService = categoryService;
this.writerService = writerService;
this.publisherService = publisherService;
}
public AddBookPresenter(IBookService bookService, ITagService tagService, IAuthorService authorService, IPublisherService publisherService,
IAddBookForm view,
IImageFileReader imageFileReader)
{
this._bookService = bookService;
this._tagService = tagService;
this._authorService = authorService;
this._publisherService = publisherService;
this._view = view;
this._imageFileReader = imageFileReader;
this._allTags = new Dictionary <string, bool>();
this._allAuthors = new Dictionary <string, bool>();
this._allPublishers = new List <string>();
// subscribe to the view's events
this._view.SaveButtonClicked += (async(sender, args) =>
{
await HandleSaveButtonClicked(sender, args);
});
this._view.InputFieldsUpdated += InputFieldsUpdated;
this._view.FilterTagsFieldUpdated += FilterTags;
this._view.FilterAuthorsFieldUpdated += FilterAuthors;
this._view.FilterPublishersFieldUpdated += FilterPublishers;
this._view.AddNewTagButtonClicked += HandleAddNewTagClicked;
this._view.AddNewAuthorButtonClicked += HandleAddNewAuthorClicked;
this._view.AddNewPublisherButtonClicked += HandleAddNewPublisherClicked;
this._view.TagCheckedChanged += HandleTagCheckedChanged;
this._view.AuthorCheckedChanged += HandleAuthorCheckedChanged;
}
public TextManageViewModel(IRegionManager regionManager, IPublisherService publisherService,
ITextService textService)
{
mRegionManager = regionManager;
mPublisherService = publisherService;
mTextService = textService;
var books = mPublisherService.GetPublishersAndBooks();
foreach (var p in books)
{
foreach (var b in p.Books)
{
var book = new BookVm
{
Title = b.Title,
Id = b.Id,
Publisher = p.Title
};
Books.Add(book);
}
}
var texts = mTextService.GetTexts();
foreach (var text in texts)
{
var book = Books.FirstOrDefault(a => a.Id == text.BookId);
book?.Texts.Add(new TextVm
{
Id = text.Id,
Title = text.Title
});
}
}
public AccountController(IAccountService accountService, IAuthentication auth, IMapper mapper,
IPublisherService publisherService) : base(auth)
{
_accountService = accountService;
_publisherService = publisherService;
_mapper = mapper;
}
public BooksController(IBookService bookService, ICategoryService categoryService, IPublisherService publisherService, IAuthorService authorService)
{
this.bookService = bookService;
this.categoryService = categoryService;
this.publisherService = publisherService;
this.authorService = authorService;
}
public SetDoneHandler(IUnitOfWork unitOfWork, IPublisherService publisherService, IConfiguration configuration, IUserService userService)
{
_unitOfWork = unitOfWork;
_publisherService = publisherService;
Configuration = configuration;
_userService = userService;
}
private PublisherService()
{
_publisherService = RestService.For<IPublisherService>(Constants.V1BaseUrl, new RefitSettings
{
AuthorizationHeaderValueGetter = TokenService.GetAuthToken
});
}
public BookController()
{
_bookService = new BookService();
_publisherService = new PublisherService();
_categoryService = new CategoryService();
_authorService = new AuthorService();
}
public BookController(IBookService bookService,
IAuthorService authorService, IPublisherService publisherService) : base()
{
_bookService = bookService;
_authorService = authorService;
_publisherService = publisherService;
}
public BookController(IBookService _bookService, IAuthorService _authorService, IPublisherService _publisherService, IBookTypeService _bookTypeService)
{
bookService = _bookService;
authorService = _authorService;
publisherService = _publisherService;
bookTypeService = _bookTypeService;
}
public DealsController(IAccountService accountService, IPublisherService publisherService, IDealService dealService, IMappingEngine mapping)
{
_accountService = accountService;
_publisherService = publisherService;
_dealService = dealService;
_mapping = mapping;
}
public PublisherController(
IPublisherService publisherService,
ILanguageService languageService)
{
_publisherService = publisherService;
_languageService = languageService;
}
public DatabaseSeedingController(IAuthorsService authorsService,
IPublisherService publisherService, IBooksService booksService, IHostingEnvironment environment)
{
this.authorsService = authorsService;
this.publisherService = publisherService;
this.booksService = booksService;
this.environment = environment;
}
public BookEditModel(IBookService bookService, IAuthorService authorService, IWebHostEnvironment webHostEnvironment, IPublisherService publisherService, ITitleAuthorService titleAuthorService)
{
this.bookService = bookService;
this.authorService = authorService;
this.webHostEnvironment = webHostEnvironment;
this.publisherService = publisherService;
this.titleAuthorService = titleAuthorService;
}
internal XDAmazonBroadcaster(ISerializer serializer, IPublisherService publisherService,
TopicRepository topicRepository)
{
Validate.That(serializer).IsNotNull();
Validate.That(publisherService).IsNotNull();
Validate.That(topicRepository).IsNotNull();
this.serializer = serializer;
this.publisherService = publisherService;
this.topicRepository = topicRepository;
}
internal XDAmazonBroadcaster(ISerializer serializer, IPublisherService publisherService,
TopicRepository topicRepository)
{
serializer.Requires("serializer").IsNotNull();
publisherService.Requires("publisherService").IsNotNull();
topicRepository.Requires("topicRepository").IsNotNull();
this.serializer = serializer;
this.publisherService = publisherService;
this.topicRepository = topicRepository;
}
public GamesController(IGameService gameService,
ILogger logger,
IGenreService genreService,
IPlarfotmTypeService platformTypeService,
IPublisherService publisherService)
{
_gameService = gameService;
_logger = logger;
_genreService = genreService;
_publisherService = publisherService;
_plarfotmTypeService = platformTypeService;
Mapper.CreateMap<CreateGameViewModel, GameDTO>()
.ForMember(g => g.Genres, m => m.Ignore())
.ForMember(g => g.PlatformTypes, m => m.Ignore())
.ForMember(g => g.Publisher, m => m.Ignore());
Mapper.CreateMap<CreateGameViewModel, GameViewModel>()
.ForMember(g => g.Genres, m => m.Ignore())
.ForMember(g => g.PlatformTypes, m => m.Ignore())
.ForMember(g => g.Publishers, m => m.Ignore());
Mapper.CreateMap<FilterViewModel, FilterDTO>()
.ForMember(f => f.From, m => m.MapFrom(fvm => Convert.ToDecimal(fvm.From)))
.ForMember(f => f.To, m => m.MapFrom(fvm => Convert.ToDecimal(fvm.To)));
Mapper.CreateMap<GameDTO, GameDetailsViewModel>()
.ForMember(g => g.Genres,
m =>
m.MapFrom(
gamedto =>
new MultiSelectList(
gamedto.Genres.Select(
genre =>
new SelectListItem() { Value = genre.GenreId.ToString(), Text = genre.Name }))))
.ForMember(pt => pt.PlatformTypes,
m =>
m.MapFrom(
ptDto =>
new MultiSelectList(
ptDto.PlatformTypes.Select(
platformType =>
new SelectListItem()
{
Value = platformType.PlatformTypeId.ToString(),
Text = platformType.Name
}))))
.ForMember(g => g.PublisherCompanyName, m => m.MapFrom(g => g.Publisher.CompanyName));
}
public HomeController(IPublisherService iPublishService)
{
this.iPublishService = iPublishService;
}
public PublisherController(IPublisherService service)
:base()
{
PublisherService = service;
}
private static void CloseProxy(IPublisherService proxy)
{
proxy.Unsubscribe(EventType.AllEvents);
((ICommunicationObject)proxy).Close();
}
public TagsController(IPublisherService iPublishService)
{
this.iPublishService = iPublishService;
}
public PublishersController(IPublisherService service, IUnitOfWork uow)
{
_service = service;
_uow = uow;
}
