public Debug(
IConnectGroupService connectGroupService,
IConnectUserService connectUserService,
IConnectRequestService connectRequestService,
IOptions <EmailConfig> eMailConfig,
IJobFilteringService jobFilteringService,
IConnectAddressService connectAddressService,
IConnectSendGridService connectSendGridService,
ICosmosDbService cosmosDbService,
IOptions <SendGridConfig> sendGridConfig,
IOptions <LinkConfig> linkConfig,
ILinkRepository linkRepository)
{
_connectGroupService = connectGroupService;
_connectUserService = connectUserService;
_connectRequestService = connectRequestService;
_emailConfig = eMailConfig;
_jobFilteringService = jobFilteringService;
_connectAddressService = connectAddressService;
_connectSendGridService = connectSendGridService;
_cosmosDbService = cosmosDbService;
_sendGridConfig = sendGridConfig;
_linkConfig = linkConfig;
_linkRepository = linkRepository;
}
public PageController(IPageRepository pageRepository, IEventLogRepository logger, ILinkRepository links, IMapper mapper)
{
_pages = pageRepository;
_logger = logger;
_links = links;
_mapper = mapper;
}
internal Archive(
IContentRepository contentRep,
IArchiveRepository archiveRep,
ILinkRepository linkRep,
IExtendFieldRepository extendRep,
ICategoryRepository categoryRep,
ITemplateRepository templateRep,
int id,
string strId,
int categoryId,
string title)
: base(
contentRep,
extendRep,
categoryRep,
templateRep,
linkRep,
id,
categoryId,
title
)
{
this.StrId = strId;
this._archiveRep = archiveRep;
this._templateRep = templateRep;
}
public RepositoryWrapper(
MeasureContext db,
IMeasurePointRepository measurePoint,
ILocationRepository location,
IMeasureValueRepository measureValue,
ILinkRepository link,
IPriorityStateRepository priorityState,
IUnitRepository unit,
IActiveMeasurePointRepository activeMeasurePoint,
IBatteryStateRepository batteryState,
IAirUserRepository airUser,
ILogger <RepositoryWrapper> logger)
{
_db = db;
MeasurePoint = measurePoint;
Location = location;
MeasureValue = measureValue;
Link = link;
PriorityState = priorityState;
Unit = unit;
ActiveMeasurePoint = activeMeasurePoint;
BatteryState = batteryState;
AirUser = airUser;
_logger = logger;
}
public async Task InvokeAsync(HttpContext context, ILinkRepository linkRepository, ILinkClickRepository linkClickRepository, IHttpClientFactory clientFactory)
{
var endpoint = context.GetEndpoint();
if (endpoint == null)
{
var link = await linkRepository.GetLinkByShortLinkAsync(context.Request.Path.ToString()[1..]);
public RouteManager(
ICityRepository cityRepository,
ILinkRepository linkRepository)
{
this.cityRepository = cityRepository;
this.linkRepository = linkRepository;
}
public DefaultController(IFeedbackRepository feedbackRepository, INewRepository newRepository, INoticeRepository noticeRepository, ILinkRepository linkRepository)
{
_feedbackRepository = feedbackRepository;
_newRepository = newRepository;
_noticeRepository = noticeRepository;
_linkRepository = linkRepository;
}
internal Archive(
IContentRepository contentRep,
IArchiveRepository archiveRep,
ILinkRepository linkRep,
IExtendFieldRepository extendRep,
ICategoryRepository categoryRep,
ITemplateRepository templateRep,
int id,
string strId,
int categoryId,
string title)
: base(
contentRep,
extendRep,
categoryRep,
templateRep,
linkRep,
id,
categoryId,
title
)
{
this.StrId = strId;
this._archiveRep = archiveRep;
this._templateRep = templateRep;
}
public AdminController(ApplicationDbContext ctx, IContentRepository contentRepository, ILinkRepository linkRepository, ISubdomainRepository subdomainRepository)
{
_ctx = ctx;
_contentRepository = contentRepository;
_linkRepository = linkRepository;
_subdomainRepository = subdomainRepository;
}
public OrderEventHandler(ISlackApiClient slackApiClient, ILinkRepository linkRepository, ILogger <OrderEventHandler> logger, IOptionsRepository optionsRepository)
{
_slackApiClient = slackApiClient;
_linkRepository = linkRepository;
_logger = logger;
_optionsRepository = optionsRepository;
}
static RepositoryContainer()
{
LinkRepository = new LinkRepository();
FileRepository = new FileRepository();
DocumentRepository = new DocumentRepository();
DataCollectRepository = new DataCollectRepository();
}
public HomeController(ILinkRepository linkRepository, ILinkRedirectRepository linkRedirectRepository, RedirectIpCacheSetting setting, ILog logger)
{
_linkRepository = linkRepository;
_linkRedirectRepository = linkRedirectRepository;
_setting = setting;
_logger = logger;
}
public SpiderFactory(ILogger logger, ISecurityContext securityContext, IMediaFactory mediaFactory, ILinkRepository linkRepository, ITagRepository tagRepository, IMediaRepository mediaRepository, IMetadataRepository mediaItemRepository, IAudioStreamFactory audioStreamFactory)
{
if (logger == null)
throw new ArgumentNullException("logger");
if (securityContext == null)
throw new ArgumentNullException("securityContext");
if (mediaFactory == null)
throw new ArgumentNullException("mediaFactory");
if (linkRepository == null)
throw new ArgumentNullException("linkRepository");
if (tagRepository == null)
throw new ArgumentNullException("tagRepository");
if (mediaRepository == null)
throw new ArgumentNullException("mediaRepository");
if (mediaItemRepository == null)
throw new ArgumentNullException("mediaItemRepository");
this.logger = logger;
this.securityContext = securityContext;
this.securityContext = securityContext;
this.mediaFactory = mediaFactory;
this.linkRepository = linkRepository;
this.tagRepository = tagRepository;
this.mediaRepository = mediaRepository;
this.mediaItemRepository = mediaItemRepository;
this.audioStreamFactory = audioStreamFactory;
}
public LinkController()
{
string connectionString = ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;
_linkRepository = new LinkRepository(connectionString);
_linkTypeRepository = new LinkTypeRepository(connectionString);
}
public void SetUp()
{
linkConnection = connectionFactory.Create(connectionString);
linkConnection.Open();
linkRepository = new SQLiteLinkRepository(logger, linkConnection);
linkRepository.Initialize();
tagConnection = connectionFactory.Create(connectionString);
tagConnection.Open();
tagRepository = new SQLiteTagRepository(logger, tagTypeFactory, tagConnection);
tagRepository.Initialize();
mediaConnection = connectionFactory.Create(connectionString);
mediaConnection.Open();
mediaRepository = new SQLiteMediaRepository(logger, mediaFactory, mediaConnection);
mediaRepository.Initialize();
itemConnection = connectionFactory.Create(connectionString);
itemConnection.Open();
mediaItemRepository = new SQLiteMetadataRepository(logger, securityContext, mediaFactory, itemConnection);
mediaItemRepository.Initialize();
audioStreamFactory = new AudioStreamFactory();
spider = new CatalogSpider(logger, securityContext, mediaFactory, linkRepository, tagRepository, mediaRepository, mediaItemRepository, audioStreamFactory);
}
public DeleteLinkTypeHandle(
ILinkTypeRepository linkTypeRepository,
ILinkRepository linkRepository)
{
_linkTypeRepository = linkTypeRepository;
_linkRepository = linkRepository;
}
public LinkService(
IShortenerService shortenerService,
ILinkRepository linkRepository)
{
_shortenerService = shortenerService;
_linkRepository = linkRepository;
}
public void SetUp()
{
linkConnection = connectionFactory.Create(connectionString);
linkConnection.Open();
linkRepository = new SQLiteLinkRepository(logger, linkConnection);
linkRepository.Initialize();
tagConnection = connectionFactory.Create(connectionString);
tagConnection.Open();
tagRepository = new SQLiteTagRepository(logger, tagTypeFactory, tagConnection);
tagRepository.Initialize();
mediaConnection = connectionFactory.Create(connectionString);
mediaConnection.Open();
mediaRepository = new SQLiteMediaRepository(logger, mediaFactory, mediaConnection);
mediaRepository.Initialize();
itemConnection = connectionFactory.Create(connectionString);
itemConnection.Open();
mediaItemRepository = new SQLiteMetadataRepository(logger, securityContext, mediaFactory, itemConnection);
mediaItemRepository.Initialize();
audioStreamFactory = new AudioStreamFactory();
spider = new CatalogSpider(logger, securityContext, mediaFactory, linkRepository, tagRepository, mediaRepository, mediaItemRepository, audioStreamFactory);
}
public LinksController(IInvitationRepository invitationRepository, ILinkRepository linkRepository,
IGroupRepository groupRepository)
{
_invitationRepository = invitationRepository;
_linkRepository = linkRepository;
_groupRepository = groupRepository;
}
public void InitialiseRepository(ISiteRepository sites, ILinkRepository links, IHardwareRepository hardware)
{
data = new DataConfigurationViewModel();
data.LoadSiteComboBoxes += new LoadSiteComboBoxesEvent(data_LoadSiteComboBoxes);
data.Initialise(sites, links, hardware);
DataContext = data;
}
public GetLinkCommand(
IStorage storageService,
ILinkRepository linkRepository)
{
_storageService = storageService;
_linkRepository = linkRepository;
}
public CVQuery(ICVRepository cvRepository,
ICompanyRepository companyRepository,
IProjectRepository projectRepository,
IEducationRepository educationRepository,
ILinkRepository linkRepository)
{
Field <CVType>("cv",
arguments:
new QueryArguments(
new QueryArgument <IntGraphType> {
Name = "id"
}),
resolve: context =>
cvRepository
.Get(context.GetArgument <int>("id")));
Field <ListGraphType <CVType> >("cvs",
resolve: context => cvRepository.All());
Field <CompanyType>("company",
arguments:
new QueryArguments(
new QueryArgument <IntGraphType> {
Name = "id"
}),
resolve: context =>
companyRepository
.Get(context.GetArgument <int>("id")));
Field <ProjectType>("project",
arguments:
new QueryArguments(
new QueryArgument <IntGraphType> {
Name = "id"
}),
resolve: context =>
projectRepository
.Get(context.GetArgument <int>("id")));
Field <EducationType>("education",
arguments:
new QueryArguments(
new QueryArgument <IntGraphType> {
Name = "id"
}),
resolve: context =>
educationRepository
.Get(context.GetArgument <int>("id")));
Field <LinkType>("link",
arguments:
new QueryArguments(
new QueryArgument <IntGraphType> {
Name = "id"
}),
resolve: context =>
linkRepository
.Get(context.GetArgument <int>("id")));
}
public LinkService(ILinkRepository linkRepo
, ITagRepository tagRepo
, IEventBus domainEventBus)
{
_linkRepo = linkRepo;
_tagRepo = tagRepo;
_domainEventBus = domainEventBus;
}
public AffiliateService(ILinkRedirectRepository linkRedirectRepository, IReferralRepository referralRepository, ILog logger, ILinkRepository linkRepository, IMemoryCache memoryCache)
{
_linkRedirectRepository = linkRedirectRepository;
_referralRepository = referralRepository;
_logger = logger;
_linkRepository = linkRepository;
_memoryCache = memoryCache;
}
public AddEditLinkViewModel(ILinkRepository linkRepository)
{
this.linkRepository = linkRepository;
CancelCommand = new RelayCommand(Close);
AddLinkCommand = new RelayCommand(AddLink);
GetLinkNameCommand = new RelayCommand(GetLinkName);
}
public LinksController(ILinkRepository linkRepo,
IBootcampRepository bootcampRepo,
ISiteRepository siteRepo)
{
_linkRepo = linkRepo;
_bootcampRepo = bootcampRepo;
_siteRepo = siteRepo;
}
public LinksController(ILinkRepository linkRepo,
IBootcampRepository bootcampRepo,
ISiteRepository siteRepo)
{
_linkRepo = linkRepo;
_bootcampRepo = bootcampRepo;
_siteRepo = siteRepo;
}
public FakeDataController(IUserRepository userRepository, ILinkRepository linkRepository, ILogRepository logRepository,
ITraceRepository traceRepository)
{
_userRepository = userRepository;
_linkRepository = linkRepository;
_logRepository = logRepository;
_traceRepository = traceRepository;
}
public HomeController(IConfigRepository config, IEventLogRepository logger, IMapper mapper,
SignInManager <User> signInManager,
ILinkRepository link)
{
_mapper = mapper;
_logger = logger;
_config = config;
}
public QueryObject(
ILinkRepository linkRepository,
IUserRepository userRepository)
{
this.Name = "Query";
this.Description = "The query type, represents all of the entry points into our object graph.";
this.Connection <LinkType>()
.Name("links")
.Argument <StringGraphType, string>(
name: "searchText",
description: "The searchText of the search criteria.",
defaultValue: default
)
.Description("Gets pages of links.")
// Enable the last and before arguments to do paging in reverse.
.Bidirectional()
// Set the maximum size of a page, use .ReturnAll() to set no maximum size.
.PageSize(MaxPageSize)
.ResolveAsync(context => ResolveConnectionLinks(linkRepository, context));
this.FieldAsync <LinkType, Link>(
"link",
"Get a link by its unique identifier.",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IntGraphType> >
{
Name = "id",
Description = "The id of the link.",
}),
resolve: context =>
linkRepository.GetLink(
context.GetArgument <int>("id"),
context.CancellationToken));
this.Connection <UserType>()
.Name("users")
.Description("Gets pages of users.")
// Enable the last and before arguments to do paging in reverse.
.Bidirectional()
// Set the maximum size of a page, use .ReturnAll() to set no maximum size.
.PageSize(MaxPageSize)
.ResolveAsync(context => ResolveConnectionUsers(userRepository, context));
this.FieldAsync <UserType, User>(
"user",
"Get a user by its unique identifier.",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IntGraphType> >
{
Name = "id",
Description = "The id of the user.",
}),
resolve: context =>
userRepository.GetUser(
context.GetArgument <int>("id"),
context.CancellationToken));
}
public ShortcutController(
UrlHashProvider hashProvider,
UrlValidationProvider validator,
ILinkRepository linkRepository)
{
_hashProvider = hashProvider;
_validator = validator;
_linkRepository = linkRepository;
}
public NewTaskPendingApprovalNotification(IConnectRequestService connectRequestService, IConnectGroupService connectGroupService, IConnectUserService connectUserService, ILinkRepository linkRepository, IOptions <LinkConfig> linkConfig)
{
_connectRequestService = connectRequestService;
_connectGroupService = connectGroupService;
_connectUserService = connectUserService;
_linkRepository = linkRepository;
_linkConfig = linkConfig;
_sendMessageRequests = new List <SendMessageRequest>();
}
public HomeController(
UserManager <User> userManager, IToastNotification toastNotification, ILinkRepository linkRepository,
IVoteRepository voteRepository)
{
_userManager = userManager;
_toastNotification = toastNotification;
_linkRepository = linkRepository;
_voteRepository = voteRepository;
}
public CreateLinkRequestValidator(ILinkRepository linkRepo, ITagValidator tagValidator)
{
_linkRepo = linkRepo;
RuleFor(m => m.Key).MustBeValidKey().When(request => !request.Key.IsNullOrEmpty());
RuleFor(m => m.Url).NotEmpty();
RuleFor(m => m.Url).MustBeAUrl().When(request => !request.Url.IsNullOrEmpty());
RuleFor(m => m.Tags).NotEmpty().WithMessage("At least one tag is required.");
RuleForEach(m => m.Tags).Must(tagValidator.ValidateTagExists).WithMessage(m => $"Tag '{m}' not found.");
}
public ContentLinkManager(ILinkRepository linkRep, int contentModelIndent, int contentId)
{
this._contentModelIndent = contentModelIndent;
this._contentId = contentId;
this._linkRep = linkRep;
_links = new List <ILink>();
this.ReadLinks();
}
public ContentLinkManager(ILinkRepository linkRep, int contentModelIndent, int contentId)
{
this._contentModelIndent = contentModelIndent;
this._contentId = contentId;
this._linkRep = linkRep;
_links = new List<ILink>();
this.ReadLinks();
}
public LinkService(ILinkRepository linkRepository, ILinkCrawlerService linkCrawler, HttpHelper httpHelper)
{
Ensure.That(() => linkRepository).IsNotNull();
Ensure.That(() => linkCrawler).IsNotNull();
Ensure.That(() => httpHelper).IsNotNull();
this.linkRepository = linkRepository;
this.linkCrawler = linkCrawler;
this.httpHelper = httpHelper;
}
public FacebookImporterService(IFacebookRepository fbRepository, IPostRepository postRepository, ILinkRepository linkRepository, IUserRepository userRepository)
{
Ensure.That(() => fbRepository).IsNotNull();
Ensure.That(() => postRepository).IsNotNull();
Ensure.That(() => linkRepository).IsNotNull();
Ensure.That(() => userRepository).IsNotNull();
this.fbRepository = fbRepository;
this.postRepository = postRepository;
this.linkRepository = linkRepository;
this.userRepository = userRepository;
}
/// <summary>
///
/// </summary>
/// <param name="contentRep"></param>
/// <param name="archiveRep"></param>
/// <param name="extendRep"></param>
/// <param name="categoryRep"></param>
/// <param name="templateRep"></param>
/// <param name="linkRep"></param>
/// <param name="id"></param>
/// <param name="strId"></param>
/// <param name="categoryId"></param>
/// <param name="title"></param>
/// <returns></returns>
public IArchive CreateArchive(
IContentRepository contentRep,
IArchiveRepository archiveRep,
IExtendFieldRepository extendRep,
ICategoryRepository categoryRep,
ITemplateRepository templateRep,
ILinkRepository linkRep,
int id,
string strId,
int categoryId,
string title)
{
return new Archive(contentRep, archiveRep, linkRep, extendRep, categoryRep, templateRep, id, strId, categoryId, title);
}
public ArchiveRepository(
IContentRepository contentRep,
IExtendFieldRepository extendRep,
ITemplateRepository templateRep,
ICategoryRepository categoryRep,
ILinkRepository linkRep
)
{
this._contentRep = contentRep;
this._extendRep = extendRep;
this._templateRep = templateRep;
this._categoryRep = categoryRep;
this._linkRep = linkRep;
}
public MainWindow()
{
InitializeComponent();
SqlCeConnection connection = new SqlCeConnection("Data Source=Panic.sdf");
// Upgrade the database if required
SqlCeEngine engine = new SqlCeEngine(connection.ConnectionString);
engine.Upgrade();
siteRepository = new SiteSQL(connection);
linkRepository = new LinkSQL(connection);
hardwareRepository = new HardwareSQL(connection);
graphVisualiser.InitialiseRepository(siteRepository, linkRepository);
dataConfiguration.InitialiseRepository(siteRepository, linkRepository, hardwareRepository);
graphVisualiser.Refresh();
}
public BootcampController(IBootcampRepository bootcampRepo,
ITechnologyRepository technologyRepo,
ILocationRepository locationRepo,
IBootcampLocationsRepository bootcampLocationsRepo,
IBootcampTechnologyRepository bootcampTechnologyRepo,
ILinkRepository linkRepo,
IBootcampSessionRepository sessionRepo,
ISiteRepository siteRepo)
{
_bootcampRepo = bootcampRepo;
_technologyRepo = technologyRepo;
_locationRepo = locationRepo;
_bootcampLocationsRepo = bootcampLocationsRepo;
_bootcampTechnologyRepo = bootcampTechnologyRepo;
_linkRepo = linkRepo;
_sessionRepo = sessionRepo;
_siteRepo = siteRepo;
}
public BaseContent(
IContentRepository contentRep,
IExtendFieldRepository extendRep,
ICategoryRepository categoryRep,
ITemplateRepository templateRep,
ILinkRepository linkRep,
int id,
int categoryId,
string title)
{
this._contentRep = contentRep;
this._linkRep = linkRep;
this._extendRep = extendRep;
this._categoryRep = categoryRep;
this._templateRep = templateRep;
this.ID = id;
this._category = this._categoryRep.CreateCategory(categoryId, null);
this.Title = title;
this.ID = id;
}
public ServicesController(ILinkRepository linkRepository)
{
this.linkRepository = linkRepository;
}
public HomeController(ILinkRepository repository)
{
this.linkRepository = repository;
}
public HomeController(ILinkRepository linksRepository)
{
this.linksRepository = linksRepository;
}
public CatalogController(ILogger logger, ISecurityContext securityContext, IMediaFactory mediaFactory, IMediaRepository mediaRepository, ILinkRepository linkRepository, ITagRepository tagRepository, IMetadataRepository mediaItemRepository, IAudioStreamFactory audioStreamFactory)
{
this.logger = logger;
spider = new CatalogSpider(logger, securityContext, mediaFactory, linkRepository, tagRepository, mediaRepository, mediaItemRepository, audioStreamFactory);
}
public PostHandler(ILinkRepository repository, IUrlShortener urlShortener)
{
_repository = repository;
_urlShortener = urlShortener;
}
public LINK(ILinkRepository linkRepository, IReplyRepository replyRepository)
{
_linkRepository = linkRepository;
_replyRepository = replyRepository;
}
public void InitialiseRepository(ISiteRepository sites, ILinkRepository links)
{
vm = new GraphPanelViewModel(sites, links);
DataContext = vm;
}
public GetHandler(ILinkRepository linkRepository)
{
_linkRepository = linkRepository;
}
public TagsController(ILinkRepository linkRepository, ITagRepository tagRepository)
{
this.linkRepository = linkRepository;
this.tagRepository = tagRepository;
}
public LinkService()
{
_repository = LinkRepository.Instance;
}
public LinkServices(ILinkRepository linkRepository)
{
_linkRepository = linkRepository;
}
public LinksController(ILinkRepository linkRepository)
{
this.linkRepository = linkRepository;
}
public LinkController(ILinkRepository r)
{
this.repository = r;
}
public void Initialise(ISiteRepository aSiteRepository, ILinkRepository aLinkRepository, IHardwareRepository aHardwareRepository)
{
// Create the Site Data Repository
siteRepository = aSiteRepository;
siteRepository.Populate();
siteRepository.SitesChanged += new SitesChangedHandler(siteRepository_SitesChanged);
BuildSiteInformation();
// Create the Link Data Repository
linkRepository = aLinkRepository;
List<Link> links = linkRepository.Populate();
Links = CollectionViewSource.GetDefaultView(links);
// Create the Hardware Data Repository
hardwareRepository = aHardwareRepository;
List<Hardware> hardwares = hardwareRepository.Populate();
Hardwares = CollectionViewSource.GetDefaultView(hardwares);
NotifyPropertyChanged("Sites");
NotifyPropertyChanged("Links");
NotifyPropertyChanged("Hardwares");
}
/// <summary>
/// 构造器方法
/// </summary>
/// <param name="linkRepository"></param>
public LinkService(ILinkRepository linkRepository)
{
this._linkRepository = linkRepository;
}
public NodeServiceTest()
{
linkRepository = new MockLinkRepository();
nodeRepoFactory = new MockNodeRepositoryFactory();
target = new NodeService(linkRepository, nodeRepoFactory);
}
public LinkBL()
{
repo = new LinkRepository();
}
