public async Task <StudentHistoryViewModel> GetHistoryAsync(string studentId) { var collectionRequest = new CollectionRequestModel("", "Modified", "True") { ParentId = studentId }; var collectionService = new CollectionService(new CollectionRepository(repository.Db)); var paymentRequest = new PaymentRequestModel("", "Modified", "True") { ParentId = studentId }; var paymentService = new PaymentService(new PaymentRepository(repository.Db)); List <CollectionViewModel> collections = await collectionService.SearchAsync(collectionRequest); List <PaymentViewModel> payments = await paymentService.SearchAsync(paymentRequest); List <StudentHistoryDetailViewModel> histories = new List <StudentHistoryDetailViewModel>(); histories.AddRange(collections.ConvertAll(x => new StudentHistoryDetailViewModel(x))); histories.AddRange(payments.ConvertAll(x => new StudentHistoryDetailViewModel(x))); StudentHistoryViewModel history = new StudentHistoryViewModel { Payments = payments, Collections = collections, CollectionTotal = collections.Sum(x => x.Total), PaymentTotal = payments.Sum(x => x.Amount), Histories = histories.OrderBy(x => x.Created).ToList() }; return(history); }
public IActionResult Get([FromQuery] CollectionRequestModel model) { try { var query = teamsRepository.GetAll(); if (!string.IsNullOrEmpty(model.Name)) { query = query.Where(x => x.Name.Contains(model.Name)); } bool withRelations = !model.NoRelations; if (withRelations) { query = this.teamsRepository.GetRelations(query) as IQueryable <Team>; } //var response = mapper.Map<Collection<TeamViewModel>>(query); var viewModel = query.Select(x => ViewModelHelper.BuildTeamViewModel(x, withRelations)); return(Ok(viewModel.ToList())); } catch (Exception ex) { return(BadRequest(new JsonResult(ex.Message))); } }
public async Task <IActionResult> Get([FromRoute] Guid id, [FromQuery] CollectionRequestModel model) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var query = teamsRepository.GetAll() .Where(x => x.Id.Equals(id)); bool withRelations = !model.NoRelations; if (withRelations) { query = this.teamsRepository.GetRelations(query) as IQueryable <Team>; } var viewQuery = query.Select(x => ViewModelHelper.BuildTeamViewModel(x, withRelations)); TeamViewModel team = await viewQuery.FirstOrDefaultAsync(); if (team == null) { return(NotFound()); } return(Ok(team)); } catch (Exception ex) { return(BadRequest(new JsonResult(ex.Message))); } }
public async Task <Result <ListResult <UserListItemModel> > > GetAllUsers(CollectionRequestModel model) { try { var query = new SearchQuery <UserEntity>(); ApplySorting(model, query); ApplyFilters(model, query); ApplyPaging(model, query); ApplyPaging(model, query); var results = await _userRepository.Search(query); var listResult = new ListResult <UserListItemModel>() { Count = results.Count, HasNext = results.HasNext, Results = results.Results.Select(u => new UserListItemModel() { Name = u.Name, Email = u.Email, Id = u.ID, RoutesCount = u.Routes.Count }).ToList() }; return(new Result <ListResult <UserListItemModel> >(listResult)); } catch (Exception ex) { ErrorResult error = GenerateError(ex); return(new Result <ListResult <UserListItemModel> >(error)); } }
public async Task <Result <ListResult <RouteInfo> > > GetAllRoutes(CollectionRequestModel model) { try { var query = new SearchQuery <RouteInfoEntity>(); ApplySorting(model, query); ApplyFilters(model, query); ApplyPaging(model, query); var results = await _routeRepository.Search(query); var listResult = new ListResult <RouteInfo>() { Count = results.Count, HasNext = results.HasNext, Results = results.Results.Select(r => new RouteInfo() { Id = r.ID, Name = r.Name, Difficulty = (Difficulty)r.Difficulty, UserId = r.UserId }).ToList() }; return(new Result <ListResult <RouteInfo> >(listResult)); } catch (Exception ex) { ErrorResult error = GenerateError(ex); return(new Result <ListResult <RouteInfo> >(error)); } }
// POST: api/Collection public IHttpActionResult Post([FromBody] CollectionRequestModel value) { try { var id = Guid.NewGuid(); var col = new Core.Entities.Model.Collection() { Id = id, UserId = CurrentUserId, Type = value.Type, Name = value.Name }; _uow.Collection.IU(col); return(Ok(col)); } catch (BusinessException ex) { return(BadRequest(ex.Message)); } catch (Exception ex) { _log.Error(ex); return(BadRequest(this.General_Err)); } }
private static void ApplyFilters(CollectionRequestModel model, SearchQuery <UserEntity> query) { if (!string.IsNullOrEmpty(model.Filter)) { var filters = FiltrationHelper.GetFilter <RouteFiltrationModel>(model.Filter); query.FiltersDictionary = FiltrationHelper.ConvertToDictionary(filters); } }
private static void ApplyPaging(CollectionRequestModel model, SearchQuery <UserEntity> query) { int page = model.Page ?? 1; int pagesize = model.PageSize ?? 100; query.Skip = pagesize * (page - 1); query.Take = pagesize; }
public async Task <CollectionResponseModel> Put(string orgId, string id, [FromBody] CollectionRequestModel model) { var collection = await GetCollectionAsync(new Guid(id), new Guid(orgId)); await _collectionService.SaveAsync(model.ToCollection(collection), model.Groups?.Select(g => g.ToSelectionReadOnly())); return(new CollectionResponseModel(collection)); }
private static void ApplySorting(CollectionRequestModel model, SearchQuery <UserEntity> query) { if (!string.IsNullOrEmpty(model.Sort)) { query.AddSortCriteria(FiltrationHelper.GetSorting <UserEntity>(model.Sort)); } else { query.AddSortCriteria(new FieldSortOrder <UserEntity>("Name", SortDirection.Ascending)); } }
public void Test1GetAll() { TeamsController controller = new TeamsController(_context, null); CollectionRequestModel collection = new CollectionRequestModel(); IActionResult a = controller.Get(collection); OkObjectResult ok = a as OkObjectResult; Assert.NotNull(ok); Assert.Equal(200, ok.StatusCode); }
public async Task <CollectionResponseModel> Put(string orgId, string id, [FromBody] CollectionRequestModel model) { var collection = await _collectionRepository.GetByIdAsync(new Guid(id)); if (collection == null || !_currentContext.OrganizationAdmin(collection.OrganizationId)) { throw new NotFoundException(); } await _collectionService.SaveAsync(model.ToCollection(collection)); return(new CollectionResponseModel(collection)); }
public void GetAllUsersValidResult() { var request = new CollectionRequestModel(); UserServiceMocker mocker = new UserServiceMocker(); mocker.RepoMock.Setup(r => r.Search(It.IsAny <SearchQuery <UserEntity> >())) .Returns(() => Task.FromResult(new PagingResult <UserEntity>() { Count = 2, HasNext = false, Results = new List <UserEntity>() { new UserEntity() { Email = "*****@*****.**", ID = 1, Name = "First", Routes = new List <RouteInfoEntity>() { new RouteInfoEntity() { ID = 1, Name = "a" } } }, new UserEntity() { Email = "*****@*****.**", ID = 2, Name = "Second", Routes = new List <RouteInfoEntity>() { new RouteInfoEntity() { ID = 2, Name = "b" } } } } })); IUserBLService service = mocker.GetService(); var result = service.GetAllUsers(request); Assert.Equal(true, result.Result.IsOk); Assert.Equal(2, result.Result.Content.Count); Assert.Equal(false, result.Result.Content.HasNext); }
public async Task <CollectionResponseModel> Post(string orgId, [FromBody] CollectionRequestModel model) { var orgIdGuid = new Guid(orgId); if (!_currentContext.OrganizationAdmin(orgIdGuid)) { throw new NotFoundException(); } var collection = model.ToCollection(orgIdGuid); await _collectionService.SaveAsync(collection, model.Groups?.Select(g => g.ToSelectionReadOnly())); return(new CollectionResponseModel(collection)); }
public void GetAllUsersUnhandledException() { var request = new CollectionRequestModel(); UserServiceMocker mocker = new UserServiceMocker(); mocker.RepoMock.Setup(r => r.Search(It.IsAny <SearchQuery <UserEntity> >())).Throws(new Exception("testexception")); IUserBLService service = mocker.GetService(); var result = service.GetAllUsers(request); Assert.Equal(ErrorStatus.InternalServer, result.Result.Error.Status); Assert.Equal("testexception", result.Result.Error.Message); }
public async Task <CollectionResponseModel> Put(Guid orgId, Guid id, [FromBody] CollectionRequestModel model) { if (!await CanEditCollectionAsync(orgId, id)) { throw new NotFoundException(); } var collection = await GetCollectionAsync(id, orgId); await _collectionService.SaveAsync(model.ToCollection(collection), model.Groups?.Select(g => g.ToSelectionReadOnly())); return(new CollectionResponseModel(collection)); }
public async Task <CollectionResponseModel> Post(string orgId, [FromBody] CollectionRequestModel model) { var orgIdGuid = new Guid(orgId); if (!await ManageAnyCollections(orgIdGuid)) { throw new NotFoundException(); } var collection = model.ToCollection(orgIdGuid); await _collectionService.SaveAsync(collection, model.Groups?.Select(g => g.ToSelectionReadOnly()), !await _currentContext.ManageAllCollections(orgIdGuid)?_currentContext.UserId : null); return(new CollectionResponseModel(collection)); }
public void GetRouteByIdInvalidId() { var request = new CollectionRequestModel(); var mocker = new RouteServiceMocker(); RouteInfoEntity entity = new RouteInfoEntity(); mocker.RepoMock.Setup(r => r.GetSingleWithDependencies(It.IsAny <int>())).Returns((() => Task.FromResult((RouteInfoEntity)null))); IRouteBLService service = mocker.GetService(); var result = service.GetRouteById(new IdModel() { Id = 1 }); Assert.Equal(ErrorStatus.ObjectNotFound, result.Result.Error.Status); Assert.Equal("Route not found", result.Result.Error.Message); }
public void GetRouteByIdUnhandledException() { var request = new CollectionRequestModel(); var mocker = new RouteServiceMocker(); RouteInfoEntity entity = new RouteInfoEntity(); mocker.RepoMock.Setup(r => r.GetSingleWithDependencies(It.IsAny <int>())).Throws(new Exception("testexception")); IRouteBLService service = mocker.GetService(); var result = service.GetRouteById(new IdModel() { Id = 1 }); Assert.Equal(ErrorStatus.InternalServer, result.Result.Error.Status); Assert.Equal("testexception", result.Result.Error.Message); }
public async Task <CollectionResponseModel> Post(Guid orgId, [FromBody] CollectionRequestModel model) { var collection = model.ToCollection(orgId); if (!await CanCreateCollection(orgId, collection.Id) && !await CanEditCollectionAsync(orgId, collection.Id)) { throw new NotFoundException(); } var assignUserToCollection = !(await _currentContext.EditAnyCollection(orgId)) && await _currentContext.EditAssignedCollections(orgId); await _collectionService.SaveAsync(collection, model.Groups?.Select(g => g.ToSelectionReadOnly()), assignUserToCollection?_currentContext.UserId : null); return(new CollectionResponseModel(collection)); }
public IActionResult Get([FromQuery] CollectionRequestModel model) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } int skip = 0; var query = this.metasRepository.GetAll() as IQueryable <MetaHuman>; if (model.Skip > 0) { skip = (int)model.Skip; } if (!string.IsNullOrEmpty(model.Name)) { query = query.Where(x => x.Name.Contains(model.Name)); } query = query .OrderBy(x => x.Name) .Skip(skip) .Take(25); bool withRelations = !model.NoRelations; if (withRelations) { query = this.metasRepository.GetRelations(query) as IQueryable <MetaHuman>; } var viewQuery = query.Select(x => ViewModelHelper.BuildMetaViewModel(x, withRelations)); return(Ok(viewQuery.ToList())); } catch (Exception ex) { return(BadRequest(new JsonResult(ex.Message))); } }
public ActionResult Get([FromQuery] CollectionRequestModel model) { try { int skip = 0; var query = this.abilitiesRepository.GetAll() as IQueryable <Ability>; if (!string.IsNullOrEmpty(model.Name)) { query = query.Where(x => x.Name.Contains(model.Name)); } if (model.Skip > 0) { skip = model.Skip; } query = query .OrderBy(x => x.Name) .Skip(skip) .Take(25); bool withRelations = !model.NoRelations; if (withRelations) { query = this.abilitiesRepository.GetRelations(query) as IQueryable <Ability>; } IQueryable <AbilityViewModel> viewQuery = query.Select(x => ViewModelHelper.BuildAbilityViewModel(x, withRelations)); return(Ok(viewQuery.ToList())); } catch (Exception ex) { return(BadRequest(new JsonResult(ex.Message))); } //return Ok(this.mapper.Map<AbilityViewModel>(query)); }
public async Task Post_Success(Guid orgId, SutProvider <CollectionsController> sutProvider) { sutProvider.GetDependency <ICurrentContext>() .CreateNewCollections(orgId) .Returns(true); sutProvider.GetDependency <ICurrentContext>() .EditAnyCollection(orgId) .Returns(false); var collectionRequest = new CollectionRequestModel { Name = "encrypted_string", ExternalId = "my_external_id" }; _ = await sutProvider.Sut.Post(orgId, collectionRequest); await sutProvider.GetDependency <ICollectionService>() .Received(1) .SaveAsync(Arg.Any <Collection>(), Arg.Any <IEnumerable <SelectionReadOnly> >(), null); }
public async Task <IActionResult> Get([FromRoute] Guid id, [FromQuery] CollectionRequestModel model) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var query = this.abilitiesRepository.GetAll() .Where(x => x.Id.Equals(id)) as IQueryable <Ability>; bool withRelations = !model.NoRelations; if (withRelations) { query = this.abilitiesRepository.GetRelations(query) as IQueryable <Ability>; } var viewModel = await query.Select(x => ViewModelHelper.BuildAbilityViewModel(x, withRelations)) .FirstOrDefaultAsync(); //this.mapper.Map<AbilityViewModel>(query); if (viewModel == null) { return(NotFound()); } return(Ok(viewModel)); } catch (Exception ex) { return(BadRequest(new JsonResult(ex.Message))); } }
public void GetAllRoutesValidResult() { var request = new CollectionRequestModel(); var mocker = new RouteServiceMocker(); RouteInfoEntity entity = new RouteInfoEntity(); mocker.RepoMock.Setup(r => r.Search(It.IsAny <SearchQuery <RouteInfoEntity> >())) .Returns(() => Task.FromResult(new PagingResult <RouteInfoEntity>() { Count = 2, HasNext = false, Results = new List <RouteInfoEntity>() { new RouteInfoEntity() { Difficulty = 2, ID = 1, Name = "First" }, new RouteInfoEntity() { Difficulty = 3, ID = 2, Name = "Second" } } })); IRouteBLService service = mocker.GetService(); var result = service.GetAllRoutes(request); Assert.Equal(true, result.Result.IsOk); Assert.Equal(2, result.Result.Content.Count); Assert.Equal(false, result.Result.Content.HasNext); }
public async Task Put_Success(Guid orgId, Guid collectionId, Guid userId, CollectionRequestModel collectionRequest, SutProvider <CollectionsController> sutProvider) { sutProvider.GetDependency <ICurrentContext>() .ViewAssignedCollections(orgId) .Returns(true); sutProvider.GetDependency <ICurrentContext>() .EditAssignedCollections(orgId) .Returns(true); sutProvider.GetDependency <ICurrentContext>() .UserId .Returns(userId); sutProvider.GetDependency <ICollectionRepository>() .GetByIdAsync(collectionId, userId) .Returns(new CollectionDetails { OrganizationId = orgId, }); _ = await sutProvider.Sut.Put(orgId, collectionId, collectionRequest); }
public async Task Put_CanNotEditAssignedCollection_ThrowsNotFound(Guid orgId, Guid collectionId, Guid userId, CollectionRequestModel collectionRequest, SutProvider <CollectionsController> sutProvider) { sutProvider.GetDependency <ICurrentContext>() .EditAssignedCollections(orgId) .Returns(true); sutProvider.GetDependency <ICurrentContext>() .UserId .Returns(userId); sutProvider.GetDependency <ICollectionRepository>() .GetByIdAsync(collectionId, userId) .Returns(Task.FromResult <CollectionDetails>(null)); _ = await Assert.ThrowsAsync <NotFoundException>(async() => await sutProvider.Sut.Put(orgId, collectionId, collectionRequest)); }