public async Task MainAsync()
{
_client = new DiscordSocketClient();
_commands = new CommandService();
BuildConfigurationBuilder();
DatabaseConnection();
DependencyInjection();
IScoreRepository scoreRepo = _services.GetService <IScoreRepository>();
_workerService = new VCWorkerService(scoreRepo);
Console.WriteLine("Initializing API");
ApiHelper.InitializeClient();
await InstallCommands();
_client.Log += Log;
_client.ReactionAdded += ReactionAdded;
_client.UserVoiceStateUpdated += UserVCUpdated;
await _client.LoginAsync(TokenType.Bot, _config.GetValue <string>("Tokens:Live"));
await _client.StartAsync();
// Block this task until the program is closed.
await Task.Delay(-1);
}
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "get", Route = "references/BallType")] HttpRequest req,
ILogger log, [Inject] IScoreRepository repository)
{
try
{
log.LogInformation($"C# HTTP trigger function processed a request.");
IList <BallType> customers = null;
customers = await repository.GetAllBallTypes()
.ConfigureAwait(false);
if (!customers.Any())
{
return((ActionResult) new NotFoundObjectResult(new { ErrorMessage = "CustomerNotFound" }));
}
return((ActionResult) new OkObjectResult(new { BallTypes = customers }));
}
catch (Exception ex)
{
log.LogCritical(ex.Message, ex);
throw;
}
}
public LecturerController(ICourseRepository courseRepository, IScoreRepository scoreRepository, IUserRepository userRepository, IComponentRepository componentRepository)
{
_courseRepository = courseRepository;
_scoreRepository = scoreRepository;
_userRepository = userRepository;
_componentRepository = componentRepository;
}
public TestController(IHostingEnvironment env, IUserRepository users, IGameRepository games, IScoreRepository scores)
{
Env = env;
Users = users;
Games = games;
Scores = scores;
}
public ScoreService(IScoreRepository scoreRepository, MaxScoreRepository maxScoreRepository,
LeaderBoardScoreService leaderboardScoreService)
{
_scoreRepository = scoreRepository;
_leaderboardScoreService = leaderboardScoreService;
_maxScoreRepository = maxScoreRepository;
}
private static int FindWinnerID(int bracketId, IScoreRepository scoreRepository)
{
var scores = (List <Score>)scoreRepository.GetScores(_ => _.BracketID == bracketId);
var winner = scores.OrderByDescending(s => s.Value).First();
return(winner.TeamID);
}
public StudentDataController(IUserRepository usrRep, ICourseRepository corRep, IScoreRepository scrRep, IComponentRepository comRep)
{
_usrRep = usrRep;
_corRep = corRep;
_scrRep = scrRep;
_comRep = comRep;
}
public ScoreStoreController(
IScoreRepository scoreRepository,
IUserRepository userRepository)
{
_scoreRepository = scoreRepository;
_userRepository = userRepository;
}
public HomeController(ILogger <HomeController> logger, MockTestContext context, IQuestionRepository questionRepository, IScoreRepository scoreRepository)
{
_logger = logger;
_context = context;
_QuestionRepository = questionRepository;
_ScoreRepository = scoreRepository;
}
public QuizController(IQuestionRepository questionRepository, IAnswersRepository answersRepository, IScoreRepository scoreRepository, IUserRepository userRepository)
{
this.questionRepository = questionRepository;
this.answersRepository = answersRepository;
this.scoreRepository = scoreRepository;
this.userRepository = userRepository;
}
public ScoreService(
IUserService userService,
IScoreRepository scoreRepository)
{
this.userService = userService;
this.scoreRepository = scoreRepository;
}
public RepositoryContainer(IUserRepository users, IScoreRepository scores, ICategoryRepository categ, ITransactionRepository trans)
{
_categ = categ;
_users = users;
_scores = scores;
_trans = trans;
}
public SetScoreCommandHandler(
IScoreRepository scoreRepository,
ICurrentSongRepository currentSongRepository
)
{
_scoreRepository = scoreRepository;
_currentSongRepository = currentSongRepository;
}
public QuizHub(IRoomRepository roomRepository, IUserRepository userRepository, IScoreRepository scoreRepository, JwtManager jwtManager, ILogger <QuizHub> logger)
{
_roomRepository = roomRepository;
_userRepository = userRepository;
_scoreRepository = scoreRepository;
_jwtManager = jwtManager;
_logger = logger;
}
public ScoreManager(IMapper mapper, IScoreRepository scoreRepository, PlayerManager playerManager,
IPlayerAchievementRepository playerAchievementRepository)
{
_mapper = mapper;
_scoreRepository = scoreRepository;
_playerManager = playerManager;
_playerAchievementRepository = playerAchievementRepository;
}
public Service(IParticipantRepository participantRepository,
IArbiterRepository arbiterRepository,
IScoreRepository scoreRepository)
{
ParticipantRepository = participantRepository;
ArbiterRepository = arbiterRepository;
ScoreRepository = scoreRepository;
}
public Match(ISettings settings, IRoundFactory roundFactory, IScoreRepository scoreRepository)
{
Settings = settings;
RoundFactory = roundFactory;
ScoreRepository = scoreRepository;
scores = new List <Score>(ScoreRepository.Load());
NextRoundIn = TimeSpan.Zero;
}
public StatisticService(IScoreService scoreService, IReviewService reviewService, IExamService examService, IScoreRepository scoreRepository, IExamRepository examRepository, IUserRepository userRepository)
{
this.scoreService = scoreService;
this.reviewService = reviewService;
this.examService = examService;
this.scoreRepository = scoreRepository;
this.examRepository = examRepository;
this.userRepository = userRepository;
}
public ExamineeService(IAnswerRepository answerRepository, IQuestionRepository questionRepository, IExamRepository examRepository, IExamService examService, IScoreRepository socreRepository, IBankService bankService)
{
this.answerRepository = answerRepository;
this.questionRepository = questionRepository;
this.examRepository = examRepository;
this.examService = examService;
this.scoreRepository = socreRepository;
this.bankService = bankService;
}
public QuizController(IQuizRepository quizRepository, IAnswerRepository answerRepository, IQuestionRepository questionRepository, IScoreRepository scoreRepository, UserManager <ApplicationUser> userManager, IHostingEnvironment e, IHttpContextAccessor httpContextAccessor)
{
_he = e;
_userManager = userManager;
_quizRepository = quizRepository;
_scoreRepository = scoreRepository;
_answerRepository = answerRepository;
_questionRepository = questionRepository;
_httpContextAccessor = httpContextAccessor;
}
public BaseController()
{
this.closestToPinRepository = new ClosestToPinRepository(dataContext);
this.courseRepository = new CourseRepository(dataContext);
this.segmentRepository = new SegmentRepository(dataContext);
this.holeRepository = new HoleRepository(dataContext);
this.messageRepository = new MessageRepository(dataContext);
this.scoreRepository = new ScoreRepository(dataContext);
this.teamRepository = new TeamRepository(dataContext);
}
public Teach_CoursesController(IMapper mapper, ITeach_CourseRepository teach_CourseRepository, ITeacherRepository teacherRepository, ICourseRepository courseRepository, IAcademyRepository academyRepository, IScoreRepository scoreRepository)
{
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_teach_CourseRepository = teach_CourseRepository ?? throw new ArgumentNullException(nameof(teach_CourseRepository));
_teacherRepository = teacherRepository ?? throw new ArgumentNullException(nameof(teacherRepository));
_courseRepository = courseRepository ?? throw new ArgumentNullException(nameof(courseRepository));
_academyRepository = academyRepository ?? throw new ArgumentNullException(nameof(academyRepository));
//用来判断学生选了哪些课程并排除
_scoreRepository = scoreRepository ?? throw new ArgumentNullException(nameof(scoreRepository));
}
public SessionController(IUserRepository userRepository, ISessionRepository sessionRepository,
IFormulaRepository formulaRepository, ITrainingDayRepository trainingDayRepository, INonMemberRepository nonMemberRepository, IScoreRepository scoreRepository)
{
_userRepository = userRepository;
_sessionRepository = sessionRepository;
_trainingDayRepository = trainingDayRepository;
_formulaRepository = formulaRepository;
_nonMemberRepository = nonMemberRepository;
_scoreRepository = scoreRepository;
}
public ScoresController(IMapper mapper, IScoreRepository scoreRepository, IStudentRepository studentRepository, ITeach_CourseRepository teach_CourseRepository, ITeacherRepository teacherRepository, ICourseRepository courseRepository)
{
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_scoreRepository = scoreRepository ?? throw new ArgumentNullException(nameof(scoreRepository));
_studentRepository = studentRepository ?? throw new ArgumentNullException(nameof(studentRepository));
_teach_CourseRepository = teach_CourseRepository ?? throw new ArgumentNullException(nameof(teach_CourseRepository));
_teacherRepository = teacherRepository ?? throw new ArgumentNullException(nameof(teacherRepository));
_courseRepository = courseRepository ?? throw new ArgumentNullException(nameof(courseRepository));
}
public MatchFactory(
ISettings settings,
IRoundFactory roundFactory,
IOutput output,
IScoreRepository scoreRepository)
{
Settings = settings;
RoundFactory = roundFactory;
Output = output;
ScoreRepository = scoreRepository;
}
public static async Task ScoreInitialize(IScoreRepository Repository)
{
if (!await Repository.CheckCount())
{
await Repository.CreateAsync(new Score { Name = "KICB", PaymentTypeId = 2, Code = "123123123", Balance = 10000 });
await Repository.CreateAsync(new Score { Name = "ELSOM", PaymentTypeId = 1, Code = "123123123", Balance = 10000 });
await Repository.CreateAsync(new Score { Name = "DemirBank", PaymentTypeId = 2, Code = "123123123", Balance = 10000 });
}
}
public EndSessionCommandHandler(
ISessionRepository sessionRepository,
ISongRepository songRepository,
ICurrentSongRepository currentSongRepository,
IScoreRepository scoreRepository
)
{
_sessionRepository = sessionRepository;
_songRepository = songRepository;
_currentSongRepository = currentSongRepository;
_scoreRepository = scoreRepository;
}
public MainWindowViewModel()
{
PlayerRepository = new PlayerRepository();
ScoreRepository = new ScoreRepository();
PictureRepository = new PictureRepository();
PlayerGroupItemRepository = new PlayerGroupItemRepository();
NewPlayer = new Player();
PicturesToDrag = new ObservableCollection<Picture>();
ListOfDraggedPictures = new ObservableCollection<Picture>();
_timer.Interval = new TimeSpan(0, 0, 1);
_timer.Tick += new EventHandler(timer_Tick);
}
public GameService(
IRandomProvider randomProvider,
ITimeProvider timeProvider,
IContextProvider contextProvider,
IAdoptionRepository adoptionRepository,
IScoreRepository scoreRepository)
{
this.randomProvider = randomProvider;
this.timeProvider = timeProvider;
this.contextProvider = contextProvider;
this.adoptionRepository = adoptionRepository;
this.scoreRepository = scoreRepository;
}
public CourseFormTests()
{
var nhs = new NHibernateService2();
_userRepository = new UserRepository(nhs);
_courseRepository = new CourseRepository(nhs);
_componentRepository = new ComponentRepository(nhs);
_scoreRepository = new ScoreRepository(nhs);
_userServices = new UserServices(_userRepository);
_courseServices = new CourseServices(_courseRepository, _userRepository, _componentRepository);
_scoreServices = new ScoreServices(_scoreRepository, _courseRepository, _userRepository);
}
public ScoresController(
IScoreRepository scoreRepository,
IUserRepository userRepository,
IMapper mapper,
IOptions <AppSettings> appSettings,
IHubContext <ScoresNotifyHub> hubContext)
{
_userRepository = userRepository;
_scoreRepository = scoreRepository;
_mapper = mapper;
_appSettings = appSettings.Value;
_hubContext = hubContext;
}
public ScoreService(
EntityValidator entityValidator,
IScoreRepository scoreRepository,
IScoreDtoMapper scoreDtoMapper,
IVisitRepository visitRepository,
ILessonRepository lessonRepository,
IVisitDtoMapper visitDtoMapper
)
{
if (entityValidator == null)
{
throw new ArgumentNullException("entityValidator");
}
if (scoreRepository == null)
{
throw new ArgumentNullException("scoreRepository");
}
if (scoreDtoMapper == null)
{
throw new ArgumentNullException("scoreDtoMapper");
}
if (visitRepository == null)
{
throw new ArgumentNullException("visitRepository");
}
if (lessonRepository == null)
{
throw new ArgumentNullException("lessonRepository");
}
if (visitDtoMapper == null)
{
throw new ArgumentNullException("visitDtoMapper");
}
_entityValidator = entityValidator;
_scoreRepository = scoreRepository;
_scoreDtoMapper = scoreDtoMapper;
_visitRepository = visitRepository;
_lessonRepository = lessonRepository;
_visitDtoMapper = visitDtoMapper;
}
public ScoreManager(IScoreRepository scoreRepository)
{
_scoreRepository = scoreRepository;
}
public void Dispose()
{
_scoreRepository.Dispose();
_scoreRepository = null;
}
public ScoresResource(IScoreRepository scoreRepository)
{
this.scoreRepository = scoreRepository;
}
