public TraceLogger(ICategoryManager categoryManager, string process, string subProcess = null, object categories = null)
{
if (null == categoryManager)
{
throw new ArgumentNullException("categoryManager");
}
_categoryManager = categoryManager;
if (string.IsNullOrWhiteSpace(process))
{
throw new ArgumentNullException("process");
}
_process = process;
if (string.IsNullOrWhiteSpace(subProcess))
{
throw new ArgumentNullException("subProcess");
}
_subProcess = subProcess;
if (null != categories)
{
_categoryManager.RegisterCategories(categories);
}
}
public CategoryController()
{
var kernel = new StandardKernel(new BllBindings());
kernel.Load(Assembly.GetExecutingAssembly());
_categoryManager = kernel.Get <ICategoryManager>();
}
public CategoryController(ICategoryManager categoryManager, IDasBlogSettings dasBlogSettings, IHttpContextAccessor httpContextAccessor)
: base(dasBlogSettings)
{
this.categoryManager = categoryManager;
this.dasBlogSettings = dasBlogSettings;
this.httpContextAccessor = httpContextAccessor;
}
public CategoryController(
ICategoryManager categoryManager,
ILogger <CategoryController> logger)
{
this.categoryManager = categoryManager;
this.logger = logger;
}
public ProductController(IProductManager iProductManager, ICategoryManager iCategoryManager,
IProductPhotoManager iProductPhotoManager)
{
_iProductManager = iProductManager;
_iCategoryManager = iCategoryManager;
_iProductPhotoManager = iProductPhotoManager;
}
public LiteFavoriteManager(
ICategoryManager categoryManager,
LiteDatabase liteDatabase)
{
_categoryManager = categoryManager;
_liteDatabase = liteDatabase;
}
public CatalogViewModel(
ICategoryManager categoryManager,
IRecipeManager recipeManager)
{
_categoryManager = categoryManager;
_recipeManager = recipeManager;
}
public CategoryAppService(
ICategoryManager categoryManager,
IRepository <Category, int> categoryRepository)
{
_categoryManager = categoryManager;
_categoryRepository = categoryRepository;
}
public HomeController(ILogger <HomeController> logger, ICategoryManager iCategoryManager,
ICategoryPhotoManager iCategoryPhotoManager)
{
_logger = logger;
_iCategoryManager = iCategoryManager;
_iCategoryPhotoManager = iCategoryPhotoManager;
}
private TestableMetaBlogApi CreateAuthenticatingApi(
IBlogManager blogManager = null,
ICategoryManager categoryManager = null,
IEntryManager entryManager = null,
IWeBlogSettings settings = null,
BaseMediaManager mediaManager = null,
BaseLinkManager linkManager = null
)
{
IBlogSettingsResolver settingsResolver = null;
if (settings != null)
{
settingsResolver = Mock.Of <IBlogSettingsResolver>(x =>
x.Resolve(It.IsAny <BlogHomeItem>()) == new BlogSettings(settings)
);
}
return(new TestableMetaBlogApi(
blogManager,
categoryManager,
entryManager,
settings,
mediaManager,
linkManager,
settingsResolver
)
{
AuthenticateFunction = (u, p) => { }
});
}
public ChannelItemViewModel(
ChannelGroupViewModel channelGroup,
ICategoryManager categoryManager,
IPlatformService platformService,
Category category,
Channel channel)
{
_categoryManager = categoryManager;
_platformService = platformService;
_channelGroup = channelGroup;
_category = category;
_channel = channel;
Copy = ReactiveCommand.CreateFromTask(() => _platformService.CopyTextToClipboard(Url));
Open = ReactiveCommand.CreateFromTask(DoOpen,
this.WhenAnyValue(x => x.Url, url => Uri
.IsWellFormedUriString(url, UriKind.Absolute)));
Notify = _channel.Notify;
this.ObservableForProperty(x => x.Notify)
.Select(property => property.Value)
.Do(notify => _channel.Notify = notify)
.Select(notify => channel)
.SelectMany(_categoryManager.Update)
.Subscribe();
Delete = ReactiveCommand.CreateFromTask(DoDelete);
Delete.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(x => _channelGroup.Channels.Remove(this));
}
public CategoryAppService(
ICategoryManager categoryManager,
ICategoryRepository repository) : base(repository)
{
_categoryManager = categoryManager;
_repository = repository;
}
public CategoryBusinessManager(IMapper mapper, ICategoryManager categoryManager,
ICategoryFieldManager categoryFieldManager)
{
_mapper = mapper;
_categoryManager = categoryManager;
_categoryFieldManager = categoryFieldManager;
}
public DefaultOpmlService(
ISerializationService serializationService,
ICategoryManager categoryManager)
{
_serializationService = serializationService;
_categoryManager = categoryManager;
}
public SearchItemViewModel(
ICategoryManager categoryManager,
IPlatformService platformService,
FeedlyItem feedlyItem)
{
_categoryManager = categoryManager;
_platformService = platformService;
_feedlyItem = feedlyItem;
Select = new Interaction <IList <string>, int>();
Add = ReactiveCommand.CreateFromTask(DoAdd, Observable
.Return(feedlyItem.FeedId?.Substring(5))
.Select(x => Uri.IsWellFormedUriString(x, UriKind.Absolute)));
Error = new Interaction <Exception, bool>();
Add.ThrownExceptions
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(error => Error.Handle(error));
Open = ReactiveCommand.CreateFromTask(
() => _platformService.LaunchUri(new Uri(Url)),
Observable.Return(Uri.IsWellFormedUriString(Url, UriKind.Absolute))
);
Copy = ReactiveCommand.CreateFromTask(
() => _platformService.CopyTextToClipboard(Url),
Observable.Return(!string.IsNullOrWhiteSpace(Url))
);
}
public ChannelItemViewModel(
ICategoryManager categoryManager,
IPlatformService platformService,
IMessageBus messageBus,
Channel channel)
{
_categoryManager = categoryManager;
_platformService = platformService;
_messageBus = messageBus;
_channel = channel;
Notify = _channel.Notify;
this.WhenAnyValue(x => x.Notify).Skip(1)
.Do(notify => _channel.Notify = notify)
.Select(notify => channel)
.SelectMany(_categoryManager.Update)
.Subscribe();
DeleteRequest = new Interaction <Unit, bool>();
Delete = ReactiveCommand.CreateFromTask(DoDelete);
Copy = ReactiveCommand.CreateFromTask(
() => _platformService.CopyTextToClipboard(Url)
);
Open = ReactiveCommand.CreateFromTask(DoOpen,
this.WhenAnyValue(x => x.Url).Select(x => Uri
.IsWellFormedUriString(x, UriKind.Absolute)));
}
public ChannelGroupViewModel(
Func <Channel, ChannelItemViewModel> factory,
ICategoryManager categoryManager,
IMessageBus messageBus,
Category category)
{
_categoryManager = categoryManager;
_messageBus = messageBus;
_category = category;
_factory = factory;
Title = category.Title;
Items = new ReactiveList <ChannelItemViewModel>();
messageBus.Listen <ChannelDeleteEvent>()
.Where(x => _category.Channels.Contains(x.Channel))
.Do(x => _category.Channels.Remove(x.Channel))
.Where(x => Items.Contains(x.ChannelItemViewModel))
.Do(x => Items.Remove(x.ChannelItemViewModel))
.SelectMany(x => _categoryManager.Update(category))
.Subscribe();
Load = ReactiveCommand.Create(
() => Items.AddRange(_category.Channels.Select(factory))
);
AddChannel = ReactiveCommand.CreateFromTask(DoAddChannel,
this.WhenAnyValue(x => x.ChannelUri, x => Uri
.IsWellFormedUriString(x, UriKind.Absolute)));
RemoveRequest = new Interaction <Unit, bool>();
RenameRequest = new Interaction <Unit, string>();
Remove = ReactiveCommand.CreateFromTask(DoRemove);
Rename = ReactiveCommand.CreateFromTask(DoRename);
}
public FeedViewModel(
Func <Category, FeedGroupViewModel> factory,
INavigationService navigationService,
ICategoryManager categoryManager,
ISettingManager settingManager)
{
_navigationService = navigationService;
_categoryManager = categoryManager;
_settingManager = settingManager;
_factory = factory;
Items = new ReactiveList <FeedGroupViewModel>();
Modify = ReactiveCommand.CreateFromTask(
() => _navigationService.Navigate <ChannelViewModel>()
);
Load = ReactiveCommand.CreateFromTask(DoLoad);
Load.IsExecuting.Skip(1)
.Subscribe(x => IsLoading = x);
Items.CountChanged
.Select(count => count == 0)
.Subscribe(x => IsEmpty = x);
Error = new Interaction <Exception, bool>();
Load.ThrownExceptions
.ObserveOn(RxApp.MainThreadScheduler)
.SelectMany(error => Error.Handle(error))
.Where(retryRequested => retryRequested)
.Select(x => Unit.Default)
.InvokeCommand(Load);
}
public ErrorManager(IErrorRepository errorRepository, ICategoryManager categoryManager, ILevelManager levelManager, IMapper mapper)
{
_errorRepository = errorRepository;
_categoryManager = categoryManager;
_levelManager = levelManager;
_mapper = mapper;
}
public DefaultOpmlService(
ICategoryManager categoryManager,
ISerializationService serializationService)
{
_categoryManager = categoryManager;
_serializationService = serializationService;
}
public CategoryRolesViewProvider(
IHttpContextAccessor httpContextAccessor,
ICategoryManager <CategoryBase> categoryManager)
{
_categoryManager = categoryManager;
_request = httpContextAccessor.HttpContext.Request;
}
public CategoryController(ICategoryManager categoryManager, IDasBlogSettings settings, IHttpContextAccessor httpContextAccessor, IMapper mapper)
: base(settings)
{
this.categoryManager = categoryManager;
dasBlogSettings = settings;
this.httpContextAccessor = httpContextAccessor;
this.mapper = mapper;
}
public HomeController(ICategoryManager categoryManager, IProductManager productManager, IUserManager userManager,
IShoppingCartManager shoppingCartManager)
{
this.categoryManager = categoryManager;
this.productManager = productManager;
this.userManager = userManager;
this.shoppingCartManager = shoppingCartManager;
}
public CategoryController(ICategoryManager categoryManager, IDasBlogSettings settings,
IHttpContextAccessor httpContextAccessor, IMapper mapper)
{
_categoryManager = categoryManager;
_dasBlogSettings = settings;
_httpContextAccessor = httpContextAccessor;
_mapper = mapper;
}
public DrinksManageController(ICategoryManager categoryManager,
IAdminDrinkService drinks, IDrinkRepository drinksRepo, ApplicationDbContext db)
{
this.categoryManager = categoryManager;
this._db = db;
this.drinks = drinks;
this._drinksRepo = drinksRepo;
}
public CategoriesController(ICategoryManager categoryManager, ICommandBus commandBus, ILogger logger)
{
_categoryManager = categoryManager;
_categoryMapper = new CategoryToCategoryMapper();
_questionMapper = new QuestionToQuestionMapper();
_commandBus = commandBus;
_logger = logger;
}
public ProductController()
{
productManager = new SqlProductManager();
categoryManager = new SqlCategoryManager();
manufacturerManager = new SqlManufacturerManager();
}
public CategoryAppService(ICategoryManager catalogyManager,
ICacheManager cacheManager,
IPictureManager pictureManager)
{
this._catalogyManager = catalogyManager;
this._cacheManager = cacheManager;
this._pictureManager = pictureManager;
}
public CategoryAppService(
ICategoryRepository repository,
ICategoryManager categoryManager) :
base(repository)
{
SetPermissions();
this._categoryManager = categoryManager;
}
/// <summary>
/// 构造函数
///</summary>
public CategoryAppService(
IRepository <Category, long> entityRepository
, ICategoryManager entityManager
)
{
_entityRepository = entityRepository;
_entityManager = entityManager;
}
public MenuController(IMenuManager menuManager,
ICategoryManager categoryManager, IManager<Ingredient> ingredientManager, IDataManager<Restaurant> restaurantManager)
{
_menuManager = menuManager;
_categoryManager = categoryManager;
_ingredientManager = ingredientManager;
_restaurantManager = restaurantManager;
}
public SyncDataService(ICategoryManager categoryManager, IProviderManager providerManager,
IContentManager contentManager, IParserService parserService)
{
_categoryManager = categoryManager;
_providerManager = providerManager;
_contentManager = contentManager;
_parserService = parserService;
Locked = false;
}
public DelightService()
{
IoCBootstrapper.Boot();
_accountManager = ObjectFactory.GetInstance<IAccountManager>();
_categoryManager = ObjectFactory.GetInstance<ICategoryManager>();
_productManager = ObjectFactory.GetInstance<IProductManager>();
_userGroupManager = ObjectFactory.GetInstance<IUserGroupManager>();
_voteManager = ObjectFactory.GetInstance<IVoteManager>();
_userManager = ObjectFactory.GetInstance<IUserManager>();
_sessionManager = ObjectFactory.GetInstance<ISessionManager>();
_messageManager = ObjectFactory.GetInstance<IMessageManager>();
}
public CatalogViewModel(
IPackageManager packageManager,
IProductManager productManager,
IProducerManager producerManager,
ICategoryManager categoryManager,
IMeasureManager measureManager,
IPriceManager priceManager
)
{
_packageManager = packageManager;
_productManager = productManager;
_producerManager = producerManager;
_categoryManager = categoryManager;
_measureManager = measureManager;
_priceManager = priceManager;
}
public CategoryController(ICategoryManager categoryManager)
{
_categoryManager = categoryManager;
}
public TestableMetaBlogApi(IBlogManager blogManager = null, ICategoryManager categoryManager = null, IEntryManager entryManager = null)
: base(blogManager, categoryManager, entryManager)
{
}
public CategoryViewModel(ICategoryManager categoryManager)
{
_categoryManager = categoryManager;
}
public SourceController(ISourceManager sourceManager, ICategoryManager categoryManager)
{
SourceManager = sourceManager;
CategoryManager = categoryManager;
}
public DishController(IDishManager dishManager, ICategoryManager categoryManager, IManager<Ingredient> ingredientManager)
{
_dishManager = dishManager;
_categoryManager = categoryManager;
_ingredientManager = ingredientManager;
}
public CategoryController(ICategoryManager categoryManager, ISourceManager sourceManager)
{
CategoryManager = categoryManager;
SourceManager = sourceManager;
}
public MetaBlogApi(IBlogManager blogManager, ICategoryManager categoryManager, IEntryManager entryManager)
{
BlogManager = blogManager ?? ManagerFactory.BlogManagerInstance;
CategoryManager = categoryManager ?? ManagerFactory.CategoryManagerInstance;
EntryManager = entryManager ?? ManagerFactory.EntryManagerInstance;
}
