public UpdateService(IUpdateRepository updateRepository, IGoalRepository goalRepository, IUnitOfWork unitOfWork, IFollowUserRepository followUserRepository)
{
this.updateRepository = updateRepository;
this.goalRepository = goalRepository;
this.followUserRepository = followUserRepository;
this.unitOfWork = unitOfWork;
}
public MessagesRepository(StudentifyDbContext context,
ISelectRepository <Message> selectRepository,
IInsertRepository <Message> insertRepository,
IUpdateRepository <Message> updateRepository
) : base(context)
{
Insert = insertRepository;
Update = updateRepository;
Select = selectRepository;
Select.FillWithReferences += async entities =>
{
var threads = await Context.Set <Thread>().ToListAsync();
foreach (var thread in threads)
{
await Context.Entry(thread).Reference(t => t.UserAccount).LoadAsync();
await Context.Entry(thread).Collection(t => t.Messages).LoadAsync();
}
var users = await Context.Set <StudentifyAccount>().ToListAsync();
foreach (var user in users)
{
await Context.Entry(user).Reference(i => i.User).LoadAsync();
}
};
}
private void InitializeGeneral()
{
AppUpdate.Updater.MonitorStarted += (sender, s) =>
{
IUpdateRepository repository = (IUpdateRepository)sender;
niTray.ShowBalloonTip(5000, repository.Name, Resources.Localization_Start_Monitoring, ToolTipIcon.Info);
};
AppUpdate.Updater.MonitorStopped += (sender, s) =>
{
IUpdateRepository repository = (IUpdateRepository)sender;
niTray.ShowBalloonTip(5000, repository.Name, Resources.Localization_Stop_Monitoring, ToolTipIcon.Info);
};
AppUpdate.Updater.MonitorNewVersion += (sender, version) =>
{
IUpdateRepository repository = (IUpdateRepository)sender;
niTray.ShowBalloonTip(5000, repository.Name, string.Format(Resources.Localization_Found_New_Version, version), ToolTipIcon.Info);
};
foreach (var manager in Program.RepositoryManagers.Values)
{
manager.Notification += (sender, s) =>
{
niTray.ShowBalloonTip(5000, s.Item2, s.Item1, ToolTipIcon.Info);
};
}
TopMost = Program.Settings.TopMostWindow;
InitLanguageCombobox(cbLanguage);
cbRefreshTime.SelectedItem = Program.Settings.Update.MonitorRefreshTime.ToString();
_holdUpdates = true;
cbGeneralRunMinimized.Checked = Program.Settings.RunMinimized;
cbGeneralRunWithWindows.Checked = Program.Settings.RunWithWindows;
cbCheckNewVersions.Checked = Program.Settings.Update.MonitorUpdates;
_holdUpdates = false;
}
public UpdateService(IUpdateRepository updateRepository, IGoalRepository goalRepository, IUnitOfWork unitOfWork, IFollowUserRepository followUserRepository)
{
_updateRepository = updateRepository;
_goalRepository = goalRepository;
_followUserRepository = followUserRepository;
_unitOfWork = unitOfWork;
}
public HomeController(ICreateRepository <User> createRepo, IReadRepository <User> readRepo,
IUpdateRepository <User> updateRepo)
{
mCreateRepository = createRepo;
mReadRepository = readRepo;
mUpdateRepository = updateRepo;
}
public ClientsController(ICreateRepository <Client> createRepo, IReadRepository <Client> readRepo,
IUpdateRepository <Client> updateRepo, IDeleteRepository <Client> deleteRepo)
{
mCreateRepository = createRepo;
mReadRepository = readRepo;
mUpdateRepository = updateRepo;
mDeleteRepository = deleteRepo;
}
public BlogCommandHandler(ICreateRepository <Blog> insertRepository, IUpdateRepository <Blog> updateRepository)
{
Contract.Requires(insertRepository != null);
Contract.Requires(updateRepository != null);
this._insertRepository = insertRepository;
this._updateRepository = updateRepository;
}
public ExperienceService(IUserRepository userRepository, IUnitOfWork unitOfWork)
{
this.userRepository = userRepository;
this.experienceReadRepository = unitOfWork.BuildExperienceReadRepository();
this.experienceUpdateRepository = unitOfWork.BuildExperienceUpdateRepository();
this.candidateRepository = unitOfWork.BuildCandidateRepository();
this.experienceRepository = unitOfWork.BuildExperienceRepository();
}
public MapsController(ILangRepository langRepo, IMappingRepository mappingRepo, IUpdateRepository updateRepo,
IUserRepository userRepo, IRestRegexRepository regexRepo)
{
Langs = langRepo;
Mappings = mappingRepo;
Updates = updateRepo;
Users = userRepo;
Regexes = regexRepo;
}
public InfosRepository(StudentifyDbContext context,
ISelectRepository <Info> selectRepository,
IInsertRepository <Info> insertRepository,
IUpdateRepository <Info> updateRepository
) : base(context, selectRepository)
{
Insert = insertRepository;
Update = updateRepository;
}
public PositionsService(IUserRepository userRepository, IUnitOfWork unitOfWork, ILoggerFactory loggerFactory)
{
this.userRepository = userRepository;
companiesRepository = unitOfWork.BuildCompaniesRepository();
positionsReadRepository = unitOfWork.BuildPositionsReadRepository();
positionsUpdateRepository = unitOfWork.BuildPositionsUpdateRepository();
logger = loggerFactory.CreateLogger <PositionsService>();
}
public ApplicationUpdater()
{
var updateInfoFactory = GitHubUpdateInfo.Factory.NewWithVersionByTagName();
_updateRepository = new GitHubUpdateRepository(GitHubDownloadType.Assets, updateInfoFactory, Program.Name, "h0useRus/StarCitizen");
_updateRepository.SetCurrentVersion(Program.Version.ToString(3));
_updateRepository.MonitorStarted += OnMonitorStarted;
_updateRepository.MonitorStopped += OnMonitorStopped;
_updateRepository.MonitorNewVersion += OnMonitorNewVersion;
}
public RepositoryBase(
ISelectRepository <T> selectRepository
, IInsertRepository <T> insertRepository
, IUpdateRepository <T> updateRepository
, IDeleteRepository <T> deleteRepository)
{
this.deleteRepository = deleteRepository;
this.selectRepository = selectRepository;
this.updateRepository = updateRepository;
this.insertRepository = insertRepository;
}
public UpdateService(
IDataProvider dataProvider,
IUpdateRepository updateRepository,
ICitiesRepository citiesRepository,
IZipCodesRepository zipCodesRepository
)
{
DataProvider = dataProvider ?? throw new ArgumentNullException(nameof(dataProvider));
UpdateRepository = updateRepository ?? throw new ArgumentNullException(nameof(updateRepository));
CitiesRepository = citiesRepository ?? throw new ArgumentNullException(nameof(citiesRepository));
ZipCodesRepository = zipCodesRepository ?? throw new ArgumentNullException(nameof(zipCodesRepository));
}
public StudentifyAccountsRepository(StudentifyDbContext context,
ISelectRepository <StudentifyAccount> selectRepository,
IUpdateRepository <StudentifyAccount> updateRepository,
IInsertRepository <StudentifyAccount> insertRepository) : base(context)
{
Update = updateRepository;
Select = selectRepository;
Select.FillWithReferences += async entities =>
{
await Context.Entry(entities).Reference(i => i.User).LoadAsync();
await Context.Entry(entities).Collection(i => i.Skills).LoadAsync();
};
Insert = insertRepository;
}
public UpdateService(
IUpdateRepository updateRepository,
IRssEntriesRepository rssEntriesRepository,
IRssChannelsRepository rssChannelsRepository,
IRssChannelUpdateRepository rssChannelsUpdatedRepository,
ISyndicationFeedAdapter syndicationFeedAdapter,
IMapper mapper)
{
this.updateRepository = updateRepository;
this.rssEntriesRepository = rssEntriesRepository;
this.rssChannelsRepository = rssChannelsRepository;
this.rssChannelsUpdatedRepository = rssChannelsUpdatedRepository;
this.syndicationFeedAdapter = syndicationFeedAdapter;
this.mapper = mapper;
}
public SkillsRepository(StudentifyDbContext context,
ISelectRepository <Skill> selectRepository,
IInsertRepository <Skill> insertRepository,
IUpdateRepository <Skill> updateRepository
) : base(context)
{
Insert = insertRepository;
Update = updateRepository;
Select = selectRepository;
Select.FillWithReferences += async entities =>
{
await Context.Entry(entities).Reference(t => t.Owner).LoadAsync();
//await Context.Entry(entities).Collection(m => m.).LoadAsync();
var users = await Context.Set <StudentifyAccount>().ToListAsync();
foreach (var user in users)
{
await Context.Entry(user).Reference(i => i.User).LoadAsync();
}
};
}
public UpdatesController(IUpdateRepository updates, IUserRepository users)
{
_updates = updates;
_users = users;
}
