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));
}
