Example #1
0
        /// <summary>
        /// Constructor
        /// </summary>
        public OpportunityService(
            ILogger <OpportunityService> logger,
            IOptionsMonitor <AppOptions> appOptions,
            IUserProfileRepository userProfileRepository,
            IIndustryRepository industryRepository,
            IRegionRepository regionRepository,
            IOpportunityRepository opportunityRepository,
            OpportunityHelpers opportunityHelpers,
            IOpportunityFactory opportunityFactory,
            IAuthorizationService authorizationService,
            IPermissionRepository permissionRepository,
            IUserContext userContext,
            UserProfileHelpers userProfileHelpers) : base(logger, appOptions)

        {
            Guard.Against.Null(opportunityRepository, nameof(opportunityRepository));
            Guard.Against.Null(opportunityHelpers, nameof(opportunityHelpers));
            Guard.Against.Null(userProfileHelpers, nameof(userProfileHelpers));
            Guard.Against.Null(authorizationService, nameof(authorizationService));
            Guard.Against.Null(permissionRepository, nameof(permissionRepository));
            Guard.Against.Null(userContext, nameof(userContext));

            _userProfileRepository = userProfileRepository;
            _industryRepository    = industryRepository;
            _regionRepository      = regionRepository;
            _opportunityRepository = opportunityRepository;
            _opportunityHelpers    = opportunityHelpers;
            _userProfileHelpers    = userProfileHelpers;
            _opportunityFactory    = opportunityFactory;
            _authorizationService  = authorizationService;
            _permissionRepository  = permissionRepository;
            _userContext           = userContext;
        }
 public CreateJobAgeCommandHandler(IIndustryRepository repository, IUnitOfWork unitOfWork, IMapper mapper, IAuthenticatedUserService authenticatedUser)
 {
     _repository        = repository;
     _unitOfWork        = unitOfWork;
     _mapper            = mapper;
     _authenticatedUser = authenticatedUser;
 }
 public IndustryService(
     ILogger <IndustryService> logger,
     IOptions <AppOptions> appOptions,
     IIndustryRepository industryRepository) : base(logger, appOptions)
 {
     Guard.Against.Null(industryRepository, nameof(industryRepository));
     _industryRepository = industryRepository;
 }
 public GetCategoryByIdQueryHandler(IIndustryRepository industryRepository, ICompanyIndustryRepository companyIndustryRepository, ICompanyRepository repository, IPlaceRepository placeRepository, IMapper mapper)
 {
     _repository                = repository;
     _mapper                    = mapper;
     _placeRepository           = placeRepository;
     _companyIndustryRepository = companyIndustryRepository;
     _industryRepository        = industryRepository;
 }
Example #5
0
 public TradersController(
     NesterServices nesterServices,
     ILogger <TradersController> logger,
     IIndustryRepository repo,
     UserManager <Trader> userManager)
     : base(nesterServices, logger, repo, userManager)
 {
 }
        public IndustryController(IIndustryRepository repository, string catalog, LoginView view)
        {
            this._LoginId  = view.LoginId.ToLong();
            this._UserId   = view.UserId.ToInt();
            this._OfficeId = view.OfficeId.ToInt();
            this._Catalog  = catalog;

            this.IndustryRepository = repository;
        }
Example #7
0
 public GetCategoryByIdQueryHandler(IIndustryRepository industryRepository, ICompanyIndustryRepository companyIndustryRepository, ICompanyRepository repository, IAuthenticatedUserService authenticatedUser, IPlaceRepository placeRepository, IMapper mapper)
 {
     _repository                = repository;
     _mapper                    = mapper;
     _placeRepository           = placeRepository;
     _authenticatedUser         = authenticatedUser;
     _companyIndustryRepository = companyIndustryRepository;
     _industryRepository        = industryRepository;
 }
        public IndustryController(IIndustryRepository repository, string catalog, LoginView view)
        {
            this._LoginId = view.LoginId.ToLong();
            this._UserId = view.UserId.ToInt();
            this._OfficeId = view.OfficeId.ToInt();
            this._Catalog = catalog;

            this.IndustryRepository = repository;
        }
Example #9
0
 public CompanyController(IIndustryRepository industryRepository, ICountryRepository countryRepository, IStateRepository stateRepository, ICompanyOwnerRepository companyownerRepository, ICompanyStatusCategoryRepository companystatuscategoryRepository, IUserRepository userRepository, ICompanyRepository companyRepository)
 {
     this.industryRepository = industryRepository;
     this.countryRepository = countryRepository;
     this.stateRepository = stateRepository;
     this.companyownerRepository = companyownerRepository;
     this.companystatuscategoryRepository = companystatuscategoryRepository;
     this.userRepository = userRepository;
     this.companyRepository = companyRepository;
 }
Example #10
0
 public VendorsController(IIndustryRepository industryRepository, ICompanyOwnerRepository companyownerRepository, IVendorLegalCompanyStructureCategoryRepository vendorlegalcompanystructurecategoryRepository, ICountryRepository countryRepository, IStateRepository stateRepository, IVendorStatusCategoryRepository vendorstatuscategoryRepository, IUserRepository userRepository, IVendorRepository vendorRepository)
 {
     this.industryRepository = industryRepository;
     this.companyownerRepository = companyownerRepository;
     this.vendorlegalcompanystructurecategoryRepository = vendorlegalcompanystructurecategoryRepository;
     this.countryRepository = countryRepository;
     this.stateRepository = stateRepository;
     this.vendorstatuscategoryRepository = vendorstatuscategoryRepository;
     this.userRepository = userRepository;
     this.vendorRepository = vendorRepository;
 }
Example #11
0
 /// <summary>
 ///
 /// </summary>
 public CommonController(IOwnerCertificationRecordRepository ownerCertificationRecordRepository,
                         ISmallDistrictRepository smallDistrictRepository,
                         IOwnerRepository ownerRepository,
                         IIndustryRepository industryRepository,
                         ITokenRepository tokenRepository)
 {
     _ownerCertificationRecordRepository = ownerCertificationRecordRepository;
     _smallDistrictRepository            = smallDistrictRepository;
     _ownerRepository    = ownerRepository;
     _industryRepository = industryRepository;
     _tokenRepository    = tokenRepository;
 }
        public BusinessLayer()
        {
            _candRepository    = new CandidateRepository();
            _profileRepository = new ProfileInfoRepository();
            _userRepository    = new UserRepository();
            _roleRepository    = new RoleRepository();

            _candStatusRepository      = new CandidateStatusRepository();
            _searchApplicantRepository = new SearchApplicantRepository();
            _companyRepository         = new CompanyRepository();
            _industryRepository        = new IndustryRepository();
            _userRoleRepository        = new UserRoleRepository();
        }
Example #13
0
 public CustsController(IMyService my, ICustRepository custsRepo, ICityRepository cityRepo,
                        IMainIndustryRepository mainIndustryRepo, IIndustryRepository industryRepo, IPositionRepository positionRepo
                        , IUserRepository userRepo, IContactRepository contactRepo)
 {
     My                = (MyService)my;
     _custRepo         = custsRepo;
     _cityRepo         = cityRepo;
     _mainIndustryRepo = mainIndustryRepo;
     _industryRepo     = industryRepo;
     _positionRepo     = positionRepo;
     _contactRepo      = contactRepo;
     _userRepo         = userRepo;
 }
Example #14
0
 public PermitsController(
     NesterServices nesterServices,
     ILogger <PermitsController> logger,
     IIndustryRepository repo,
     UserManager <Trader> userManager,
     SignInManager <Trader> signInManager,
     IEmailSender emailSender,
     IJwtFactory jwtFactory)
     : base(nesterServices, logger, repo, userManager)
 {
     _signInManager = signInManager;
     _emailSender   = emailSender;
     _jwtFactory    = jwtFactory;
 }
        public IndustryController()
        {
            this._LoginId  = AppUsers.GetCurrent().View.LoginId.ToLong();
            this._UserId   = AppUsers.GetCurrent().View.UserId.ToInt();
            this._OfficeId = AppUsers.GetCurrent().View.OfficeId.ToInt();
            this._Catalog  = AppUsers.GetCurrentUserDB();

            this.IndustryRepository = new MixERP.Net.Schemas.Core.Data.Industry
            {
                _Catalog = this._Catalog,
                _LoginId = this._LoginId,
                _UserId  = this._UserId
            };
        }
Example #16
0
        public IndustryController()
        {
            this._LoginId = AppUsers.GetCurrent().View.LoginId.ToLong();
            this._UserId = AppUsers.GetCurrent().View.UserId.ToInt();
            this._OfficeId = AppUsers.GetCurrent().View.OfficeId.ToInt();
            this._Catalog = AppUsers.GetCurrentUserDB();

            this.IndustryRepository = new MixERP.Net.Schemas.Core.Data.Industry
            {
                _Catalog = this._Catalog,
                _LoginId = this._LoginId,
                _UserId = this._UserId
            };
        }
Example #17
0
 /// <summary>
 ///
 /// </summary>
 public UploadController(
     IUploadRepository uploadRepository,
     ITokenRepository tokenRepository,
     IBuildingRepository buildingRepository,
     IBuildingUnitRepository buildingUnitRepository,
     IIndustryRepository industryRepository,
     IOwnerRepository ownerRepository)
 {
     _uploadRepository       = uploadRepository;
     _tokenRepository        = tokenRepository;
     _buildingRepository     = buildingRepository;
     _buildingUnitRepository = buildingUnitRepository;
     _industryRepository     = industryRepository;
     _ownerRepository        = ownerRepository;
 }
 public BusinessLayer(ICandidateRepository candRepository,
                      IProfileInfoRepository profileRepository,
                      IUserRepository userRepository,
                      IRoleRepository roleRepository,
                      ICandidateStatusRepository candStatusRepository,
                      ICompanyRepository companyRepository,
                      IIndustryRepository industryRepository,
                      IUserRoleRepository userRoleRepository)
 {
     _candRepository       = candRepository;
     _profileRepository    = profileRepository;
     _userRepository       = userRepository;
     _roleRepository       = roleRepository;
     _candStatusRepository = candStatusRepository;
     _companyRepository    = companyRepository;
     _industryRepository   = industryRepository;
     _userRoleRepository   = userRoleRepository;
 }
Example #19
0
 /// <summary>
 ///
 /// </summary>
 public OwnerCertificationRecordController(
     IOwnerCertificationRecordRepository ownerCertificationRecordRepository,
     IOwnerCertificationAnnexRepository ownerCertificationAnnexRepository,
     IOwnerRepository ownerRepository,
     IIndustryRepository industryRepository,
     IIDCardPhotoRecordRepository iDCardPhotoRecordRepository,
     IVipOwnerCertificationRecordRepository vipOwnerCertificationRecordRepository,
     IVipOwnerRepository vipOwnerRepository,
     ITokenRepository tokenRepository)
 {
     _ownerCertificationRecordRepository = ownerCertificationRecordRepository;
     _ownerCertificationAnnexRepository  = ownerCertificationAnnexRepository;
     _ownerRepository                       = ownerRepository;
     _industryRepository                    = industryRepository;
     _iDCardPhotoRecordRepository           = iDCardPhotoRecordRepository;
     _vipOwnerCertificationRecordRepository = vipOwnerCertificationRecordRepository;
     _vipOwnerRepository                    = vipOwnerRepository;
     _tokenRepository                       = tokenRepository;
 }
Example #20
0
 public AdminService(ICompanyRepository companyRepository, IAdminViewModelFactory adminViewModelFactory, IDigitalFileRepository digitalFileRepository,
                     ILookupRepository lookupRepository, IDepartmentRepository departmentRepository, IEmployeeOnBoardRepository employeeOnBoardRepository,
                     IJobTitleRepository jobTitleRepository, ISessionStateService session, IAccountRepository accountRepository,
                     IIndustryRepository industryRepository, IUsersRepository usersRepository, IDigitalFileService digitalFileService,
                     IGenerateDocumentService generateDocumentService)
 {
     this.companyRepository     = companyRepository;
     this.adminViewModelFactory = adminViewModelFactory;
     this.lookupRepository      = lookupRepository;
     this.departmentRepository  = departmentRepository;
     this.jobTitleRepository    = jobTitleRepository;
     this.industryRepository    = industryRepository;
     this.usersRepository       = usersRepository;
     this.session                   = session;
     this.accountRepository         = accountRepository;
     this.digitalFileService        = digitalFileService;
     this.generateDocumentService   = generateDocumentService;
     this.employeeOnBoardRepository = employeeOnBoardRepository;
     this.digitalFileRepository     = digitalFileRepository;
 }
        public RegistrationController(ICompanyRepository companyRepository, IUserRepository userRepository,
                                      IInquiryRepository inquiryRepository, ICityRepository cityRepository, IIndustryRepository industryRepository,
                                      IEmailTemplateRepository emailTemplateRepository)
        {
            if (companyRepository == (ICompanyRepository)null)
            {
                throw new ArgumentNullException("companyRepository");
            }
            _companyRepository = companyRepository;

            if (userRepository == (IUserRepository)null)
            {
                throw new ArgumentNullException("userRepository");
            }
            _userRepository = userRepository;

            if (inquiryRepository == (IInquiryRepository)null)
            {
                throw new ArgumentNullException("inquiryRepository");
            }
            _inquiryRepository = inquiryRepository;

            if (emailTemplateRepository == (IEmailTemplateRepository)null)
            {
                throw new ArgumentNullException("emailTemplateRepository");
            }
            _emailTemplateRepository = emailTemplateRepository;

            if (cityRepository == (ICityRepository)null)
            {
                throw new ArgumentNullException("cityRepository");
            }
            _cityRepository = cityRepository;

            if (industryRepository == (IIndustryRepository)null)
            {
                throw new ArgumentNullException("industryRepository");
            }
            _industryRepository = industryRepository;
        }
Example #22
0
        public HomeController(IUserRepository userRepository, IPurchaseOrderRepository purchaseOrderRepository, ICityRepository cityRepository, IIndustryRepository industryRepository, ICompanyRepository companyRepository, ILicenseDescriptionRepository licenseDescriptionRepository)
        {
            if (userRepository == (IUserRepository)null)
            {
                throw new ArgumentNullException("userRepository");
            }
            _userRepository = userRepository;



            if (purchaseOrderRepository == (ICompanyRepository)null)
            {
                throw new ArgumentNullException("purchaseOrderRepository");
            }
            _purchaseOrderRepository = purchaseOrderRepository;

            if (companyRepository == (ICompanyRepository)null)
            {
                throw new ArgumentNullException("companyRepository");
            }
            _companyRepository = companyRepository;

            if (cityRepository == (ICityRepository)null)
            {
                throw new ArgumentNullException("cityRepository");
            }
            _cityRepository = cityRepository;

            if (industryRepository == (IIndustryRepository)null)
            {
                throw new ArgumentNullException("industryRepository");
            }
            _industryRepository = industryRepository;

            if (licenseDescriptionRepository == (ILicenseDescriptionRepository)null)
            {
                throw new ArgumentNullException("licenseDescriptionRepository");
            }
            _licenseDescriptionRepository = licenseDescriptionRepository;
        }
Example #23
0
        /// <summary>
        /// Constructor
        /// </summary>
        public OpportunityService(
            ILogger <OpportunityService> logger,
            IOptions <AppOptions> appOptions,
            IUserProfileRepository userProfileRepository,
            IIndustryRepository industryRepository,
            IRegionRepository regionRepository,
            IOpportunityRepository opportunityRepository,
            OpportunityHelpers opportunityHelpers,
            UserProfileHelpers userProfileHelpers) : base(logger, appOptions)

        {
            Guard.Against.Null(opportunityRepository, nameof(opportunityRepository));
            Guard.Against.Null(opportunityHelpers, nameof(opportunityHelpers));
            Guard.Against.Null(userProfileHelpers, nameof(userProfileHelpers));

            _userProfileRepository = userProfileRepository;
            _industryRepository    = industryRepository;
            _regionRepository      = regionRepository;
            _opportunityRepository = opportunityRepository;
            _opportunityHelpers    = opportunityHelpers;
            _userProfileHelpers    = userProfileHelpers;
        }
		public ChecklistController(IDependencyFactory dependencyFactory)
		{
			_checklistRepository = dependencyFactory.GetInstance<ICheckListRepository>();
			_questionRepository = dependencyFactory.GetInstance<IQuestionRepository>();
			_questionResponseRepository = dependencyFactory.GetInstance<IQuestionResponseRepository>();
			_clientDetailsService = dependencyFactory.GetInstance<IClientDetailsService>();
			_getChecklistsQuery = dependencyFactory.GetInstance<IGetChecklistsQuery>();
			_checklistQuestionRepository = dependencyFactory.GetInstance<IChecklistQuestionRepository>();
			_employeeRespository = dependencyFactory.GetInstance<IEmployeeRepository>();
			_impressionRespository = dependencyFactory.GetInstance<IImpressionTypeRepository>();
			_categoryRepository = dependencyFactory.GetInstance<ICategoryRepository>();
			_timescaleRepository = dependencyFactory.GetInstance<ITimescaleRepository>();
			_userForAuditingRepository = dependencyFactory.GetInstance<IUserForAuditingRepository>();
			_siteRepository = dependencyFactory.GetInstance<ISiteRepository>();
			_checklistPdfCreator = dependencyFactory.GetInstance<IChecklistPdfCreator>();
			_clientDocumentationChecklistPdfWriter =
				dependencyFactory.GetInstance<IClientDocumentationChecklistPdfWriter>();
			_log = dependencyFactory.GetInstance<IPeninsulaLog>();
			_qaAdvisorRepository = dependencyFactory.GetInstance<IQaAdvisorRepository>();
            _industryRepository = dependencyFactory.GetInstance<IIndustryRepository>();
		    _bus = dependencyFactory.GetInstance<IBus>();
		}
Example #25
0
 /// <summary>
 ///
 /// </summary>
 public OrderController(
     IOwnerCertificationRecordRepository ownerCertificationRecordRepository,
     IOrderRepository orderRepository,
     IShopUserAddressRepository shopUserAddressRepository,
     IOrdeItemRepository ordeItemRepository,
     IUserRepository userRepository,
     ISmallDistrictRepository smallDistrictRepository,
     ITokenRepository tokenRepository,
     IIndustryRepository industryRepository,
     IWeiXinUserRepository weiXinUserRepository,
     IActivityRepository activityRepository)
 {
     _tokenRepository = tokenRepository;
     _orderRepository = orderRepository;
     _ownerCertificationRecordRepository = ownerCertificationRecordRepository;
     _shopUserAddressRepository          = shopUserAddressRepository;
     _ordeItemRepository      = ordeItemRepository;
     _userRepository          = userRepository;
     _smallDistrictRepository = smallDistrictRepository;
     _industryRepository      = industryRepository;
     _weiXinUserRepository    = weiXinUserRepository;
     _activityRepository      = activityRepository;
 }
 public BusinessDivisionsController(IIndustryRepository industryRepository, IBusinessDivisionRepository businessdivisionRepository)
 {
     this.industryRepository = industryRepository;
     this.businessdivisionRepository = businessdivisionRepository;
 }
Example #27
0
        public FiefType(
            IBaseEntityRepository <Market> marketRepository,
            IBaseEntityRepository <Steward> stewardRepository,
            IBaseEntityRepository <Port> portRepository,
            IBaseEntityRepository <Livingcondition> livingconditionRepository,
            IBaseEntityRepository <Road> roadRepository,
            IBaseEntityRepository <Inheritance> inheritanceRepository,
            IBaseEntityRepository <Village> villageRepository,
            IIndustryRepository industryRepository,
            IBaseEntityRepository <Building> buildingRepository,
            IBaseEntityRepository <Resident> residentRepository,
            IBaseEntityRepository <Soldier> soldierRepository,
            IBaseEntityRepository <Employee> employeeRepository,
            IBaseEntityRepository <Builder> builderRepository
            )
        {
            Field(_ => _.Id);
            Field(_ => _.GamesessionId);
            Field(_ => _.UserId);
            Field(_ => _.Name);
            Field(_ => _.ManorName);
            Field(_ => _.Acres);
            Field(_ => _.FarmlandAcres);
            Field(_ => _.PastureAcres);
            Field(_ => _.WoodlandAcres);
            Field(_ => _.FellingAcres);
            Field(_ => _.UnusableAcres);
            Field(_ => _.LivingconditionId);
            Field(_ => _.RoadId);
            Field(_ => _.InheritanceId);
            Field(_ => _.BuildingIds);
            Field(_ => _.SoldierIds);
            Field(_ => _.EmployeeIds);
            Field(_ => _.StewardId, nullable: true);
            Field(_ => _.PortId, nullable: true);
            Field(_ => _.MarketId, nullable: true);
            Field(_ => _.VillageIds);
            Field(_ => _.ResidentIds);
            Field(_ => _.BuilderIds);


            FieldAsync <MarketType, Market>(
                "market",
                resolve: async context =>
            {
                return(await marketRepository.GetByIdAsync(context.Source.MarketId));
            }
                );
            FieldAsync <StewardType, Steward>(
                "steward",
                resolve: async context =>
            {
                return(await stewardRepository.GetByIdAsync(context.Source.StewardId));
            }
                );
            FieldAsync <PortType, Port>(
                "port",
                resolve: async context =>
            {
                return(await portRepository.GetByIdAsync(context.Source.PortId));
            }
                );
            FieldAsync <LivingconditionType, Livingcondition>(
                "livingcondition",
                resolve: async context =>
            {
                return(await livingconditionRepository.GetByIdAsync(context.Source.LivingconditionId));
            }
                );
            FieldAsync <RoadType, Road>(
                "road",
                resolve: async context =>
            {
                return(await roadRepository.GetByIdAsync(context.Source.RoadId));
            }
                );
            FieldAsync <InheritanceType, Inheritance>(
                "inheritance",
                resolve: async context =>
            {
                return(await inheritanceRepository.GetByIdAsync(context.Source.InheritanceId));
            }
                );
            FieldAsync <ListGraphType <VillageType>, ICollection <Village> >(
                "villages",
                resolve: async context =>
            {
                return(await villageRepository.GetListAsync(context.Source.VillageIds));
            }
                );
            FieldAsync <ListGraphType <IndustryType>, ICollection <Industry> >(
                "industries",
                resolve: async context =>
            {
                return(await industryRepository.GetIndustriesForFief(context.Source.Id));
            }
                );
            FieldAsync <ListGraphType <BuildingType>, ICollection <Building> >(
                "buildings",
                resolve: async context =>
            {
                return(await buildingRepository.GetListAsync(context.Source.BuildingIds));
            }
                );
            FieldAsync <ListGraphType <ResidentType>, ICollection <Resident> >(
                "residents",
                resolve: async context =>
            {
                return(await residentRepository.GetListAsync(context.Source.ResidentIds));
            }
                );
            FieldAsync <ListGraphType <SoldierType>, ICollection <Soldier> >(
                "soldiers",
                resolve: async context =>
            {
                return(await soldierRepository.GetListAsync(context.Source.SoldierIds));
            }
                );
            FieldAsync <ListGraphType <EmployeeType>, ICollection <Employee> >(
                "employees",
                resolve: async context =>
            {
                return(await employeeRepository.GetListAsync(context.Source.EmployeeIds));
            }
                );
            FieldAsync <ListGraphType <BuilderType>, ICollection <Builder> >(
                "builders",
                resolve: async context =>
            {
                return(await builderRepository.GetListAsync(context.Source.BuilderIds));
            }
                );
        }
Example #28
0
 public IndustryServices(IIndustryRepository industryRepository,
                         IIndustryViewModelFactory industryViewModelFactory)
 {
     this.industryViewModelFactory = industryViewModelFactory;
     this.industryRepository       = industryRepository;
 }
 public IndustryController()
 {
     _industryRepository = ObjectFactory.GetInstance<IIndustryRepository>();
 }
 public GetCategoryByIdQueryHandler(IIndustryRepository repository, IMapper mapper)
 {
     _repository = repository;
     _mapper     = mapper;
 }
 public SpecializedService(ISpecializedRepository ispecializedRepository,
                           IIndustryRepository iIndustryRepository)
 {
     _ispecializedRepository = ispecializedRepository;
     _iIndustryRepository    = iIndustryRepository;
 }
Example #32
0
 public IndustryController(IIndustryRepository industryRepository)
 {
     this.industryRepository = industryRepository;
 }
 public void IndustryInitialize()
 {
     _industryRepository = new IndustryRepository(new Core.Base.Data.SqlServer.Factory.BaseContextFactory <HCRGUniversity.Core.Data.SqlServer.HCRGUniversityDBContext>());
     _IndustryBL         = new IndustryImpl(_industryRepository);
 }
Example #34
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="industryRepository"></param>
 public IndustryController(IIndustryRepository industryRepository)
 {
     _industryRepository = industryRepository;
     _tokenManager       = new TokenManager();
 }
Example #35
0
 public IndustryImpl(IIndustryRepository iindustryRepository)
 {
     _iindustryRepository = iindustryRepository;
 }
Example #36
0
 public IndustryService(IIndustryRepository repo)
 {
     this.repo = repo;
 }
 public GetAllQueryHandler(IIndustryRepository repository)
 {
     _repository = repository;
 }
Example #38
0
 /// <summary>
 ///
 /// </summary>
 public IndustryController(IIndustryRepository industryRepository, ITokenRepository tokenRepository)
 {
     _industryRepository = industryRepository;
     _tokenRepository    = tokenRepository;
 }