public async Task <IActionResult> OnGet()
        {
            Submissions = await _engine.Query(Query);

            var campaigns = await _engine.Query(new Szlem.Recruitment.Campaigns.Index.Query());

            campaigns.Tap(value => Campaigns = value);

            Trainings = await _engine.Query(new Szlem.Recruitment.Trainings.Index.Query());

            return(Page());
        }
        public async Task OnGet()
        {
            var user = await _userAccessor.GetUser();

            Trainigns = await _engine.Query(new Szlem.Recruitment.Trainings.Index.Query()
            {
                CoordinatorId = user.Id
            });

            var campaigns = await _engine.Query(new Szlem.Recruitment.Campaigns.Index.Query())
                            .Map(res => res.Where(x => x.StartDateTime.ToInstant() > _clock.GetCurrentInstant()));

            Campaigns = campaigns.Value.ToArray();
        }
        public async Task <IActionResult> OnGet([FromRoute] int campaignId)
        {
            CampaignID = campaignId;
            var result = await _engine.Query(new Details.Query()
            {
                CampaignID = campaignId
            });

            if (result.IsFailure)
            {
                ModelState.AddModelError(string.Empty, result.Error.Message);
                return(Page());
            }

            var campaign = result.Value;

            if (campaign.IsRecruitmentFormOpen == false)
            {
                ModelState.AddModelError(string.Empty, "Rekrutacja w tej kampanii jest zamknięta");
                return(Page());
            }

            AvailableTrainings = campaign.Trainings.Select(x => BuildSelectListItem(x)).ToArray();

            return(Page());
        }
Beispiel #4
0
        public async Task <IActionResult> OnGet(Guid userId)
        {
            UserDetails = await _app.Query(new DetailsUseCase.Query()
            {
                UserId = userId
            });

            var availableRoles = await _app.Query(new DetailsUseCase.GetRolesThatCanBeGrantedQuery()
            {
                UserId = userId
            });

            AvailableRoles = new SelectList(availableRoles, nameof(DetailsUseCase.RoleData.Name), nameof(DetailsUseCase.RoleData.Description));

            return(Page());
        }
 public async Task <IActionResult> OnGet(int id)
 {
     Edition = (await _engine.Query(new Query()
     {
         EditionID = id
     })).Value;
     return(Page());
 }
Beispiel #6
0
        public async Task <IActionResult> Details(int id)
        {
            var result = await _engine.Query(new Recruitment.Campaigns.Details.Query()
            {
                CampaignID = id
            });

            return(result.MatchToActionResult(v => Ok(v)));
        }
Beispiel #7
0
 public async Task OnGet()
 {
     if (User.Identity.IsAuthenticated)
     {
         CurrentCampaign = await _engine.Query(new Szlem.Recruitment.Campaigns.GetCurrentCampaign.Query());
     }
     else
     {
         CurrentCampaign = Maybe <Szlem.Recruitment.Campaigns.Details.Campaign> .None;
     }
 }
Beispiel #8
0
        public async Task <IActionResult> OnGet()
        {
            var user = await _userAccessor.GetUser();

            var result = await _engine.Query(new GetEnrollmentDetails.QueryByEmail()
            {
                Email = EmailAddress.Parse(user.Email)
            })
                         .Tap(details => EnrollmentDetails = details)
                         .OnFailure(error => ModelState.AddModelError(string.Empty, error.Message));

            return(result.Match <GetEnrollmentDetails.Details, IActionResult, Error>(
                       success => { EnrollmentDetails = success; return Page(); },
                       failure => { ModelState.AddModelError(string.Empty, failure.Message); return RedirectToPage("/Index"); }
                       ));
        }
Beispiel #9
0
        public async Task <IActionResult> OnGet(int trainingId)
        {
            var result = await _engine.Query(new Details.Query()
            {
                TrainingId = trainingId
            });

            if (result.HasNoValue)
            {
                return(NotFound());
            }

            Training = result.Value;

            return(Page());
        }
        public async Task <Response> Handle(Query request, CancellationToken cancellationToken)
        {
            var timetableResult = await _engine.Query(new GetTimetableUseCase.Query()
            {
                SchoolID = request.SchoolID, ValidOn = DateTime.Today
            });

            var courses = new[]
            {
                new CourseSummary()
                {
                    Class     = "1a",
                    IsOngoing = new Random().Next() % 2 == 0,
                    Lecturers = new FullNameGenerator().GetNames(1, 3).ToArray()
                },
                new CourseSummary()
                {
                    Class     = "1c",
                    IsOngoing = new Random().Next() % 2 == 0,
                    Lecturers = new FullNameGenerator().GetNames(1, 3).ToArray()
                }
            };

            var response = new Response()
            {
                SchoolID      = 1,
                SchoolName    = "I LO im. Mikołaja Kopernika",
                SchoolAddress = "Wałowa 7",
                SchoolCity    = "Gdańsk",

                IsCurrentEdition = true,

                EditionID        = 6,
                EditionName      = "Edycja VI",
                EditionStartDate = DateTime.Today.AddMonths(-1),
                EditionEndDate   = DateTime.Today.AddMonths(3).AddDays(17),

                LessonCount       = 17,
                Courses           = courses,
                Timetable         = timetableResult.Timetable,
                CanStartNewCourse = true
            };

            return(response);
        }
        private async Task <IActionResult> BuildPage(Guid enrollmentId)
        {
            EnrollmentId = enrollmentId;
            var request = new GetEnrollmentDetails.QueryByEnrollmentId()
            {
                EnrollmentID = enrollmentId
            };
            var result = await _engine.Query(request);

            if (result.IsFailure)
            {
                return new PageResult()
                       {
                           StatusCode = (int)System.Net.HttpStatusCode.NotFound
                       }
            }
            ;

            EnrollmentDetails = result.Value;
            return(Page());
        }
        public async Task <IActionResult> OnGet()
        {
            Users = await _engine.Query(new IndexUseCase.Query());

            return(Page());
        }
        public async Task <IActionResult> OnGet()
        {
            Editions = await _engine.Query(new Query());

            return(Page());
        }
Beispiel #14
0
 public async Task OnGet()
 {
     CurrentCampaign = await _engine.Query(new Szlem.Recruitment.Campaigns.GetCurrentCampaign.Query());
 }
 public async Task <IActionResult> Index([FromQuery] GetSchools.Query query)
 {
     return(Ok(await _engine.Query(query)));
 }
 public async Task <IActionResult> GetSubmissions([FromQuery] GetSubmissions.Query query)
 {
     return(Ok(await _engine.Query(query)));
 }
        public async Task <IActionResult> OnGet()
        {
            Schools = await _engine.Query(Query);

            return(Page());
        }
 public async Task <IActionResult> Index()
 {
     return(Ok(await _engine.Query(new IndexUseCase.Query())));
 }