public SponsorExhibitorService(ISponsorExhibitorRepository SponsorExhibitorRepository, ISponsorRepository SponsorRepository, IMapper Mapper)
{
_SponsorExhibitorRepository = SponsorExhibitorRepository;
_SponsorRepository = SponsorRepository;
_Mapper = Mapper;
_mainResponse = new MainResponse();
}
public HomeController(ILogger <HomeController> logger, MyContext context)
{
sponsors = new SponsorRepository(context);
colleagues = new ColleagueRepository(context);
banks = new BankRepository(context);
_logger = logger;
}
public SponsorsPageViewModel(ISponsorRepository sponsorRepository, IVerenigingRepository verenigingRepository, INavigationService navigationService,
IResourceLoader resourceLoader, IAlertMessageService alertMessageService, IEventAggregator eventAggregator)
{
_sponsorRepository = sponsorRepository;
_verenigingRepository = verenigingRepository;
_navigationService = navigationService;
_resourceLoader = resourceLoader;
_alertMessageService = alertMessageService;
_eventAggregator = eventAggregator;
GoBackCommand = new DelegateCommand(_navigationService.GoBack);
indexTimer = new DispatcherTimer();
indexTimer.Interval = TimeSpan.FromSeconds(30);
indexTimer.Tick += indexTimer_Tick;
indexTimer.Start();
if (_eventAggregator != null)
{
_eventAggregator.GetEvent <SponsorUpdatedEvent>().Subscribe(UpdateSponsorsAsync);
}
//WijzigBaanCommand = DelegateCommand.FromAsyncHandler(BaanWijzigen);
UpdateSponsorsAsync(null);
}
public ExhibitorService(IExhibitorRepository exhibitorRepository, IAddressRepository addressRepository,
IExhibitorHorseRepository exhibitorHorseRepository, IHorseRepository horseRepository,
IGroupExhibitorRepository groupExhibitorRepository, IGlobalCodeRepository globalCodeRepository,
IExhibitorClassRepository exhibitorClassRepository, IClassRepository classRepository,
ISponsorExhibitorRepository sponsorExhibitorRepository, ISponsorRepository sponsorRepository,
IScanRepository scanRepository, IExhibitorPaymentDetailRepository exhibitorPaymentDetailRepository,
IApplicationSettingRepository applicationRepository, IEmailSenderRepository emailSenderRepository,
IClassSponsorRepository classSponsorRepository, IMapper mapper, IStallAssignmentRepository stallAssignmentRepository)
{
_exhibitorRepository = exhibitorRepository;
_addressRepository = addressRepository;
_exhibitorHorseRepository = exhibitorHorseRepository;
_horseRepository = horseRepository;
_groupExhibitorRepository = groupExhibitorRepository;
_globalCodeRepository = globalCodeRepository;
_exhibitorClassRepository = exhibitorClassRepository;
_classRepository = classRepository;
_sponsorExhibitorRepository = sponsorExhibitorRepository;
_sponsorRepository = sponsorRepository;
_scanRepository = scanRepository;
_exhibitorPaymentDetailRepository = exhibitorPaymentDetailRepository;
_applicationRepository = applicationRepository;
_emailSenderRepository = emailSenderRepository;
_classSponsorRepository = classSponsorRepository;
_mapper = mapper;
_mainResponse = new MainResponse();
_stallAssignmentRepository = stallAssignmentRepository;
}
public SponsorService(IMapper mapper, IPlayerRepository playerRepository, ISponsorRepository sponsorRepository, ITeamRepository teamRepository, IRugNummerRepository rugnummerRepository)
{
_mapper = mapper;
_playerRepository = playerRepository;
_sponsorRepository = sponsorRepository;
_teamRepository = teamRepository;
_rugnummerRepository = rugnummerRepository;
}
public SponsorService(ISponsorRepository SponsorRepository, IAddressRepository AddressRepository, IMapper Mapper)
{
_SponsorRepository = SponsorRepository;
_AddressRepository = AddressRepository;
_Mapper = Mapper;
_mainResponse = new MainResponse();
newIdResponse = new BaseResponse();
}
public SponsorLogoService(ISponsorRepository sponsorRepository)
{
if (sponsorRepository == null)
{
throw new ArgumentNullException("sponsorRepository");
}
this.sponsorRepository = sponsorRepository;
}
public SponsorLogoService(ISponsorRepository sponsorRepository)
{
if (sponsorRepository == null)
{
throw new ArgumentNullException("sponsorRepository");
}
this.sponsorRepository = sponsorRepository;
}
public static HttpResponseMessage Run(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = "sperrov1/sponsors")] HttpRequestMessage req,
[Inject(typeof(ISponsorRepository))] ISponsorRepository sponsorRepository,
TraceWriter log)
{
log.Info("C# HTTP trigger function processed a request.");
// Fetching the name from the path parameter in the request URL
return(req.CreateResponse(HttpStatusCode.OK, JsonConvert.SerializeObject(sponsorRepository.FindAll())));
}
public InstallationRepository(IDbConnection connection,
ILocationRepository locationRepository,
IAddressRepository addressRepository,
ISponsorRepository sponsorRepository)
{
_connection = connection;
_locationRepository = locationRepository;
_addressRepository = addressRepository;
_sponsorRepository = sponsorRepository;
}
public SponsorDistributionService(ISponsorExhibitorRepository SponsorExhibitorRepository, ISponsorDistributionRepository
SponsorDistributionRepository, ISponsorRepository SponsorRepository,
IGlobalCodeRepository GlobalCodeRepository, IMapper Mapper)
{
_SponsorDistributionRepository = SponsorDistributionRepository;
_SponsorExhibitorRepository = SponsorExhibitorRepository;
_SponsorRepository = SponsorRepository;
_GlobalCodeRepository = GlobalCodeRepository;
_Mapper = Mapper;
_mainResponse = new MainResponse();
}
public SponsorService(
ILogger <SponsorService> logger,
EventManagementDbContext context,
ISponsorRepository repository,
IMapper mapper)
{
this.logger = logger;
this.context = context;
this.repository = repository;
this.mapper = mapper;
}
public SponsorController(ISponsorRepository sponsorRepository, ISponsorSorter sponsorSorter)
{
if (sponsorRepository == null)
{
throw new ArgumentNullException("sponsorRepository");
}
if (sponsorSorter == null)
{
throw new ArgumentNullException("sponsorSorter");
}
this.sponsorRepository = sponsorRepository;
this.sponsorSorter = sponsorSorter;
}
public SponsorController(ISponsorRepository sponsorRepository, ISponsorSorter sponsorSorter)
{
if (sponsorRepository == null)
{
throw new ArgumentNullException("sponsorRepository");
}
if (sponsorSorter == null)
{
throw new ArgumentNullException("sponsorSorter");
}
this.sponsorRepository = sponsorRepository;
this.sponsorSorter = sponsorSorter;
}
public UsersController(
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IOptions <ApplicationSettings> appSettings,
ISponsorRepository sponsorRepository,
IMapper mapper,
IConfiguration configuration)
{
_userManager = userManager;
_signInManager = signInManager;
_sponsorRepo = sponsorRepository;
_mapper = mapper;
_appSettings = appSettings.Value;
Configuration = configuration;
}
public HttpResponseMessage Reorder(int conferenceId)
{
var raw = new StreamReader(HttpContext.Current.Request.InputStream).ReadToEnd();
var data = JsonConvert.DeserializeObject <List <Order> >(raw);
ISponsorRepository _repository = SponsorRepository.Instance;
foreach (Order no in data)
{
var sponsor = _repository.GetSponsor(no.id);
if (sponsor != null)
{
sponsor.ViewOrder = no.order;
_repository.UpdateSponsor(sponsor.GetSponsorBase(), UserInfo.UserID);
}
}
return(Request.CreateResponse(HttpStatusCode.OK, ""));
}
public static HttpResponseMessage Run([HttpTrigger(AuthorizationLevel.Function, "post", Route = "sperrov1/pendingsponsor")] HttpRequestMessage req,
[Inject(typeof(ISponsorRepository))] ISponsorRepository sponsorRepository,
TraceWriter log)
{
log.Info("C# HTTP trigger function processed a request.");
string jsonContent = req.Content.ReadAsStringAsync().Result;
Sponsor sponsor = JsonConvert.DeserializeObject <Sponsor>(jsonContent);
sponsor.Status = SponsorStatus.Pending;
sponsorRepository.Create(sponsor);
// Fetching the name from the path parameter in the request URL
return(req.CreateResponse(HttpStatusCode.OK));
}
public ContentService(TFContext context, IGenericRepository<Award> repoAward, INominatieRepository repoNominatie, ISponsorRepository repoSponsor, INieuwsItemRepository repoNieuwsItem, IGenericRepository<Setup> repoSetup,
IGenericRepository<Contact> repoContact , IGenericRepository<HallOfFame> repoHallOfFame , IGenericRepository<Home> repoHome , IGenericRepository<JuryLid> repoJuryLid , IGenericRepository<Page> repoPage ,
IJuryKeuzeRepository repoJuryKeuze, IGenericRepository<FlickrAlbum> repoFlickr, IUOW uow)
{
this.context = context;
this.repoAward = repoAward;
this.repoNominatie = repoNominatie;
this.repoSponsor = repoSponsor;
this.repoNieuwsItem = repoNieuwsItem;
this.repoSetup = repoSetup;
this.repoContact = repoContact;
this.repoHallOfFame = repoHallOfFame;
this.repoHome = repoHome;
this.repoJuryLid = repoJuryLid;
this.repoPage = repoPage;
this.repoJuryKeuze = repoJuryKeuze;
this.uow = uow;
this.repoFlickr = repoFlickr;
}
public void TestInitialize()
{
_mockRepository = new MockRepository();
_mockRepo = _mockRepository.StrictMock<ISponsorRepository>();
}
public SponsorsAdminController(ISponsorRepository sponsorRepository)
{
_sponsorRepository = sponsorRepository;
}
public Context()
{
sponsorRepository = new InMemorySponsorRepository();
allPublicSponsors = new AllPublicSponsors(sponsorRepository, new DefaultSponsorSorter());
}
public SponsorController(MyContext context)
{
sponsors = new SponsorRepository(context);
colleagues = new ColleagueRepository(context);
}
internal Sponsor(ISponsorRepository repository)
{
_repository = repository;
}
public ContentController(ISponsorRepository sponsorsRepository, IWaitListHelper waitListHelper)
{
_sponsorRepository = sponsorsRepository;
_waitListHelper = waitListHelper;
}
public SponsorService(ISponsorRepository sponsorRepository)
{
this.sponsorRepository = sponsorRepository;
}
public Sponsor()
{
_repository = new StructureMapDependencyResolver().GetConcreteInstanceOf<ISponsorRepository>();
}
public SponsorApplication(ISponsorRepository sponsorRepository, IFileUploader fileUploader)
{
_sponsorRepository = sponsorRepository;
_fileUploader = fileUploader;
}
public SponsorService(ISponsorRepository repo)
{
_repo = repo;
}
public SponsorTransactionController(IHostingEnvironment hostingEnvironment, MyContext context)
{
sponsors = new SponsorRepository(context);
colleages = new ColleagueRepository(context);
_hostingEnvironment = hostingEnvironment;
}
public SponsorsAdminController(ISponsorRepository sponsorRepository)
{
_sponsorRepository = sponsorRepository;
}
public ContentController(ISponsorRepository sponsorsRepository, IWaitListHelper waitListHelper)
{
_sponsorRepository = sponsorsRepository;
_waitListHelper = waitListHelper;
}
public void TestCleanup()
{
_mockRepo = null;
}
public SponsorController(ISponsorRepository repository)
{
Requires.NotNull(repository);
_repository = repository;
}
public DetailsColleagueTable(MyContext context)
{
sponsors = new SponsorRepository(context);
colleages = new ColleagueRepository(context);
}
public UpdateSponsorCommandHandler(ISponsorRepository repository)
{
_repository = repository;
}
public Context()
{
sponsorRepository = new InMemorySponsorRepository();
allPublicSponsors = new AllPublicSponsors(sponsorRepository, new DefaultSponsorSorter());
}
public SponsorController(ISponsorRepository SponsorServices)
{
_SponsorServices = SponsorServices;
}
public void Setup()
{
_sponsorRepository = Substitute.For <ISponsorRepository>();
_waitListHelper = Substitute.For <IWaitListHelper>();
}
/// <summary>
/// SponsorController
/// </summary>
public SponsorController()
{
sponsorRepository = new SponsorRepository(new TTAnalyticsContext());
}
/// <summary>
/// SponsorController
/// </summary>
/// <param name="sponsorRepository"></param>
public SponsorController(ISponsorRepository sponsorRepository)
{
this.sponsorRepository = sponsorRepository;
}
public void Setup()
{
_sponsorRepository = Substitute.For<ISponsorRepository>();
_waitListHelper = Substitute.For<IWaitListHelper>();
}
