public DrawingService(ILogger <DrawingService> logger,
GRA.Abstract.IDateTimeProvider dateTimeProvider,
IUserContextProvider userContextProvider,
IBranchRepository branchRepository,
IDrawingRepository drawingRepository,
IDrawingCriterionRepository drawingCriterionRepository,
IMailRepository mailRepository,
IPrizeWinnerRepository prizeWinnerRepository,
IProgramRepository programRepository,
ISystemRepository systemRepository)
: base(logger, dateTimeProvider, userContextProvider)
{
_branchRepository = branchRepository
?? throw new ArgumentNullException(nameof(branchRepository));
_drawingRepository = drawingRepository
?? throw new ArgumentNullException(nameof(drawingRepository));
_drawingCriterionRepository = drawingCriterionRepository
?? throw new ArgumentNullException(
nameof(drawingCriterionRepository));
_mailRepository = mailRepository
?? throw new ArgumentNullException(nameof(mailRepository));
_prizeWinnerRepository = prizeWinnerRepository
?? throw new ArgumentNullException(nameof(prizeWinnerRepository));
_programRepository = programRepository
?? throw new ArgumentNullException(nameof(programRepository));
_systemRepository = systemRepository
?? throw new ArgumentNullException(nameof(systemRepository));
}
public SystemService(
ISystemRepository systemRepository,
IMapper mapper)
{
_systemRepository = systemRepository;
_mapper = mapper;
}
public PrizeWinnerService(ILogger <PrizeWinnerService> logger,
GRA.Abstract.IDateTimeProvider dateTimeProvider,
IUserContextProvider userContextProvider,
IBranchRepository branchRepository,
IDrawingCriterionRepository drawingCriterionRepository,
IDrawingRepository drawingRepository,
IPrizeWinnerRepository prizeWinnerRepository,
ISystemRepository systemRepository,
ITriggerRepository triggerRepository,
IUserRepository userRepository,
IVendorCodeRepository vendorCodeRepository,
IVendorCodeTypeRepository vendorCodeTypeRepository)
: base(logger, dateTimeProvider, userContextProvider)
{
_branchRepository = branchRepository
?? throw new ArgumentNullException(nameof(branchRepository));
_drawingCriterionRepository = drawingCriterionRepository
?? throw new ArgumentNullException(nameof(drawingCriterionRepository));
_drawingRepository = drawingRepository
?? throw new ArgumentNullException(nameof(drawingRepository));
_prizeWinnerRepository = prizeWinnerRepository
?? throw new ArgumentNullException(nameof(prizeWinnerRepository));
_systemRepository = systemRepository
?? throw new ArgumentNullException(nameof(systemRepository));
_triggerRepository = triggerRepository
?? throw new ArgumentNullException(nameof(triggerRepository));
_userRepository = userRepository
?? throw new ArgumentNullException(nameof(userRepository));
_vendorCodeRepository = vendorCodeRepository
?? throw new ArgumentNullException(nameof(vendorCodeRepository));
_vendorCodeTypeRepository = vendorCodeTypeRepository
?? throw new ArgumentNullException(nameof(vendorCodeTypeRepository));
SetManagementPermission(Permission.ViewUserPrizes);
}
protected Mock <IUnitOfWork> GetNewMockedUnitOfWork(ISystemRepository repository)
{
var unitOfWorkMock = new Mock <IUnitOfWork>();
unitOfWorkMock.Setup(u => u.Systems).Returns(repository);
return(unitOfWorkMock);
}
public DocMenuE1Repository(IConfiguration configuration, IRegisterUserRepository IRegisterUserRepository, ISystemRepository SystemRepository)
{
_configuration = configuration;
ConnectionString = Encoding.UTF8.GetString(Convert.FromBase64String(_configuration.GetConnectionString("SqlConnection")));
_IRegisterUserRepository = IRegisterUserRepository;
_ISystemRepository = SystemRepository;
}
public TriggerService(ILogger <TriggerService> logger,
GRA.Abstract.IDateTimeProvider dateTimeProvider,
IUserContextProvider userContextProvider,
IAvatarBundleRepository avatarBundleRepository,
IBranchRepository branchRepository,
IEventRepository eventRepository,
IProgramRepository programRepository,
ISystemRepository systemRepository,
ITriggerRepository triggerRepository,
SiteLookupService siteLookupService)
: base(logger, dateTimeProvider, userContextProvider)
{
SetManagementPermission(Permission.ManageTriggers);
_avatarBundleRepository = avatarBundleRepository
?? throw new ArgumentNullException(
nameof(avatarBundleRepository));
_branchRepository = branchRepository
?? throw new ArgumentNullException(nameof(branchRepository));
_eventRepository = eventRepository
?? throw new ArgumentNullException(nameof(eventRepository));
_programRepository = programRepository
?? throw new ArgumentNullException(nameof(programRepository));
_systemRepository = systemRepository
?? throw new ArgumentNullException(nameof(systemRepository));
_triggerRepository = triggerRepository
?? throw new ArgumentNullException(nameof(triggerRepository));
_siteLookupService = siteLookupService
?? throw new ArgumentNullException(nameof(siteLookupService));
}
public SetupMultipleProgramService(ILogger <SetupMultipleProgramService> logger,
GRA.Abstract.IDateTimeProvider dateTimeProvider,
IAuthorizationCodeRepository authorizationCodeRepository,
IBranchRepository branchRepository,
IChallengeTaskRepository challengeTaskRepository,
IProgramRepository programRepository,
IRoleRepository roleRepository,
ISystemRepository systemRepository,
IPointTranslationRepository pointTranslationRepository,
IUserRepository userRepository) : base(logger, dateTimeProvider)
{
_authorizationCodeRepository = authorizationCodeRepository
?? throw new ArgumentNullException(nameof(authorizationCodeRepository));
_branchRepository = branchRepository
?? throw new ArgumentNullException(nameof(branchRepository));
_challengeTaskRepository = challengeTaskRepository
?? throw new ArgumentNullException(nameof(challengeTaskRepository));
_programRepository = programRepository
?? throw new ArgumentNullException(nameof(programRepository));
_roleRepository = roleRepository
?? throw new ArgumentNullException(nameof(roleRepository));
_systemRepository = systemRepository
?? throw new ArgumentNullException(nameof(systemRepository));
_pointTranslationRepository = pointTranslationRepository
?? throw new ArgumentNullException(nameof(pointTranslationRepository));
_userRepository = userRepository
?? throw new ArgumentNullException(nameof(userRepository));
}
public Form1(IKernel kernel)
{
#region Splash screen Start
//this.Hide();
//Thread splashthread = new Thread(new ThreadStart(SplashScreen.ShowSplashScreen));
//splashthread.IsBackground = true;
//splashthread.Start();
#endregion
Kernel = kernel;
UserRepository = Kernel.Get<UserRepository>();
SystemRepository = Kernel.Get<SystemRepository>();
UserDesktopRepository = Kernel.Get<UserDesktopRepository>();
InitializeComponent();
var details = UserRepository.GetSessionDetails(AppSettings.Instance.LiveUserAccount.Username);
if (details.GoDaddyAccount == null && !string.IsNullOrEmpty(Settings.Default.GDUsername))
{
details.GoDaddyAccount = new GoDaddyAccount()
{
AccountId = Guid.NewGuid(), AccountUsername = details.Username, Password = Settings.Default.GDPassword,
Username = Settings.Default.GDUsername, UserID = AppSettings.Instance.LiveUserAccount.AccountID
};
SystemRepository.SaveGodaddyAccount(details.GoDaddyAccount);
}
AppSettings.Instance.SessionDetails = details;
AppSettings.Instance.GoDaddy = new GoDaddyAuctionSniper(AppSettings.Instance.SessionDetails.Username, Kernel.Get<IUserRepository>());
LoadAuctions();
Instance = this;
//Login();
}
public Form1(IKernel kernel)
{
#region Splash screen Start
//this.Hide();
//Thread splashthread = new Thread(new ThreadStart(SplashScreen.ShowSplashScreen));
//splashthread.IsBackground = true;
//splashthread.Start();
#endregion
Kernel = kernel;
UserRepository = Kernel.Get <UserRepository>();
SystemRepository = Kernel.Get <SystemRepository>();
UserDesktopRepository = Kernel.Get <UserDesktopRepository>();
InitializeComponent();
var details = UserRepository.GetSessionDetails(AppSettings.Instance.LiveUserAccount.Username);
if (details.GoDaddyAccount == null && !string.IsNullOrEmpty(Settings.Default.GDUsername))
{
details.GoDaddyAccount = new GoDaddyAccount()
{
AccountId = Guid.NewGuid(), AccountUsername = details.Username, Password = Settings.Default.GDPassword,
Username = Settings.Default.GDUsername, UserID = AppSettings.Instance.LiveUserAccount.AccountID
};
SystemRepository.SaveGodaddyAccount(details.GoDaddyAccount);
}
AppSettings.Instance.SessionDetails = details;
AppSettings.Instance.GoDaddy = new GoDaddyAuctionSniper(AppSettings.Instance.SessionDetails.Username, Kernel.Get <IUserRepository>());
LoadAuctions();
Instance = this;
//Login();
}
public ReportService(ILogger <ReportService> logger,
GRA.Abstract.IDateTimeProvider dateTimeProvider,
IUserContextProvider userContextProvider,
IServiceProvider serviceProvider,
IDistributedCache cache,
IBranchRepository branchRepository,
IReportCriterionRepository reportCriterionRepository,
IReportRequestRepository reportRequestRepository,
IUserRepository userRepository,
IUserLogRepository userLogRepository,
ISystemRepository systemRepository)
: base(logger, dateTimeProvider, userContextProvider)
{
_serviceProvider = serviceProvider
?? throw new ArgumentNullException(nameof(serviceProvider));
_cache = cache ?? throw new ArgumentNullException(nameof(cache));
_branchRepository = branchRepository
?? throw new ArgumentNullException(nameof(branchRepository));
_reportCriterionRepository = reportCriterionRepository
?? throw new ArgumentNullException(nameof(reportCriterionRepository));
_reportRequestRepository = reportRequestRepository
?? throw new ArgumentNullException(nameof(reportRequestRepository));
_userRepository = userRepository
?? throw new ArgumentNullException(nameof(userRepository));
_userLogRepository = userLogRepository
?? throw new ArgumentNullException(nameof(userLogRepository));
_systemRepository = systemRepository
?? throw new ArgumentNullException(nameof(systemRepository));
}
//#Bonsai Snippets - Declarations
public override void SetRepositories()
{
_Service = new SystemService <SystemViewModel>((U, C, A) =>
ExecuteQueryWithReturnTypeAndNetworkAccessAsync <SystemViewModel>(U, C, A));
_Repository = new SystemRepository <SystemViewModel>(_MasterRepo, _Service);
//#Bonsai Snippets - ServicedRepos
}
GetNewService(IUserRepository repository, string role, ISystemRepository systemRepo = null)
{
var mockUnitOfWork = this.GetNewMockedUnitOfWork(repository);
var mockCache = new Mock <IAppCache>();
mockCache.Setup(c => c.GetAsync <IEnumerable <UserEntity> >(It.IsAny <string>()))
.Returns(Task.FromResult <IEnumerable <UserEntity> >(null));
var mockTokenProvider = new Mock <ITokenProvider>();
mockTokenProvider.Setup(t => t.BuildToken(It.IsAny <UserEntity>(), It.IsAny <string>()))
.Returns(new TokenInfo()
{
Token = "MockedToken", Role = role
});
return(new UserService
(
mockUnitOfWork.Object,
MapperInstance, mockCache.Object,
mockTokenProvider.Object,
systemRepo
),
mockUnitOfWork, mockCache);
}
public SiteService(ILogger <SiteService> logger,
GRA.Abstract.IDateTimeProvider dateTimeProvider,
IUserContextProvider userContextProvider,
IBranchRepository branchRepository,
IProgramRepository programRepository,
ISiteRepository siteRepository,
ISiteSettingRepository siteSettingRepository,
ISpatialDistanceRepository spatialDistanceRepository,
ISystemRepository systemRepository,
SiteLookupService siteLookupService,
IUserRepository userRepository)
: base(logger, dateTimeProvider, userContextProvider)
{
SetManagementPermission(Permission.ManageSites);
_branchRepository = branchRepository
?? throw new ArgumentNullException(nameof(branchRepository));
_programRepository = programRepository
?? throw new ArgumentNullException(nameof(programRepository));
_siteRepository = siteRepository
?? throw new ArgumentNullException(nameof(siteRepository));
_siteSettingRepository = siteSettingRepository
?? throw new ArgumentNullException(nameof(siteSettingRepository));
_spatialDistanceRepository = spatialDistanceRepository
?? throw new ArgumentNullException(nameof(spatialDistanceRepository));
_systemRepository = systemRepository
?? throw new ArgumentNullException(nameof(systemRepository));
_siteLookupService = siteLookupService
?? throw new ArgumentException(nameof(siteLookupService));
_userRepository = userRepository
?? throw new ArgumentNullException(nameof(userRepository));
}
public UnitOfWork(DocumentContext context)
{
_context = context;
Documents = new DocControlRepository(context);
Users = new UserRepository(context);
AuthorizationRepo = new AuthorizationRepository(context);
SystemRepo = new SystemRepository(context);
}
public EnhancementController(IEnhancementRepository repo,
ISystemRepository sys_repo,
IModuleRepository mod_repo)
{
repository = repo;
sys_repository = sys_repo;
mod_repository = mod_repo;
}
public DrinksController(ApplicationDbContext db, ISystemService <DrinkDto> service,
ISystemRepository <DrinkType> typeService,
ISendDataAsync data)
{
_db = new ApplicationDbContext();
_service = service;
_typeService = typeService;
_data = data;
}
/// <summary>
/// Initializes this instance.
/// </summary>
static void Initialize()
{
SystemRepository = Kernel.Get <ISystemRepository>();
ConsoleRepository = Kernel.Get <IConsoleRepository>();
Settings = Kernel.Get <IHyperValidatorSettings>();
HyperSpin = SystemRepository.Get();
ConsoleRepository.GameValidated += ConsoleRepository_GameValidated;
ConsoleRepository.ValidationComplete += ConsoleRepository_ValidationComplete;
}
public SystemController(ISystemRepository systemRepository, IMapper mapper, IUnitOfWork unitOfWork)
{
_SystemRepo = systemRepository ??
throw new ArgumentNullException(nameof(systemRepository));
_mapper = mapper ??
throw new ArgumentNullException(nameof(mapper));
_unitOfWork = unitOfWork ??
throw new ArgumentNullException(nameof(unitOfWork));
}
public SystemConfiguration(ISystemRepository systemRepository)
{
if (systemRepository == null)
{
throw new ArgumentNullException("systemRepository");
}
values = systemRepository.GetSystemValues().ToList();
}
public async Task <IActionResult> Get([FromServices] ISystemRepository systemRepository, [FromQuery(Name = "page")] int page = 1)
{
try
{
return(StatusCode(200, systemRepository.GetAllAsync(page).GetAwaiter().GetResult()));
} catch
{
return(StatusCode(500));
}
}
public BaiduPanService(
IMemoryCache memoryCache,
ISystemRepository systemRepository,
IBaiduPanRepository baiduPanRepository)
: base(baiduPanRepository)
{
_baiduPanRepository = baiduPanRepository;
_memoryCache = memoryCache;
_systemRepository = systemRepository;
}
public RegistrationsAchieversReport(ILogger <RegistrationsAchieversReport> logger,
ServiceFacade.Report serviceFacade,
IBranchRepository branchRepository,
ISystemRepository systemRepository,
IUserRepository userRepository) : base(logger, serviceFacade)
{
_branchRepository = branchRepository
?? throw new ArgumentNullException(nameof(branchRepository));
_userRepository = userRepository
?? throw new ArgumentNullException(nameof(userRepository));
}
GetNewService(ISystemRepository repository)
{
var mockUnitOfWork = this.GetNewMockedUnitOfWork(repository);
var mockCache = new Mock <IAppCache>();
mockCache.Setup(c => c.GetAsync <IEnumerable <SystemEntity> >(It.IsAny <string>()))
.Returns(Task.FromResult <IEnumerable <SystemEntity> >(null));
return(new SystemService(mockUnitOfWork.Object, MapperInstance, mockCache.Object), mockUnitOfWork, mockCache);
}
public ValueMapsController(ISystemRepository sr, IValueMapsRepository vmr, IEmailSender es, IRedisServiceHelper redisService, IMemoryCache mCache, IDistributedCache discache)
{
systemRepository = sr;
valuemapsRepository = vmr;
emailSender = es;
_redisService = redisService;
memoryCache = mCache;
distcache = discache;
//rabbitmq = rabbit;
////redisCache=rc;
//_publisher = icp;
}
protected RedisCacheStore(bool isEnabled)
: base(isEnabled)
{
var systemRepositories = ServiceLocator.GetMany <Lazy <ISystemRepository, ServerTypeMetaData> >().ToList();
Repository = systemRepositories.GetLazyItem();
CacheConfiguration.Instance.OnDataCacheSettingChanged += OnDataCacheConfigurationChanged;
if (isEnabled)
{
ExecuteRestoreCacheDataJob();
}
}
public UserService(ILogger <UserService> logger,
IUserContextProvider userContextProvider,
GRA.Abstract.IPasswordValidator passwordValidator,
IAuthorizationCodeRepository authorizationCodeRepository,
IBadgeRepository badgeRepository,
IBookRepository bookRepository,
IBranchRepository branchRepository,
IMailRepository mailRepository,
INotificationRepository notificationRepository,
IPrizeWinnerRepository prizeWinnerRepository,
IProgramRepository programRepository,
IRequiredQuestionnaireRepository requireQuestionnaireRepository,
IRoleRepository roleRepository,
ISchoolRepository schoolRepository,
ISiteRepository siteRepository,
IStaticAvatarRepository staticAvatarRepository,
ISystemRepository systemRepository,
IUserLogRepository userLogRepository,
IUserRepository userRepository,
IVendorCodeRepository vendorCodeRepository,
ActivityService activityService,
SampleDataService configurationService,
SchoolService schoolService)
: base(logger, userContextProvider)
{
_passwordValidator = Require.IsNotNull(passwordValidator, nameof(passwordValidator));
_authorizationCodeRepository = Require.IsNotNull(authorizationCodeRepository,
nameof(authorizationCodeRepository));
_badgeRepository = Require.IsNotNull(badgeRepository, nameof(badgeRepository));
_bookRepository = Require.IsNotNull(bookRepository, nameof(bookRepository));
_branchRepository = Require.IsNotNull(branchRepository, nameof(branchRepository));
_mailRepository = Require.IsNotNull(mailRepository, nameof(mailRepository));
_notificationRepository = Require.IsNotNull(notificationRepository,
nameof(notificationRepository));
_prizeWinnerRepository = Require.IsNotNull(prizeWinnerRepository,
nameof(prizeWinnerRepository));
_programRepository = Require.IsNotNull(programRepository, nameof(programRepository));
_requireQuestionnaireRepository = Require.IsNotNull(requireQuestionnaireRepository,
nameof(requireQuestionnaireRepository));
_roleRepository = Require.IsNotNull(roleRepository, nameof(roleRepository));
_schoolRepository = Require.IsNotNull(schoolRepository, nameof(schoolRepository));
_siteRepository = Require.IsNotNull(siteRepository, nameof(siteRepository));
_staticAvatarRepository = Require.IsNotNull(staticAvatarRepository,
nameof(staticAvatarRepository));
_systemRepository = Require.IsNotNull(systemRepository, nameof(systemRepository));
_userLogRepository = Require.IsNotNull(userLogRepository, nameof(userLogRepository));
_userRepository = Require.IsNotNull(userRepository, nameof(userRepository));
_vendorCodeRepository = Require.IsNotNull(vendorCodeRepository, nameof(vendorCodeRepository));
_activityService = Require.IsNotNull(activityService, nameof(activityService));
_configurationService = Require.IsNotNull(configurationService,
nameof(configurationService));
_schoolService = Require.IsNotNull(schoolService, nameof(schoolService));
}
public void CoverageNotifications()
{
try
{
//if (systemRepository == null)
//{
systemRepository = new SystemDataImpl();
//}
LogTraceEngine.WriteLogWithCategory("Coverage Notification service Called Step 1 ", AppVariables.AppLogTraceCategoryName.NotificationListener);
if (systemRepository.CoverageNotificationTimeSetting() != null) //Get Time Slot settings
{
LogTraceEngine.WriteLogWithCategory("Coverage Notification service Called Time Matched with TimeSettings ", AppVariables.AppLogTraceCategoryName.NotificationListener);
//If time slot gets in current time
var notifications = SystemRepository.GetCoverageNotificationService(); //Execute Procedure to generate Notification Data
AndroiddNotificationManager pushNotifier = new AndroiddNotificationManager();
List <CoverageNotificationService> CoverageNotification = new List <CoverageNotificationService>();
if (notifications != null && notifications.Count > 0)
{
LogTraceEngine.WriteLogWithCategory("Coverage Notification started pushing notification to users ", AppVariables.AppLogTraceCategoryName.NotificationListener);
foreach (var notification in notifications)
{
if (!String.IsNullOrEmpty(notification.AndroidID))
{
string response = pushNotifier.SendNotification("\"" + notification.AndroidID + "\"", "Coverage Notification~" + notification.PushNotificationMessage, 1); //Send for Notification
if (!String.IsNullOrEmpty(response) && response.Contains("id"))
{
response = String.Format("Success Coverage Notification Status For UserID: {0} of Notification Date {1},{2}", notification.UserID, DateTime.Now.ToString(), response);
CoverageNotification.Add(GenerateCoverageNotificationResponse(true, false, notification.CoverageNotificationServiceID, "Success: " + response));
}
else
{
if (response != null)
{
response = String.Format("Failure Coverage Notification Status For UserID: {0} of Notification Date {1},{2}", notification.UserID, DateTime.Now.ToString(), response);
}
CoverageNotification.Add(GenerateCoverageNotificationResponse(true, false, notification.CoverageNotificationServiceID, "Success: " + response));
}
}
}
LogTraceEngine.WriteLogWithCategory("Coverage Notification End pushing notification to users ", AppVariables.AppLogTraceCategoryName.NotificationListener);
SystemRepository.UpdateCoverageNotificationServiceResponse(CoverageNotification);
}
}
}
catch (Exception ex)
{
LogTraceEngine.WriteLogWithCategory("Coverage Notification service Called and exception occured : Database string : " + dataAccess.ConnectionString + " " + ex.Message, AppVariables.AppLogTraceCategoryName.NotificationListener);
}
}
public TriggerService(ILogger <TriggerService> logger,
IUserContextProvider userContextProvider,
IBranchRepository branchRepository,
IProgramRepository programRepository,
ISystemRepository systemRepository,
ITriggerRepository triggerRepository) : base(logger, userContextProvider)
{
SetManagementPermission(Permission.ManageTriggers);
_branchRepository = Require.IsNotNull(branchRepository, nameof(branchRepository));
_programRepository = Require.IsNotNull(programRepository, nameof(programRepository));
_systemRepository = Require.IsNotNull(systemRepository, nameof(systemRepository));
_triggerRepository = Require.IsNotNull(triggerRepository, nameof(triggerRepository));
}
public VendorCodeReport(ILogger <TopScoresReport> logger,
Domain.Report.ServiceFacade.Report serviceFacade,
IBranchRepository branchRepository,
ISystemRepository systemRepository,
IVendorCodeRepository vendorCodeRepository) : base(logger, serviceFacade)
{
_branchRepository = branchRepository
?? throw new ArgumentException(nameof(branchRepository));
_systemRepository = systemRepository
?? throw new ArgumentException(nameof(systemRepository));
_vendorCodeRepository = vendorCodeRepository
?? throw new ArgumentException(nameof(vendorCodeRepository));
}
public PrizeRedemptionReport(ILogger <PrizeRedemptionReport> logger,
Domain.Report.ServiceFacade.Report serviceFacade,
IBranchRepository branchRepository,
IPrizeWinnerRepository prizeWinnerRepository,
ISystemRepository systemRepository) : base(logger, serviceFacade)
{
_branchRepository = branchRepository
?? throw new ArgumentException(nameof(branchRepository));
_prizeWinnerRepository = prizeWinnerRepository
?? throw new ArgumentNullException(nameof(prizeWinnerRepository));
_systemRepository = systemRepository
?? throw new ArgumentException(nameof(systemRepository));
}
private bool ProcessGeoTagUnFreezFile(DataTable ExcelData, int modulecode)
{
systemRepositoryInstance = SystemRepositoryInstance;
List <string> StoreCode = (from r in ExcelData.AsEnumerable()
select r.Field <string>("StoreCode")).ToList();
var result = systemRepositoryInstance.ValidateStoreCode(StoreCode);
ErrorType = result.Count() == 0 ? ErrorType : 6;
return(ErrorType == 0 ? systemRepositoryInstance.UnfreezeGeoTag(StoreCode) : false);
}
public SystemService(
IUnitOfWork unitOfWork,
IRepository<Document> documentRepository,
IRepository<LookUp> lookUpRepository,
IRepository<XUser> userepository,
ISystemRepository customSystemRepository,
IUserRepository customUserRepository,
IStoreRepository customStorerRepository)
{
_unitOfWork = unitOfWork;
_customSystemRepository = customSystemRepository;
_customUserRepository = customUserRepository;
_documentRepository = documentRepository;
_lookUpRepository = lookUpRepository;
_userepository = userepository;
}
public Login(IKernel kernal)
{
this.SuspendLayout();
//
// Login
//
this.ClientSize = new System.Drawing.Size(284, 261);
this.MinimizeBox = false;
this.Name = "Login";
this.ResumeLayout(false);
Kernal = kernal;
SystemRepository = Kernal.Get<SystemRepository>();
InitializeComponent();
tbUsername.Text = Properties.Settings.Default.sStoredUsername;
tbPassword.Text = Properties.Settings.Default.sStoredPassword;
}
public SystemService(ISystemRepository systemRepository)
{
_systemRepository = systemRepository;
}
public ResourceController(IProjectRepository projectRepo, ISystemRepository systemRepo)
{
_projectRepo = projectRepo;
_systemRepo = systemRepo;
}
public ProjectService(IUnitOfWork unitOfWork, IProjectRepository projectRepo, ISystemRepository systemRepo)
{
_projectRepo = projectRepo;
_systemRepo = systemRepo;
_uow = unitOfWork;
}
public systemController(IManageRepository _manageRepository, ISystemRepository _systemrepository)
{
manageService = new ManageService(_manageRepository);
systemService = new SystemService(_systemrepository);
}