public void CopyJobObjectDataToCategoryModelTest()
{
var testCategory = new Category()
{
CategoryId = 123765, Name = "Product Group"
};
testCategory.Tools = new List <Tool> ()
{
new Tool()
{
ToolId = 987456, Name = "Tool Name"
}
};
var groupModel = JobAssistantMapper.Map <CategoryModel>(testCategory);
Assert.NotNull(groupModel);
Assert.Equal("Product Group", testCategory.Name);
var enumerator = testCategory.Tools.GetEnumerator();
enumerator.MoveNext();
var onlyTool = enumerator.Current;
Assert.NotNull(onlyTool);
Assert.Equal("Tool Name", onlyTool.Name);
Assert.Equal(987456, onlyTool.ToolId);
enumerator.Dispose();
}
public void NullCategoryToCategoryGroupTest()
{
Job nullCategory = null;
var categoryModel = JobAssistantMapper.Map <CategoryModel>(nullCategory);
Assert.Null(categoryModel);
}
public IActionResult GetAllTools([FromQuery] int pageNumber = 0, [FromQuery] int pageSize = 25)
{
_logger.LogInformation("Returning the list of tools");
IEnumerable <ToolModel> toolModels;
try
{
var tenantDomain = _currentTenant.DomainId;
// TODO: Validate that the tenant/domain exists and based on the security context,
// TODO (continued): that the API caller should have access to it!
_logger.LogDebug($"Looking up all tool data for data tenant: {tenantDomain})");
var tools = _repo.Filter(Tool.IsMatching(tenantDomain), out var total, pageNumber, pageSize);
toolModels = JobAssistantMapper.MapObjects <ToolModel>(tools);
_logger.LogDebug("Pagination tool models (count): " + total);
var paginationMetadata = new
{
totalCount = total,
pageSize,
pageNumber,
totalPages = total / pageSize
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(paginationMetadata));
}
catch (Exception e)
{
_logger.LogError(1, e, "Failed to get all tools in DB repository");
throw;
}
return(Ok(toolModels.AsEnumerable()));
}
public async Task UpdateAccessoryValidModelWithOkResult()
{
// Arrange & Act
var mockRepo = new Mock <IRepository>();
var controller = new AccessoriesController(mockRepo.Object, _logger);
var enhancedBlackTapAndDieAccessorySet = new Accessory
{
AccessoryId = 123987,
Name = "B44710 Enhanced Black Oxide Tap and Die Set",
ModelNumber = "B44710"
};
mockRepo.Setup(repo => repo.Update(enhancedBlackTapAndDieAccessorySet)).Returns(Task.FromResult(123987));
// Act
var accessoryModel = JobAssistantMapper.Map <AccessoryModel>(enhancedBlackTapAndDieAccessorySet);
var result = await controller.UpdateAccessory(123987, accessoryModel);
// Assert
Assert.IsType <OkResult>(result);
_logger.Log(LogLevel.Debug, 0, "Logging exeution of method UpdateAccessoryValidModelWithOkResult", null,
null);
}
public void CopyCategoryObjectDataToCategoryModelTest()
{
var testCategory = new Category
{
CategoryId = 123765,
Name = "Category",
Jobs = new List <Job>()
{
new Job()
{
JobId = 765456, Name = "Job Name"
}
}
};
var categoryModel = JobAssistantMapper.Map <CategoryModel>(testCategory);
Assert.NotNull(categoryModel);
Assert.Equal("Category", testCategory.Name);
var enumerator = testCategory.Jobs.GetEnumerator();
enumerator.MoveNext();
var onlyJob = enumerator.Current;
Assert.NotNull(onlyJob);
Assert.Equal("Job Name", onlyJob.Name);
Assert.Equal(765456, onlyJob.JobId);
enumerator.Dispose();
}
public void CopyMaterialObjectDataToMaterialModelTest()
{
var testMaterial = new Material()
{
MaterialId = 123765, Name = "Material"
};
testMaterial.Tools = new List <Tool>()
{
new Tool()
{
ToolId = 112233, Name = "Tool Name"
}
};
var materialModel = JobAssistantMapper.Map <MaterialModel>(testMaterial);
Assert.NotNull(materialModel);
Assert.Equal("Material", testMaterial.Name);
var enumerator = testMaterial.Tools.GetEnumerator();
enumerator.MoveNext();
var onlyTool = enumerator.Current;
Assert.NotNull(onlyTool);
Assert.Equal("Tool Name", onlyTool.Name);
Assert.Equal(112233, onlyTool.ToolId);
enumerator.Dispose();
}
public IActionResult GetAllJobs([FromQuery] int pageNumber = 0, [FromQuery] int pageSize = 25)
{
_logger.LogInformation("Returning the list of jobs");
IEnumerable <JobModel> jobModels;
try
{
var tenantDomain = _currentTenant.DomainId;
_logger.LogDebug($"Looking up all job data for data tenant: {tenantDomain})");
var jobs = _repo.Filter(Job.IsMatching(tenantDomain), out var total, pageNumber, pageSize);
_logger.LogDebug("Pagination job models (count): " + total);
jobModels = JobAssistantMapper.MapObjects <JobModel>(jobs);
var paginationMetadata = new
{
totalCount = total,
pageSize,
pageNumber,
totalPages = total / pageSize
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(paginationMetadata));
}
catch (Exception e)
{
_logger.LogError(1, e, "Failed to get all accessories in DB repository");
throw;
}
return(Ok(jobModels.AsEnumerable()));
}
public void NullMaterialToMaterialGroupTest()
{
Job nullMaterial = null;
var materialModel = JobAssistantMapper.Map <MaterialModel>(nullMaterial);
Assert.Null(materialModel);
}
public void CopyTradeObjectDataToTradeModelTest()
{
var testTrade = new Trade {
TradeId = 123765, Name = "Trade"
};
testTrade.Tools = new List <Tool> {
new Tool {
ToolId = 112233, Name = "Tool Name"
}
};
var tradeModel = JobAssistantMapper.Map <TradeModel>(testTrade);
Assert.NotNull(tradeModel);
Assert.Equal("Trade", testTrade.Name);
var enumerator = testTrade.Tools.GetEnumerator();
enumerator.MoveNext();
var onlyTool = enumerator.Current;
Assert.NotNull(onlyTool);
Assert.Equal("Tool Name", onlyTool.Name);
Assert.Equal(112233, onlyTool.ToolId);
enumerator.Dispose();
}
public void NullJobToJobModelTest()
{
Job nullJob = null;
var jobModel = JobAssistantMapper.Map <JobModel>(nullJob);
Assert.Null(jobModel);
}
public void NullTradeToTradeGroupTest()
{
Job nullTrade = null;
var tradeModel = JobAssistantMapper.Map <TradeModel>(nullTrade);
Assert.Null(tradeModel);
}
public IActionResult GeChildCategoriessByParentCategoryId(int categoryId)
{
_logger.LogDebug("Returning child categories for the specified (parent) category: " + categoryId);
var theCategory = _repo.All <Category>().Include(c => c.Categories).Single(c => c.CategoryId == categoryId);
var categoryModel = JobAssistantMapper.Map <CategoryModel>(theCategory);
return(Ok(JobAssistantMapper.MapObjects(categoryModel.Categories)));
}
public IActionResult GetAllTenants()
{
var tenantData = _repo.Filter(Tenant.IsValid());
var tenantModels = JobAssistantMapper.MapObjects <TenantModel>(tenantData);
_logger.LogDebug("Pagination tenant models (count): " + tenantModels.Count);
return(Ok(tenantModels.AsEnumerable()));
}
public void EmptyJobToJobModelTest()
{
var emptyJob = new Job();
var jobModel = JobAssistantMapper.Map <JobModel>(emptyJob);
Assert.NotNull(jobModel);
Assert.True(string.IsNullOrEmpty(jobModel.Name));
}
public IActionResult GetJobsByCategoryId(int categoryId)
{
_logger.LogDebug("Returning jobs for the specified category: " + categoryId);
var theCategory = _repo.All <Category>().Include(c => c.Jobs).Single(c => c.CategoryId == categoryId);
var categoryModel = JobAssistantMapper.Map <CategoryModel>(theCategory);
return(Ok(JobAssistantMapper.MapObjects(categoryModel.Jobs)));
}
public void EmptyCategoryToCategoryModelTest()
{
Category emptyCategory = new Category();
var categoryModel = JobAssistantMapper.Map <CategoryModel>(emptyCategory);
Assert.NotNull(categoryModel);
Assert.True(string.IsNullOrEmpty(categoryModel.Name));
}
public void EmptyTradeToTradeModelTest()
{
var emptyTrade = new Trade();
var tradeModel = JobAssistantMapper.Map <TradeModel>(emptyTrade);
Assert.NotNull(tradeModel);
Assert.True(string.IsNullOrEmpty(tradeModel.Name));
}
public void EmptyMaterialToMaterialModelTest()
{
Material emptyMaterial = new Material();
var materialModel = JobAssistantMapper.Map <MaterialModel>(emptyMaterial);
Assert.NotNull(materialModel);
Assert.True(string.IsNullOrEmpty(materialModel.Name));
}
public IActionResult GetAssociatedMaterialsByJobId(int jobId)
{
_logger.LogDebug("Looking up materials for the specified job: " + jobId);
var theJob = _repo.All <Job>().Include(j => j.Materials).Single(j => j.JobId == jobId);
var jobModel = JobAssistantMapper.Map <JobModel>(theJob);
_logger.LogDebug("Returning the associated material data for the specified job: " + jobModel.Name);
return(Ok(JobAssistantMapper.MapObjects(jobModel.Materials)));
}
public void CopyJobObjectDataToJobModelTest()
{
var fastenJob = new Job {
JobId = 1006, Name = "Fasten"
};
var fastenModel = JobAssistantMapper.Map <JobModel>(fastenJob);
Assert.Equal("[ Fasten ]", fastenModel.Name);
}
public IActionResult GetAssociatedAccessoriesByJobId(int jobId)
{
_logger.LogDebug("Looking up accessories for the specified job: " + jobId);
var theJob = _repo.All <Job>().Include(j => j.ToolRelationships).Single(j => j.JobId == jobId);
var jobModel = JobAssistantMapper.Map <JobModel>(theJob);
_logger.LogDebug("Returning the associated accessory data for the specified job: " + jobModel.Name);
return(Ok(JobAssistantMapper.MapObjects(jobModel.Accessories)));
}
public async Task <IActionResult> GetTenantById(string domainId)
{
_logger.LogDebug("Returning the specified tenant: " + domainId);
var tenantResult = await _repo.All <Tenant>().SingleAsync(t => t.DomainId == domainId);
var tenantModel = JobAssistantMapper.Map <TenantModel>(tenantResult);
return(Ok(tenantModel));
}
public async Task <IActionResult> GetAssociatedAccessoriesByApplicationId(int applicationId)
{
var applicationResult = await _repo.All <Application>().Include(a => a.AccessoryRelationships)
.SingleAsync(a => a.ApplicationId == applicationId);
var applicationModel = JobAssistantMapper.Map <ApplicationModel>(applicationResult);
new LateModelDataBinder(_repo).BindRelatedAccessoryDataToModel(applicationModel.Accessories);
return(Ok(applicationModel.Accessories));
}
public IActionResult GetAllTrades([FromQuery] int pageNumber = 0, [FromQuery] int pageSize = 25)
{
_logger.LogInformation("Returning the list of trade objects.");
int total;
var tradeData = _repo.Filter(Trade.IsValid(), out total, pageNumber, pageSize);
var models = JobAssistantMapper.MapObjects <TradeModel>(tradeData);
_logger.LogDebug("Pagination trade models (count): " + total);
return(Ok(models.AsEnumerable()));
}
public async Task <IActionResult> GetByApplicationId(string id, [FromHeader] string queryBy)
{
var tenantDomain = _currentTenant.DomainId;
var applicationResult = await _repo.All <Application>().Include(a => a.ToolRelationships)
.Include(a => a.AccessoryRelationships)
.FirstOrDefaultAsync(ApiQueryExpression.GenerateApplicationPredicate(id, queryBy, tenantDomain));
var applicationModel = JobAssistantMapper.Map <ApplicationModel>(applicationResult);
return(Ok(applicationModel));
}
public async Task <IActionResult> GetByCategoryId(string id, [FromHeader] string queryBy)
{
_logger.LogDebug("Returning the specified category: " + id);
var tenantDomain = _currentTenant.DomainId;
var categoryResult = await _repo.All <Category>().Include(c => c.Jobs)
.SingleAsync(ApiQueryExpression.GenerateCategoryPredicate(id, queryBy, tenantDomain));
var categoryModel = JobAssistantMapper.Map <CategoryModel>(categoryResult);
return(Ok(categoryModel));
}
public async Task <IActionResult> GetAccessoryById(string id, [FromHeader] string queryBy)
{
_logger.LogDebug("Looking up accessory data for the specified id: " + id);
var tenantDomain = _currentTenant.DomainId;
var accessoryResult = await _repo.All <Accessory>()
.SingleOrDefaultAsync(ApiQueryExpression.GenerateAccessoryPredicate(id, queryBy, tenantDomain));
var accessoryModel = JobAssistantMapper.Map <AccessoryModel>(accessoryResult);
_logger.LogDebug("Returning accessory data for the specified accessory: " + accessoryModel.Name);
return(Ok(accessoryModel));
}
public async Task <IActionResult> GetByMaterialId(string id, [FromHeader] string queryBy)
{
_logger.LogDebug("Returning material data for the specified id: " + id);
var tenantDomain = _currentTenant.DomainId;
// TODO: Validate that the tenant/domain exists and based on the security context,
// TODO (continued): that the API caller should have access to it!
var materialResult = await _repo.All <Material>().Include(m => m.Applications)
.FirstOrDefaultAsync(ApiQueryExpression.GenerateMaterialPredicate(id, queryBy, tenantDomain));
var materialModel = JobAssistantMapper.Map <MaterialModel>(materialResult);
return(Ok(materialModel));
}
public async Task <IActionResult> GetToolById(string id, [FromHeader] string queryBy)
{
_logger.LogDebug("Looking up tool data associated to the specified id: " + id);
var tenantDomain = _currentTenant.DomainId;
var toolResult = await _repo.All <Tool>()
.SingleOrDefaultAsync(ApiQueryExpression.GenerateToolPredicate(id, queryBy, tenantDomain));
_logger.LogDebug("Tool data " + toolResult.Name + " (ToolId = " + toolResult.ToolId + ")");
var toolModel = JobAssistantMapper.Map <ToolModel>(toolResult);
_logger.LogDebug("Returning tool data for the specified tool: " + toolModel.Name);
return(Ok(toolModel));
}
public async Task <IActionResult> GetApplicationsByMaterialId(int materialId)
{
_logger.LogDebug("Returning associated applications for the specified material: " + materialId);
// TODO: Validate that the tenant/domain exists and based on the security context,
// TODO (continued): that the API caller should have access to it!
var materialResult = await _repo.All <Material>().Include(m => m.Applications)
.SingleAsync(m => m.MaterialId == materialId);
var materialModel = JobAssistantMapper.Map <MaterialModel>(materialResult);
_logger.LogDebug("Mapped application models (count): " + materialModel.Applications.Count);
return(Ok(materialModel.Applications));
}
