public DetailsHandler(IClock clock, ITrainingRepository trainingRepo, ITrainerProvider trainerProvider, IEnrollmentRepository enrollmentRepo)
{
_clock = clock ?? throw new ArgumentNullException(nameof(clock));
_trainingRepo = trainingRepo ?? throw new ArgumentNullException(nameof(trainingRepo));
_trainerProvider = trainerProvider ?? throw new ArgumentNullException(nameof(trainerProvider));
_enrollmentRepo = enrollmentRepo ?? throw new ArgumentNullException(nameof(enrollmentRepo));
}
public void Get_lookUps_grouped_with_aggregates()
{
DataRequest request = new DataRequest
{
Options = new DataSourceRequestOptions
{
//Queryable.Min<TSource, string> throws System.ArgumentException against In-Memory DB
//Aggregate = "listName-count~value-min",
Aggregate = "listName-count~booleanValue-min",
Filter = null,
Group = "listName-asc",
Page = 1,
Sort = null,
PageSize = 5
},
ModelType = "Enrollment.Domain.Entities.LookUpsModel",
DataType = "Enrollment.Data.Entities.LookUps",
Includes = null,
Selects = null,
Distinct = false
};
IEnrollmentRepository repository = serviceProvider.GetRequiredService <IEnrollmentRepository>();
DataSourceResult result = Task.Run(() => request.InvokeGenericMethod <DataSourceResult>("GetData", repository, serviceProvider.GetRequiredService <IMapper>())).Result;
Assert.Equal(466, result.Total);
Assert.Equal(2, ((IEnumerable <AggregateFunctionsGroupModel <LookUpsModel> >)result.Data).Count());
Assert.Equal(2, result.AggregateResults.Count());
Assert.Equal("Count", result.AggregateResults.First().AggregateMethodName);
Assert.Equal(466, (int)result.AggregateResults.First().Value);
}
// private readonly ContosoContext Context;
// dependency injection!!!!! inversion of control
public EnrollmentService(IStudentRepository students, ICourseRepository courses, IEnrollmentRepository enrollments)
{
// Context = context;
Courses = courses;
Students = students;
Enrollments = enrollments;
}
public LecturesController(ILectureRepository lectureRepository, ITeacherRepository teacherRepository, IEnrollmentRepository enrollmentRepository, IStudentRepository studentRepository)
{
_lectureRepository = lectureRepository;
_teacherRepository = teacherRepository;
_enrollmentRepository = enrollmentRepository;
_studentRepository = studentRepository;
}
public EnrollmentsController(IEnrollmentService enrollmentService, IEnrollmentRepository enrollmentRepository,
IMapper mapper)
{
_enrollmentService = enrollmentService;
_enrollmentRepository = enrollmentRepository;
_mapper = mapper;
}
public static TModel GetModel
(
[Comments("Filter.")]
FilterGroupParameters filterGroup,
[Comments("Variable reference to the repository.")]
IEnrollmentRepository repository,
[Comments("Variable reference to AutoMapper's IMapper.")]
IMapper mapper,
[ListEditorControl(ListControlType.HashSetForm)]
[ParameterEditorControl(ParameterControlType.ParameterSourcedPropertyInput)]
[NameValue(AttributeNames.PROPERTYSOURCEPARAMETER, "modelType")]
[Comments("Update the model type first for help with property names.")]
string[] includes = null,
[ParameterEditorControl(ParameterControlType.TypeAutoComplete)]
[NameValue(AttributeNames.DEFAULTVALUE, "Enrollment.Domain.Entities")]
[Comments("Fully qualified class name for the model type.")]
string modelType = null
)
{
FilterGroup fg = mapper.Map <FilterGroup>(filterGroup);
TModel model = repository.GetItemsAsync <TModel, TData>(fg.GetFilterExpression <TModel>(), null, includes.BuildIncludesExpressionCollection <TModel>()).Result.SingleOrDefault();
return(model ?? new TModel());
}
public EnrollmentService(
IEnrollmentRepository enrollmentRepository,
IEvaluationRepository evaluationRepository)
{
_enrollmentRepository = enrollmentRepository;
_evaluationRepository = evaluationRepository;
}
public void Select_Residencies_In_Ascending_Order_As_LookUpsModel_Type()
{
//arrange
var selectorLambdaOperatorDescriptor = GetExpressionDescriptor <IQueryable <ResidencyModel>, IEnumerable <LookUpsModel> >
(
GetResidenciesBodyForLookupModelType(),
"q"
);
IMapper mapper = serviceProvider.GetRequiredService <IMapper>();
IEnrollmentRepository repository = serviceProvider.GetRequiredService <IEnrollmentRepository>();
//act
var expression = mapper.MapToOperator(selectorLambdaOperatorDescriptor).Build();
var list = RequestHelpers.GetList <ResidencyModel, Residency, IEnumerable <LookUpsModel>, IEnumerable <LookUps> >
(
new Business.Requests.GetTypedListRequest
{
Selector = selectorLambdaOperatorDescriptor
},
repository,
mapper
).Result.List;
//assert
AssertFilterStringIsCorrect(expression, "q => Convert(q.OrderBy(d => d.DriversLicenseNumber).Select(d => new LookUpsModel() {NumericValue = Convert(d.UserId), Text = d.DriversLicenseNumber}))");
Assert.Equal(2, list.Count());
}
public void Select_Users_In_Ascending_Order_As_UserModel_Type()
{
//arrange
var selectorLambdaOperatorDescriptor = GetExpressionDescriptor <IQueryable <UserModel>, IEnumerable <UserModel> >
(
GetUsersBodyForUserModelType(),
"q"
);
IMapper mapper = serviceProvider.GetRequiredService <IMapper>();
IEnrollmentRepository repository = serviceProvider.GetRequiredService <IEnrollmentRepository>();
//act
var expression = mapper.MapToOperator(selectorLambdaOperatorDescriptor).Build();
var list = RequestHelpers.GetList <UserModel, User, IEnumerable <UserModel>, IEnumerable <User> >
(
new Business.Requests.GetTypedListRequest
{
Selector = selectorLambdaOperatorDescriptor,
ModelType = typeof(UserModel).AssemblyQualifiedName,
DataType = typeof(User).AssemblyQualifiedName,
ModelReturnType = typeof(IEnumerable <UserModel>).AssemblyQualifiedName,
DataReturnType = typeof(IEnumerable <User>).AssemblyQualifiedName
},
repository,
mapper
).Result.List.ToList();
//assert
AssertFilterStringIsCorrect(expression, "q => Convert(q.OrderBy(d => d.UserName))");
Assert.Equal(2, list.Count);
}
public void Get_students_filter_by_navigation_property_of_navigation_property()
{
IEnrollmentRepository repository = serviceProvider.GetRequiredService <IEnrollmentRepository>();
ICollection <UserModel> list = Task.Run(() => repository.GetItemsAsync <UserModel, User>(s => s.Residency.StatesLivedIn.Any(e => e.State == "GA"))).Result.ToList();
Assert.True(list.Count == 1);
}
public void Get_lookup_list_with_select_new()
{
DataRequest request = new DataRequest
{
Options = new DataSourceRequestOptions
{
Aggregate = null,
Filter = "listName~eq~'residentstates'",
Group = null,
Page = 0,
Sort = "value-asc",
PageSize = 0
},
ModelType = "Enrollment.Domain.Entities.LookUpsModel",
DataType = "Enrollment.Data.Entities.LookUps",
Includes = null,
Selects = new Dictionary <string, string> {
["value"] = "value", ["text"] = "text", ["listName"] = "listName"
},
Distinct = false
};
IEnrollmentRepository repository = serviceProvider.GetRequiredService <IEnrollmentRepository>();
IEnumerable <dynamic> result = Task.Run(() => request.InvokeGenericMethod <IEnumerable <dynamic> >("GetDynamicSelect", repository, serviceProvider.GetRequiredService <IMapper>())).Result;
Assert.Equal("AK", result.First().value);
Assert.Equal(60, result.Count());
}
public PlugUnitOfWork(IDbContextFactory contextFactory)
{
_contextFactory = contextFactory;
Courses = new CourseRepository(Context);
Students = new StudentRepository(Context);
Enrollments = new EnrollmentRepository(Context);
}
public EnrollmentsController()
{
var context = new ApplicationDbContext();
_enrollmentRepository = new EnrollmentRepository(context);
_lectureRepository = new LectureRepository(context);
_studentRepository = new StudentRepository(context);
}
public CreateEnrollmentHandler(IEnrollmentRepository enrollmentRepository,
ICourseRepository courseRepository,
IStudentRepository studentRepository)
{
_enrollmentRepository = enrollmentRepository;
_courseRepository = courseRepository;
_studentRepository = studentRepository;
}
public StudentController(IStudentRepository studentRepository,
IEnrollmentRepository enrollmentRepository,
ICourseRepository courseRepository)
{
_studentRepository = studentRepository;
_enrollmentRepository = enrollmentRepository;
_courseRepository = courseRepository;
}
public void Get_students_with_no_includes()
{
IEnrollmentRepository repository = serviceProvider.GetRequiredService <IEnrollmentRepository>();
ICollection <UserModel> list = Task.Run(() => repository.GetItemsAsync <UserModel, User>()).Result;
Assert.Equal(2, list.Count);
Assert.Null(list.First().Residency);
}
public LearningManagementService(ICourseRepository courseRepository,
IEnrollmentRepository enrollmentRepository,
IUserInfoProvider userInfoProvider)
{
_courseRepository = courseRepository;
_enrollmentRepository = enrollmentRepository;
_userInfoProvider = userInfoProvider;
}
public void RunBeforeAnyTests()
{
_config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
_courseRepository = new CourseRepository(_config);
_enrollmentRepository = new EnrollmentRepository(_config);
_studentLogic = new StudentLogic(_courseRepository, _enrollmentRepository);
}
public HomeController(IStudentRepository studentRepository, ICourseRepository courseRepository, IEnrollmentRepository enrollmentRepository, IRequestRepository requestRepository
, IHttpContextAccessor httpContextAccessor)
{
_StudentRepository = studentRepository;
_CourseRepository = courseRepository;
_EnrollmentRepository = enrollmentRepository;
_RequestRepository = requestRepository;
_httpContextAccessor = httpContextAccessor;
}
public StudentEnrollmentInCourseService(ICourseRepository courseRepository,
IStudentEnrolledInCourseRepository studentEnrolledInCourseRepository, IEnrollmentService enrollmentService,
IEnrollmentRepository enrollmentRepository)
{
_courseRepository = courseRepository;
_studentEnrolledInCourseRepository = studentEnrolledInCourseRepository;
_enrollmentService = enrollmentService;
_enrollmentRepository = enrollmentRepository;
}
public void RunBeforeAnyTests()
{
_config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
_instructorRepository = new InstructorRepository(_config);
_enrollmentRepository = new EnrollmentRepository(_config);
_instructorLogic = new InstructorLogic(_instructorRepository, _enrollmentRepository);
}
public EnrollmentsController(
IEnrollmentRepository enrollments,
ISiteRepository sites,
IMapper mapper
)
{
_enrollments = enrollments;
_sites = sites;
_mapper = mapper;
}
public EnrollmentService(IEnrollmentRepository enrollmentRepository,
IStudentRepository studentRepository,
ICourseRepository courseRepository,
IMapper mapper)
{
_enrollmentRepository = enrollmentRepository;
_studentRepository = studentRepository;
_courseRepository = courseRepository;
_mapper = mapper;
}
public FundingTimelinesAreValid(
IFundingRepository fundings,
IEnrollmentRepository enrollments,
IReportingPeriodRepository reportingPeriods
)
{
_fundings = fundings;
_enrollments = enrollments;
_reportingPeriods = reportingPeriods;
}
public MatriculaController(
IEnrollmentRepository matriculaRepository,
IRepository <Student> alunoRepository,
IRepository <Course> cursoRepository,
EnrollmentCreation enrollmentCreation)
{
_matriculaRepository = matriculaRepository;
_alunoRepository = alunoRepository;
_cursoRepository = cursoRepository;
_enrollmentCreation = enrollmentCreation;
}
public VideosController(IVideoRepository videoRepository,
IHostingEnvironment hostingEnvironment,
ISectionRepository sectionRepository,
UserManager <ApplicationUser> userManager,
IEnrollmentRepository enrollmentRepository)
{
_videoRepository = videoRepository;
_hostingEnvironment = hostingEnvironment;
_sectionRepository = sectionRepository;
_userManager = userManager;
_enrollmentRepository = enrollmentRepository;
}
public void Get_students_inlude_navigation_property_of_navigation_property()
{
IEnrollmentRepository repository = serviceProvider.GetRequiredService <IEnrollmentRepository>();
ICollection <UserModel> list = Task.Run(() => repository.GetItemsAsync <UserModel, User>(s => s.Residency.StatesLivedIn.Count() > 0, null,
new Expression <Func <IQueryable <UserModel>, IIncludableQueryable <UserModel, object> > >[]
{
a => a.Include(x => x.Residency).ThenInclude(e => e.StatesLivedIn)
})).Result.ToList();
Assert.NotNull(list.First().Residency);
Assert.NotNull(list.First().Residency.StatesLivedIn.First().State);
}
public EnrollmentsController(IEnrollmentRepository enrollmentRepository,
ISectionRepository sectionRepository,
UserManager <ApplicationUser> userManager,
ICourseRepository courseRepository,
IVideoRepository videoRepository)
{
_enrollmentRepository = enrollmentRepository;
_sectionRepository = sectionRepository;
_userManager = userManager;
_courseRepository = courseRepository;
_videoRepository = videoRepository;
}
public EnrollmentService(IEnrollmentRepository enrollmentRepository,
IExamRepository examRepository,
ICourseService courseService,
IHttpContextAccessor httpContextAccessor,
IMapper mapper)
{
_enrollmentRepository = enrollmentRepository;
_examRepository = examRepository;
_courseService = courseService;
_httpContextAccessor = httpContextAccessor;
_mapper = mapper;
}
public CourseService(IStudyPlanRepository studyPlanRepository, ISubjectRepository subjectRepository,
ITeacherRepository teacherRepository, ICourseGenerationService courseGenerationService,
ICourseRepository courseRepository, IEnrollmentRepository enrollmentRepository,
IStudentEnrollmentInCourseService studentEnrollmentService)
{
_studyPlanRepository = studyPlanRepository;
_subjectRepository = subjectRepository;
_teacherRepository = teacherRepository;
_courseGenerationService = courseGenerationService;
_courseRepository = courseRepository;
_enrollmentRepository = enrollmentRepository;
_studentEnrollmentService = studentEnrollmentService;
}
public EnrollmentService(IEnrollmentRepository repository)
{
this.repository = repository;
}
public EnrollmentsController(IEnrollmentRepository enrollmentRepository)
{
this.enrollmentRepository = enrollmentRepository;
}
public SetupController(IEnrollmentRepository repo)
{
this.db = repo;
}
