public ProposalService(IProposalRepository repository, SystemConfigurations configurations, ICategoryRepository categoryRepository, ISupplierRepository supplierRepository)
{
this.Repository = repository;
this.Configurations = configurations;
this.CategoryRepository = categoryRepository;
this.SupplierRepository = supplierRepository;
}
public ProposalAppService(IProposalRepository proposalRepository, IMapper mapper, IUserService userService, IJobRepository jobRepository)
{
_proposalRepository = proposalRepository;
_mapper = mapper;
_userService = userService;
_jobRepository = jobRepository;
}
public ProposalController(ILogger <ProposalController> logger, IProposalRepository proposalRepository, ProposalContext context)
{
_logger = logger;
_context = context;
_proposalRepository = proposalRepository;
}
public InMemoryMarketProcessor(ISubscriptionRepository subscriptionRepository,
IProposalRepository proposalRepository,
IAgreementRepository agreementRepository)
{
this.SubscriptionRepository = subscriptionRepository;
this.ProposalRepository = proposalRepository;
this.AgreementRepository = agreementRepository;
}
public ProposalController(IProposalRepository repository, IUnitOfWork unitOfWork, UserManager <User> userManager, IAdvertRepository adverRepository, IFeedbackRepository feedbacks)
{
_repository = repository;
_unitOfWork = unitOfWork;
_userManager = userManager;
_adverRepository = adverRepository;
_feedbacks = feedbacks;
}
public ProfessorRepository(IUnitOfWork unitOfWork,
IProposalRepository IProposalRepository,
IStudentRepository IStudentRepository
) : base(unitOfWork)
{
ProposalRepository = IProposalRepository;
StudentRepository = IStudentRepository;
}
public FreelancersController(ApplicationDbContext context = null, IWebHostEnvironment hostingEnvironment = null, IProposalRepository proposalRepository = null, IWalletRepository walletRepository = null)
{
currentUser = RegisterModel.registeredUser;
this.proposalRepository = proposalRepository;
this.walletRepository = walletRepository;
_context = context;
_hostingEnvironment = hostingEnvironment;
}
public static Solution Instance(IProposalRepository repository)
{
if (instance == null)
{
instance = new Solution(repository);
}
return(instance);
}
public SubscribeDemandOperation(ISubscriptionRepository subscriptionRepo,
IProposalRepository proposalRepo,
IDictionary <string, SubscriptionPipeline <DemandSubscription, MarketRequestorEvent> > requestorEventPipelines,
IDictionary <string, string> demandSubscriptions,
IDictionary <string, SubscriptionPipeline <OfferSubscription, MarketProviderEvent> > providerEventPipelines,
IDictionary <string, string> offerSubscriptions)
: base(subscriptionRepo, proposalRepo, null, requestorEventPipelines, demandSubscriptions, providerEventPipelines, offerSubscriptions)
{
}
public ProjectController(IProjectRepository project,
IStudentRepository student,
IProposalRepository proposal,
IHostingEnvironment environment)
{
_projectctx = project;
_studentctx = student;
_proposalctx = proposal;
this.environment = environment;
}
public ProposalService(
ILoggerFactory loggerFactory, IRepository <Proposal> itemRepository, IProposalRepository proposalRepository
)
{
// this._converter = converter;
this._itemRepository = itemRepository;
this._proposalRepository = proposalRepository;
}
public ProposalController(IProposalRepository proposal,
ILecturerRepository lecturer,
IProjectRepository project,
IHostingEnvironment environment)
{
_proposalctx = proposal;
_lecturerctx = lecturer;
_projectx = project;
this.environment = environment;
}
public RpdbService(ICarbrandRepository carbrandRepository,
ICarmodelRepository carmodelRepository,
ICarmodelTypeRepository carmodelTypeRepository,
IProposalRepository proposalRepository)
{
_carbrandRepository = carbrandRepository;
_proposalRepository = proposalRepository;
_carmodelRepository = carmodelRepository;
_carmodelTypeRepository = carmodelTypeRepository;
}
public CancelAgreementOperation(ISubscriptionRepository subscriptionRepo,
IProposalRepository proposalRepo,
IAgreementRepository agreementRepo,
IDictionary <string, SubscriptionPipeline <DemandSubscription, MarketRequestorEvent> > requestorEventPipelines,
IDictionary <string, string> demandSubscriptions,
IDictionary <string, SubscriptionPipeline <OfferSubscription, MarketProviderEvent> > providerEventPipelines,
IDictionary <string, string> offerSubscriptions,
IDictionary <string, BlockingCollection <AgreementResultEnum> > agreementResultPipelines)
: base(subscriptionRepo, proposalRepo, agreementRepo, requestorEventPipelines, demandSubscriptions, providerEventPipelines, offerSubscriptions, agreementResultPipelines)
{
}
// Конструктор
public RequisitionsController(IRequisitionRepository requisitionRepository,
IProposalRepository proposalRepository,
IMachineRepository machineRepository,
IMachineTypeRepository machineTypeRepository,
IReadedNoticeRepository readedNoticeRepository,
IHubContext <NotificationHub> hub)
{
_requisitionRepository = requisitionRepository;
_proposalRepository = proposalRepository;
_machineRepository = machineRepository;
_machineTypeRepository = machineTypeRepository;
_readedNoticeRepository = readedNoticeRepository;
_hub = hub;
} // RequisitionsController
// Конструктор
public NoticesController(IProposalRepository proposalRepository,
IRequisitionRepository requisitionRepository,
IMessageRepository messageRepository,
IReadedNoticeRepository readedNoticeRepository,
UserManager <AppUser> userManager,
IHubContext <NotificationHub> hub)
{
_proposalRepository = proposalRepository;
_requisitionRepository = requisitionRepository;
_messageRepository = messageRepository;
_readedNoticeRepository = readedNoticeRepository;
_hub = hub;
_userManager = userManager;
} // NoticesController
public MarketRequestorApiController(IRequestorMarketProcessor marketProcessor,
ISubscriptionRepository subscriptionRepository,
IProposalRepository proposalRepository,
IAgreementRepository agreementRepository,
MarketRequestorEventMapper requestorEventMapper,
DemandMapper demandMapper,
OfferMapper offerMapper)
{
this.MarketProcessor = marketProcessor;
this.SubscriptionRepository = subscriptionRepository;
this.ProposalRepository = proposalRepository;
this.AgreementRepository = agreementRepository;
this.RequestorEventMapper = requestorEventMapper;
this.DemandMapper = demandMapper;
this.OfferMapper = offerMapper;
}
public SemesterController(ISemesterRepsitory repsitory,
IMapper mapper,
IUnitOfWork unitOfWork,
ISemesterCatagoryRepository catagoryRepository,
IProposalRepository proposalRepository,
IHostingEnvironment host,
IUserRepository userRepository, IOptionsSnapshot <SemesterFile> options)
: base(repsitory, mapper, unitOfWork)
{
_catagoryRepository = catagoryRepository;
_proposalRepository = proposalRepository;
_host = host;
_file = options.Value;
_userRepository = userRepository;
}
// Конструктор
public ProposalsController(IProposalRepository proposalRepository,
IRequisitionRepository requisitionRepository,
IProposalImageRepository proposalImageRepository,
IMachineRepository machineRepository,
IMachineTypeRepository machineTypeRepository,
IReadedNoticeRepository readedNoticeRepository,
IWebHostEnvironment environment,
IHubContext <NotificationHub> hub)
{
_proposalRepository = proposalRepository;
_requisitionRepository = requisitionRepository;
_proposalImageRepository = proposalImageRepository;
_machineRepository = machineRepository;
_machineTypeRepository = machineTypeRepository;
_readedNoticeRepository = readedNoticeRepository;
_environment = environment;
_hub = hub;
} // ProposalsController
public MarketProviderApiController(IProviderMarketProcessor marketProcessor,
ISubscriptionRepository subscriptionRepository,
IProposalRepository proposalRepository,
IAgreementRepository agreementRepository,
MarketProviderEventMapper providerEventMapper,
OfferMapper offerMapper,
DemandMapper demandMapper,
ILogger <MarketProviderApiController> logger)
{
this.MarketProcessor = marketProcessor;
this.SubscriptionRepository = subscriptionRepository;
this.ProposalRepository = proposalRepository;
this.AgreementRepository = agreementRepository;
this.ProviderEventMapper = providerEventMapper;
this.OfferMapper = offerMapper;
this.DemandMapper = demandMapper;
this._logger = logger;
}
public InMemoryMarketOperationBase(
ISubscriptionRepository subscriptionRepo,
IProposalRepository proposalRepo,
IAgreementRepository agreementRepo,
IDictionary <string, SubscriptionPipeline <DemandSubscription, MarketRequestorEvent> > requestorEventPipelines,
IDictionary <string, string> demandSubscriptions,
IDictionary <string, SubscriptionPipeline <OfferSubscription, MarketProviderEvent> > providerEventPipelines,
IDictionary <string, string> offerSubscriptions
)
{
this.SubscriptionRepository = subscriptionRepo;
this.ProposalRepository = proposalRepo;
this.AgreementRepository = agreementRepo;
this.RequestorEventPipelines = requestorEventPipelines;
this.DemandSubscriptions = demandSubscriptions;
this.ProviderEventPipelines = providerEventPipelines;
this.OfferSubscriptions = offerSubscriptions;
}
public PhaseThreeController(
ISectionRepository sectionRepository,
IUserRepository userRepository,
IProposalRepository proposalRepository,
IConferenceRepository conferenceRepository,
IUserSectionRepository userSectionRepository,
IReviewRepository reviewRepository,
IPhaseRepository phaseRepository,
ITopicRepository topicRepository
)
{
SectionRepository = sectionRepository;
UserRepository = userRepository;
ProposalRepository = proposalRepository;
ConferenceRepository = conferenceRepository;
UserSectionRepository = userSectionRepository;
ReviewRepository = reviewRepository;
PhaseRepository = phaseRepository;
TopicRepository = topicRepository;
}
// Конструктор
public UsersController(UserManager <AppUser> userManager,
RoleManager <AppRole> roleManager,
SignInManager <AppUser> signInManager,
IRequisitionRepository requisitionRepository,
IProposalRepository proposalRepository,
IUserImageRepository userImageRepository,
IReadedNoticeRepository readedNoticeRepository,
IWebHostEnvironment environment,
IHubContext <NotificationHub> hub)
{
_userManager = userManager;
_roleManager = roleManager;
_signInManager = signInManager;
_requisitionRepository = requisitionRepository;
_proposalRepository = proposalRepository;
_userImageRepository = userImageRepository;
_readedNoticeRepository = readedNoticeRepository;
_environment = environment;
_hub = hub;
} // UsersController
public UnitOfWork(ApplicationDbContext context,
IAllowedDomainRepository domain,
IRolesRepository roles,
IAccountRepository account,
IEmailSettingRepository emailSetting,
IDepartmentRepository department,
IEmailRepository email,
ISystemSettingsRepository systemsettings,
IProposalRepository proposal)
{
_context = context;
allowedDomains = domain;
EmailSetting = emailSetting;
Roles = roles;
Account = account;
Departments = department;
Email = email;
SystemSettings = systemsettings;
Proposals = proposal;
}
public ProposalController(IConferenceRepository conferenceRepo, IProposalRepository proposalRepo)
{
this.conferenceRepo = conferenceRepo;
this.proposalRepo = proposalRepo;
}
public ProposalService(IMapper mapper)
{
_proposalRepository = new ProposalRepository();
_mapper = mapper;
}
public ProposalController(IProposalRepository proposalRepo, IAppRepository appRepo)
{
_appRepo = appRepo;
_proposalRepo = proposalRepo;
}
public StudentRepository(IUnitOfWork unitOfWork,
IProposalRepository IProposalRepository
) : base(unitOfWork)
{
ProposalRepository = IProposalRepository;
}
public ProposalManager(IProposalRepository proposalRepository, ICommitProvider commitProvider)
{
_proposalRepository = proposalRepository;
_commitProvider = commitProvider;
}
public CollectRequestorEventsOperation(ISubscriptionRepository subscriptionRepo,
IProposalRepository proposalRepo,
IDictionary <string, SubscriptionPipeline <DemandSubscription, MarketRequestorEvent> > requestorEventPipelines)
: base(subscriptionRepo, proposalRepo, null, requestorEventPipelines, null, null, null)
{
}
public ServiceResult ListProposals([FromServices] IProposalRepository proposalRepository)
{
var result = proposalRepository.Get();
return(Mapper.Map <List <ProposalViewModel> >(result).AsServiceResultWithEntity().SetValid());
}