public async void TestDelete()
{
var builder = new WebHostBuilder()
.UseEnvironment("Production")
.UseStartup <TestStartup>();
TestServer testServer = new TestServer(builder);
var client = new ApiClient(testServer.CreateClient());
var createModel = new ApiTableRequestModel();
createModel.SetProperties("B");
CreateResponse <ApiTableResponseModel> createResult = await client.TableCreateAsync(createModel);
createResult.Success.Should().BeTrue();
ApiTableResponseModel getResponse = await client.TableGetAsync(2);
getResponse.Should().NotBeNull();
ActionResponse deleteResult = await client.TableDeleteAsync(2);
deleteResult.Success.Should().BeTrue();
ApiTableResponseModel verifyResponse = await client.TableGetAsync(2);
verifyResponse.Should().BeNull();
}
public virtual ApiTableResponseModel MapBOToModel(
BOTable boTable)
{
var model = new ApiTableResponseModel();
model.SetProperties(boTable.Id, boTable.Name);
return(model);
}
public void MapResponseToRequest()
{
var mapper = new ApiTableModelMapper();
var model = new ApiTableResponseModel();
model.SetProperties(1, "A");
ApiTableRequestModel response = mapper.MapResponseToRequest(model);
response.Name.Should().Be("A");
}
public static ApiTableResponseModel <DanceGroupModel> GetDanceGroups(DanceGroupModel filter)
{
ApiTableResponseModel <DanceGroupModel> response = new ApiTableResponseModel <DanceGroupModel>();
using (var ctx = new DFAppEntities())
{
var q = ctx.DanceGroups
.Include(t => t.Lookup_AgeCategories)
.AsQueryable();
if (!string.IsNullOrEmpty(filter.DanceGroupName))
{
q = q.Where(x => x.DanceGroupName.ToLower().Contains(filter.DanceGroupName.ToLower()));
}
if (string.IsNullOrEmpty(filter.OrderByClause))
{
// default order
filter.OrderByClause = "DanceGroupName";
}
if (filter.PageNo < 1)
{
filter.PageNo = 1;
}
if (filter.RecordsPerPage < 1)
{
// unlimited
filter.RecordsPerPage = 1000000;
}
response.Total = q.Count();
var Data =
q.ToList()
.Select(x =>
new DanceGroupModel()
{
DanceGroupID = x.DanceGroupID,
DanceGroupName = x.DanceGroupName,
DanceGroupDesc = x.DanceGroupDesc,
AgeCategoryID = x.AgeCategoryID,
AgeCategory = (x.Lookup_AgeCategories != null) ? x.Lookup_AgeCategories.Name : string.Empty
}
)
.OrderBy(filter.OrderByClause)
.Skip((filter.PageNo - 1) * filter.RecordsPerPage)
.Take(filter.RecordsPerPage);
response.Data = Data;
}
return(response);
}
public void MapBOToModel()
{
var mapper = new BOLTableMapper();
BOTable bo = new BOTable();
bo.SetProperties(1, "A");
ApiTableResponseModel response = mapper.MapBOToModel(bo);
response.Id.Should().Be(1);
response.Name.Should().Be("A");
}
public async void TestGet()
{
var builder = new WebHostBuilder()
.UseEnvironment("Production")
.UseStartup <TestStartup>();
TestServer testServer = new TestServer(builder);
var client = new ApiClient(testServer.CreateClient());
ApiTableResponseModel response = await client.TableGetAsync(1);
response.Should().NotBeNull();
}
public async virtual Task <IActionResult> Get(int id)
{
ApiTableResponseModel response = await this.TableService.Get(id);
if (response == null)
{
return(this.StatusCode(StatusCodes.Status404NotFound));
}
else
{
return(this.Ok(response));
}
}
public async void Get_null_record()
{
var mock = new ServiceMockFacade <ITableRepository>();
mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult <Table>(null));
var service = new TableService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.TableModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLTableMapperMock,
mock.DALMapperMockFactory.DALTableMapperMock);
ApiTableResponseModel response = await service.Get(default(int));
response.Should().BeNull();
mock.RepositoryMock.Verify(x => x.Get(It.IsAny <int>()));
}
public async void TestUpdate()
{
var builder = new WebHostBuilder()
.UseEnvironment("Production")
.UseStartup <TestStartup>();
TestServer testServer = new TestServer(builder);
var client = new ApiClient(testServer.CreateClient());
ApiTableResponseModel model = await client.TableGetAsync(1);
ApiTableModelMapper mapper = new ApiTableModelMapper();
UpdateResponse <ApiTableResponseModel> updateResponse = await client.TableUpdateAsync(model.Id, mapper.MapResponseToRequest(model));
updateResponse.Record.Should().NotBeNull();
updateResponse.Success.Should().BeTrue();
}
public async void Create_Errors()
{
TableControllerMockFacade mock = new TableControllerMockFacade();
var mockResponse = new Mock <CreateResponse <ApiTableResponseModel> >(new FluentValidation.Results.ValidationResult());
var mockRecord = new ApiTableResponseModel();
mockResponse.SetupGet(x => x.Success).Returns(false);
mock.ServiceMock.Setup(x => x.Create(It.IsAny <ApiTableRequestModel>())).Returns(Task.FromResult <CreateResponse <ApiTableResponseModel> >(mockResponse.Object));
TableController controller = new TableController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
IActionResult response = await controller.Create(new ApiTableRequestModel());
response.Should().BeOfType <ObjectResult>();
(response as ObjectResult).StatusCode.Should().Be((int)HttpStatusCode.UnprocessableEntity);
mock.ServiceMock.Verify(x => x.Create(It.IsAny <ApiTableRequestModel>()));
}
public async void All_Exists()
{
TableControllerMockFacade mock = new TableControllerMockFacade();
var record = new ApiTableResponseModel();
var records = new List <ApiTableResponseModel>();
records.Add(record);
mock.ServiceMock.Setup(x => x.All(It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(records));
TableController controller = new TableController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
IActionResult response = await controller.All(1000, 0);
response.Should().BeOfType <OkObjectResult>();
(response as OkObjectResult).StatusCode.Should().Be((int)HttpStatusCode.OK);
var items = (response as OkObjectResult).Value as List <ApiTableResponseModel>;
items.Count.Should().Be(1);
mock.ServiceMock.Verify(x => x.All(It.IsAny <int>(), It.IsAny <int>()));
}
public virtual async Task <IActionResult> Patch(int id, [FromBody] JsonPatchDocument <ApiTableRequestModel> patch)
{
ApiTableResponseModel record = await this.TableService.Get(id);
if (record == null)
{
return(this.StatusCode(StatusCodes.Status404NotFound));
}
else
{
ApiTableRequestModel model = await this.PatchModel(id, patch);
UpdateResponse <ApiTableResponseModel> result = await this.TableService.Update(id, model);
if (result.Success)
{
return(this.Ok(result));
}
else
{
return(this.StatusCode(StatusCodes.Status422UnprocessableEntity, result));
}
}
}
public static ApiTableResponseModel <MemberModel> GetFilteredMembers_Dapper(MemberFilterModel filter)
{
ApiTableResponseModel <MemberModel> response = new ApiTableResponseModel <MemberModel>();
var q =
new Query("Members")
.LeftJoin("Lookup_AgeCategories", "Members.AgeCategoryID", "Lookup_AgeCategories.ID")
.LeftJoin("ContactData", "Members.ContactDataID", "ContactData.ContactDataID")
.Select("MemberID", "FirstName", "LastName", "IsActive", "IsCompetitor", "JMBG", "BirthDate", "BirthPlace", "AgeCategoryID", "Note")
.SelectRaw("FirstName + ' ' + LastName as FullName")
.SelectRaw("Lookup_AgeCategories.Name as AgeCategory")
.SelectRaw("dbo.fnGetMemberDanceGroups(MemberID) as DanceGroups")
.SelectRaw("'' as Split")
.SelectRaw("ContactData.Address, ContactData.Email, ContactData.Phone1, ContactData.Phone2, ContactData.Phone3");
if (filter != null)
{
bool excludeNonActive = true;
if (filter.ExcludeNonActive.HasValue)
{
excludeNonActive = (bool)filter.ExcludeNonActive;
}
if (excludeNonActive)
{
q = q.WhereRaw("IsActive = 1");
}
if (!string.IsNullOrEmpty(filter.FullName))
{
q = q.WhereRaw("lower(FirstName + ' ' + LastName) like '%" + filter.FullName.ToLower() + "%'");
}
if (!string.IsNullOrEmpty(filter.JMBG))
{
q = q.WhereRaw("lower(JMBG) like '" + filter.JMBG.ToLower() + "%'");
}
if (filter.DanceGroupID.HasValue)
{
q = q.WhereRaw(filter.DanceGroupID + " in (select DanceGroupID from fnGetMemberDanceGroupsAsTable(MemberID))");
}
// paging & sorting
if (string.IsNullOrEmpty(filter.OrderByClause))
{
// default order
filter.OrderByClause = "FullName";
}
if (filter.PageNo < 1)
{
filter.PageNo = 1;
}
if (filter.RecordsPerPage < 1)
{
// unlimited
filter.RecordsPerPage = 1000000;
}
}
var compiler = new SqlServerCompiler();
SqlResult result = compiler.Compile(q);
string sql = result.Sql;
string connectionString = DALHelper.GetSqlConnectionStringFromEF();
List <MemberModel> members = new List <MemberModel>();
using (var connection = new SqlConnection(connectionString))
{
// Total
response.Total = connection.Query <MemberModel>(sql).Count();
// Data
members = connection.Query <MemberModel, ContactDataModel, MemberModel>(
sql,
(member, contactData) => {
member.ContactData = contactData;
return(member);
},
splitOn: "Split"
)
.OrderBy(filter.OrderByClause)
.Skip((filter.PageNo - 1) * filter.RecordsPerPage)
.Take(filter.RecordsPerPage)
.AsList();
}
response.Data = members;
return(response);
}
public async void TestGet()
{
ApiTableResponseModel response = await this.Client.TableGetAsync(1);
response.Should().NotBeNull();
}
public static ApiTableResponseModel <TrainingModel> GetTrainingsFiltered(TrainingFilter filter)
{
ApiTableResponseModel <TrainingModel> response = new ApiTableResponseModel <TrainingModel>();
using (var ctx = new DFAppEntities())
{
var q = ctx.Trainings
.Include(t => t.Locations)
.Include(t => t.DanceGroups)
.Include(t => t.DanceSelections)
.Include(t => t.Users)
// .Include("TrainingMemberPresenceRegistrations.Members")
.AsQueryable();
if (filter.TrainingDate.HasValue)
{
q = q.Where(x => x.TrainingDate == filter.TrainingDate.Value);
}
if (filter.TrainingDanceGroupID.HasValue)
{
q = q.Where(x => x.TrainingDanceGroupID == filter.TrainingDanceGroupID.Value);
}
if (filter.TrainingLocationID.HasValue)
{
q = q.Where(x => x.TrainingLocationID == filter.TrainingLocationID.Value);
}
if (filter.TrainerUserID.HasValue)
{
q = q.Where(x => x.TrainerUserID == filter.TrainerUserID.Value);
}
if (!string.IsNullOrEmpty(filter.WeekDay))
{
q = q.Where(x => x.WeekDay.ToUpper() == filter.WeekDay.ToUpper());
}
if (string.IsNullOrEmpty(filter.OrderByClause))
{
// default order
filter.OrderByClause = "TrainingDate desc";
}
if (filter.PageNo < 1)
{
filter.PageNo = 1;
}
if (filter.RecordsPerPage < 1)
{
// unlimited
filter.RecordsPerPage = 1000000;
}
response.Total = q.Count();
var Data =
q.ToList()
.Select(x =>
new TrainingModel()
{
TrainingID = x.TrainingID,
TrainingDate = x.TrainingDate,
TrainingLocationID = x.TrainingLocationID,
TrainingLocationName = x.Locations.LocationName,
TrainingDanceGroupID = x.TrainingDanceGroupID,
TrainingDanceGroupName = x.DanceGroups.DanceGroupName,
WeekDay = x.WeekDay,
StartTime = (TimeSpan)x.StartTime,
EndTime = (TimeSpan)x.EndTime,
TrainerUserID = x.TrainerUserID,
TrainerUserName = (x.Users != null) ? (x.Users.FirstName + " " + x.Users.LastName) : string.Empty,
Note = x.Note //,
//TrainingMemberPresenceRegistrations = x.TrainingMemberPresenceRegistrations.Select(r =>
// new TrainingMemberPresenceRegistrationModel()
// {
// TrainingID = r.TrainingID,
// MemberID = r.MemberID,
// MemberName = r.Members.FirstName + " " + r.Members.LastName,
// IsPresent = r.IsPresent,
// AbsenceJustified = r.AbsenceJustified,
// AbsenceNote = r.AbsenceNote
// }
//)
//.OrderBy(mp => mp.MemberName)
}
)
.OrderBy(filter.OrderByClause)
.Skip((filter.PageNo - 1) * filter.RecordsPerPage)
.Take(filter.RecordsPerPage);
response.Data = Data;
}
return(response);
}
