santhoshsnair/DamageAssessment_Backend
1
0
Fork 0
forked from MDCPS/DamageAssessment_Backend
Code Pull Requests Activity

Merged new dev changes

Browse Source
This commit is contained in:
uppuv 2023-09-13 13:16:42 -04:00
commit e04bccfffd
137 changed files with 2247 additions and 1254 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
DamageAssesmentApi/DamageAssesment.Api.Answers.Test/AnswersServiceTest.cs
View File

@ -98,7 +98,7 @@ namespace DamageAssesment.Api.Answers.Test
mockAnswerService.Setup(service => service.PostAnswerAsync(mockInputAnswer)).ReturnsAsync(mockResponse);
var AnswerProvider = new AnswersController(mockAnswerService.Object);
var result = (OkObjectResult)await AnswerProvider.CreateAnswer(mockInputAnswer);
var result = (OkObjectResult) await AnswerProvider.CreateAnswer(mockInputAnswer);
Assert.Equal(200, result.StatusCode);
}
@ -112,7 +112,7 @@ namespace DamageAssesment.Api.Answers.Test
mockAnswerService.Setup(service => service.PostAnswerAsync(mockInputAnswer)).ReturnsAsync(mockResponse);
var AnswerProvider = new AnswersController(mockAnswerService.Object);
var result = (BadRequestObjectResult)await AnswerProvider.CreateAnswer(mockInputAnswer);
var result = (BadRequestObjectResult) await AnswerProvider.CreateAnswer(mockInputAnswer);
Assert.Equal(400, result.StatusCode);
}
@ -126,7 +126,7 @@ namespace DamageAssesment.Api.Answers.Test
mockAnswerService.Setup(service => service.UpdateAnswerAsync(mockInputAnswer)).ReturnsAsync(mockResponse);
var AnswerProvider = new AnswersController(mockAnswerService.Object);
var result = (OkObjectResult)await AnswerProvider.UpdateAnswer(mockInputAnswer);
var result = (OkObjectResult) await AnswerProvider.UpdateAnswer(mockInputAnswer);
Assert.Equal(200, result.StatusCode);
}
@ -140,7 +140,7 @@ namespace DamageAssesment.Api.Answers.Test
mockAnswerService.Setup(service => service.UpdateAnswerAsync(mockInputAnswer)).ReturnsAsync(mockResponse);
var AnswerProvider = new AnswersController(mockAnswerService.Object);
var result = (NotFoundObjectResult)await AnswerProvider.UpdateAnswer(mockInputAnswer);
var result = (NotFoundObjectResult) await AnswerProvider.UpdateAnswer(mockInputAnswer);
Assert.Equal(404, result.StatusCode);
}
@ -154,7 +154,7 @@ namespace DamageAssesment.Api.Answers.Test
mockAnswerService.Setup(service => service.UpdateAnswerAsync(mockInputAnswer)).ReturnsAsync(mockResponse);
var AnswerProvider = new AnswersController(mockAnswerService.Object);
var result = (BadRequestObjectResult)await AnswerProvider.UpdateAnswer(mockInputAnswer);
var result = (BadRequestObjectResult) await AnswerProvider.UpdateAnswer(mockInputAnswer);
Assert.Equal(400, result.StatusCode);
}

4
DamageAssesmentApi/DamageAssesment.Api.Answers.Test/MocData.cs
View File

@ -43,9 +43,9 @@ namespace DamageAssesment.Api.Answers.Test
return (false, list, null);
}
public static async Task<Answers.Db.Answer> getInputAnswerData()
public static async Task<Answers.Models.Answer> getInputAnswerData()
{
return new Answers.Db.Answer { Id = 1, AnswerText = "Yes", Comment = "", QuestionId = 1, SurveyResponseId = 1 };
return new Answers.Models.Answer { Id = 1, AnswerText = "Yes", Comment = "", QuestionId = 1, SurveyResponseId = 1 };
}

53
DamageAssesmentApi/DamageAssesment.Api.Answers/Controllers/AnswersController.cs
View File

@ -5,7 +5,6 @@ using Microsoft.OpenApi.Any;
namespace DamageAssesment.Api.Answers.Controllers
{
[Route("api")]
[ApiController]
public class AnswersController: ControllerBase
{
@ -14,7 +13,10 @@ namespace DamageAssesment.Api.Answers.Controllers
public AnswersController(IAnswersProvider answersProvider) {
this.answerProvider=answersProvider;
}
//get all answers
/// <summary>
/// Get all answers
/// </summary>
[HttpGet("Answers")]
public async Task<ActionResult> GetAnswersAsync() {
@ -26,7 +28,11 @@ namespace DamageAssesment.Api.Answers.Controllers
return NoContent();
}
//get answer based on answerid
/// <summary>
/// Get an answer based on answerId.
/// </summary>
[HttpGet("Answers/{Id}")]
public async Task<ActionResult> GetAnswerByIdAsync(int Id)
{
@ -39,32 +45,39 @@ namespace DamageAssesment.Api.Answers.Controllers
return NotFound();
}
// get all answers based on response id
[HttpGet("AnswersByResponse/{ResponseId}")]
public async Task<IActionResult> GetAnswersByResponseId(int ResponseId)
/// <summary>
/// Get all answers based on responseId.
/// </summary>
[HttpGet("Answers/ByResponse/{responseid}")]
public async Task<IActionResult> GetAnswersByResponseId(int responseid)
{
var result = await this.answerProvider.GetAnswersAsync(ResponseId);
var result = await this.answerProvider.GetAnswersAsync(responseid);
if(result.IsSuccess)
{
return Ok(result.Answers);
}
return NoContent();
}
// get all answers based on question id
[HttpGet("AnswersByQuestion/{QuestionId}")]
public async Task<IActionResult> AnswersByQuestionId(int QuestionId)
/// <summary>
/// Get all answers based on questionId.
/// </summary>
[HttpGet("Answers/ByQuestion/{questionid}")]
public async Task<IActionResult> AnswersByQuestionId(int questionid)
{
var result = await this.answerProvider.GetAnswersByQuestionAsync(QuestionId);
var result = await this.answerProvider.GetAnswersByQuestionAsync(questionid);
if (result.IsSuccess)
{
return Ok(result.Answers);
}
return NotFound();
}
//update existing answer
/// <summary>
/// Update an existing answer.
/// </summary>
[HttpPut("Answers")]
public async Task<IActionResult> UpdateAnswer(Db.Answer answer)
public async Task<IActionResult> UpdateAnswer(Models.Answer answer)
{
if (answer != null)
{
@ -80,13 +93,16 @@ namespace DamageAssesment.Api.Answers.Controllers
}
return NotFound();
}
//save new answer
/// <summary>
/// Save a new answer.
/// </summary>
[HttpPost("Answers")]
public async Task<IActionResult> CreateAnswer(Db.Answer answer)
public async Task<IActionResult> CreateAnswer(Models.Answer answer)
{
if (answer != null)
{
var result = await this.answerProvider.PostAnswerAsync(answer);
var result = await this.answerProvider.PostAnswerAsync(answer);
if (result.IsSuccess)
{
return Ok(result.Answer);
@ -95,7 +111,10 @@ namespace DamageAssesment.Api.Answers.Controllers
}
return CreatedAtRoute("DefaultApi", new { id = answer.Id }, answer);
}
//delete existing answer
/// <summary>
/// Delete an existing answer.
/// </summary>
[HttpDelete("Answers/{id}")]
public async Task<IActionResult> DeleteAnswer(int id)
{

2
DamageAssesmentApi/DamageAssesment.Api.Answers/DamageAssesment.Api.Answers.csproj
View File

@ -4,10 +4,12 @@
<TargetFramework>net6.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
<GenerateDocumentationFile>True</GenerateDocumentationFile>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="12.0.1" />
<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="6.0.21" />
<PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.9" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="7.0.9">
<PrivateAssets>all</PrivateAssets>

8
DamageAssesmentApi/DamageAssesment.Api.Answers/Db/AnswerDbContext.cs
View File

@ -16,7 +16,13 @@ namespace DamageAssesment.Api.Answers.Db
options.UseSqlServer(_Configuration.GetConnectionString("AnswerConnection"));
}
public DbSet<Db.Answer> Answers { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity<Answer>()
.Property(item => item.Id)
.ValueGeneratedOnAdd();
}
}
}

5
DamageAssesmentApi/DamageAssesment.Api.Answers/Interfaces/IAnswersProvider.cs
View File

@ -6,8 +6,9 @@
Task<(bool IsSuccess, IEnumerable<Models.Answer> Answers, string ErrorMessage)> GetAnswersByQuestionAsync(int questionId);
Task<(bool IsSuccess, Models.Answer Answer, string ErrorMessage)> GetAnswerByIdAsync(int Id);
Task<(bool IsSuccess, IEnumerable<Models.Answer> Answers, string ErrorMessage)> GetAnswersAsync(int responseId);
Task<(bool IsSuccess, Models.Answer Answer, string ErrorMessage)> PostAnswerAsync(Db.Answer Answer);
Task<(bool IsSuccess, Models.Answer Answer, string ErrorMessage)> UpdateAnswerAsync(Db.Answer Answer);
Task<(bool IsSuccess, Models.Answer Answer, string ErrorMessage)> PostAnswerAsync(Models.Answer Answer);
Task<(bool IsSuccess, Models.Answer Answer, string ErrorMessage)> UpdateAnswerAsync(Models.Answer Answer);
Task<(bool IsSuccess, Models.Answer Answer, string ErrorMessage)> DeleteAnswerAsync(int Id);
void SeedData();
}
}

1
DamageAssesmentApi/DamageAssesment.Api.Answers/Profiles/AnswersProfile.cs
View File

@ -7,6 +7,7 @@ namespace DamageAssesment.Api.Answers.Profiles
public AnswersProfile()
{
CreateMap<Db.Answer,Models.Answer>();
CreateMap<Models.Answer, Db.Answer>();
}
}
}

12
DamageAssesmentApi/DamageAssesment.Api.Answers/Program.cs
View File

@ -2,6 +2,7 @@ using DamageAssesment.Api.Answers.Db;
using DamageAssesment.Api.Answers.Interfaces;
using DamageAssesment.Api.Answers.Providers;
using Microsoft.EntityFrameworkCore;
using System.Reflection;
var builder = WebApplication.CreateBuilder(args);
@ -10,15 +11,24 @@ var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
//builder.Services.AddSwaggerGen();
builder.Services.AddSwaggerGen(c =>
{
// Include XML comments from your assembly
var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
c.IncludeXmlComments(xmlPath);
});
builder.Services.AddScoped<IAnswersProvider, AnswersProvider>();
builder.Services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies()); //4/30
builder.Services.AddDbContext<AnswerDbContext>(option =>
{
option.UseSqlServer("AnswerConnection");
});
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{

28
DamageAssesmentApi/DamageAssesment.Api.Answers/Providers/AnswerProvider.cs
View File

@ -18,12 +18,11 @@ namespace DamageAssesment.Api.Answers.Providers
this.answerDbContext = answerDbContext;
this.logger = logger;
this.mapper = mapper;
SeedData();
//SeedData();
}
public async Task<(bool IsSuccess, IEnumerable<Models.Answer> Answers, string ErrorMessage)> GetAnswersAsync()
{
try
{
logger?.LogInformation("Query Question");
@ -108,16 +107,17 @@ namespace DamageAssesment.Api.Answers.Providers
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.Answer Answer, string ErrorMessage)> PostAnswerAsync(Db.Answer Answer)
public async Task<(bool IsSuccess, Models.Answer Answer, string ErrorMessage)> PostAnswerAsync(Models.Answer Answer)
{
try
{
logger?.LogInformation("Query Answer");
if (!AnswerExists(Answer.Id))
{
answerDbContext.Answers.Add(Answer);
answerDbContext.SaveChanges();
var result = mapper.Map<Db.Answer, Models.Answer>(Answer);
Db.Answer answer = mapper.Map<Models.Answer, Db.Answer>(Answer);
answerDbContext.Answers.Add(answer);
await answerDbContext.SaveChangesAsync();
var result = mapper.Map<Db.Answer, Models.Answer>(answer);
return (true, result, null);
}
return (false, null, "Answer is already exits");
@ -128,7 +128,7 @@ namespace DamageAssesment.Api.Answers.Providers
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.Answer Answer, string ErrorMessage)> UpdateAnswerAsync(Db.Answer Answer)
public async Task<(bool IsSuccess, Models.Answer Answer, string ErrorMessage)> UpdateAnswerAsync(Models.Answer Answer)
{
try
{
@ -137,9 +137,10 @@ namespace DamageAssesment.Api.Answers.Providers
var existing = answerDbContext.Answers.AsNoTracking().FirstOrDefault(x => x.Id == Answer.Id);
if (existing != null)
{
answerDbContext.Answers.Update(Answer);
answerDbContext.SaveChanges();
return (true, mapper.Map<Db.Answer, Models.Answer>(Answer), "Successful");
Db.Answer answer = mapper.Map<Models.Answer, Db.Answer>(Answer);
answerDbContext.Answers.Update(answer);
await answerDbContext.SaveChangesAsync();
return (true, mapper.Map<Db.Answer, Models.Answer>(answer), "Successful");
}
else
{
@ -152,7 +153,6 @@ namespace DamageAssesment.Api.Answers.Providers
logger?.LogInformation($"{Answer} Bad Request");
return (false, null, "Bad request");
}
}
catch (Exception ex)
{
@ -187,7 +187,7 @@ namespace DamageAssesment.Api.Answers.Providers
return answerDbContext.Answers.AsNoTracking().Count(e => e.Id == id) > 0;
}
private void SeedData()
public void SeedData()
{
if (!answerDbContext.Answers.Any())
{
@ -199,10 +199,6 @@ namespace DamageAssesment.Api.Answers.Providers
answerDbContext.Answers.Add(new Db.Answer() { AnswerText = "No", Comment = "No Comment", QuestionId = 3, SurveyResponseId = 2 });
answerDbContext.SaveChanges();
}
}
}
}

3
DamageAssesmentApi/DamageAssesment.Api.Answers/appsettings.json
View File

@ -1,4 +1,7 @@
{
"JwtSettings": {
"securitykey": "bWlhbWkgZGFkZSBzY2hvb2xzIHNlY3JldCBrZXk="
},
"Logging": {
"LogLevel": {
"Default": "Information",

8
DamageAssesmentApi/DamageAssesment.Api.Attachments.Test/AttachmentsServiceTest.cs
View File

@ -80,7 +80,7 @@ namespace DamageAssesment.Api.Attachments.Test
mockAttachmentService.Setup(service => service.PostAttachmentAsync(mockInputAttachment)).ReturnsAsync(mockResponse);
var AttachmentProvider = new AttachmentsController(mockAttachmentService.Object, mockUploadService.Object);
var result = (NoContentResult)await AttachmentProvider.UploadAttachmentAsync(AttachmentResponse);
var result = (NoContentResult) await AttachmentProvider.UploadAttachmentAsync(AttachmentResponse);
Assert.Equal(204, result.StatusCode);
}
@ -96,7 +96,7 @@ namespace DamageAssesment.Api.Attachments.Test
var AttachmentProvider = new AttachmentsController(mockAttachmentService.Object, mockUploadService.Object);
AttachmentInfo attachmentInfo=new AttachmentInfo();
var result = (BadRequestObjectResult)await AttachmentProvider.UploadAttachmentAsync(attachmentInfo);
var result = (BadRequestObjectResult) await AttachmentProvider.UploadAttachmentAsync(attachmentInfo);
Assert.Equal(400, result.StatusCode);
}
@ -112,7 +112,7 @@ namespace DamageAssesment.Api.Attachments.Test
mockAttachmentService.Setup(service => service.PostAttachmentAsync(mockInputAttachment)).ReturnsAsync(mockResponse);
var AttachmentProvider = new AttachmentsController(mockAttachmentService.Object, mockUploadService.Object);
var result = (NoContentResult)await AttachmentProvider.UpdateAttachmentAsync(AttachmentResponse);
var result = (NoContentResult) await AttachmentProvider.UpdateAttachmentAsync(AttachmentResponse);
Assert.Equal(204, result.StatusCode);
}
@ -128,7 +128,7 @@ namespace DamageAssesment.Api.Attachments.Test
var AttachmentProvider = new AttachmentsController(mockAttachmentService.Object, mockUploadService.Object);
AttachmentInfo attachmentInfo = new AttachmentInfo();
var result = (BadRequestObjectResult)await AttachmentProvider.UpdateAttachmentAsync(attachmentInfo);
var result = (BadRequestObjectResult) await AttachmentProvider.UpdateAttachmentAsync(attachmentInfo);
Assert.Equal(400, result.StatusCode);
}

8
DamageAssesmentApi/DamageAssesment.Api.Attachments.Test/MockData.cs
View File

@ -17,7 +17,7 @@ namespace DamageAssesment.Api.Attachments.Test
for (int i = 0; i < 10; i++)
{
list.Add(new Attachments.Models.Attachment(i, Guid.NewGuid().ToString() + "@gmail.com")
list.Add(new Attachments.Models.Attachment()
{
Id = i,
AnswerId = i,
@ -73,10 +73,10 @@ namespace DamageAssesment.Api.Attachments.Test
return (false, list, null);
}
public static async Task<List<Attachments.Db.Attachment>> getInputAttachmentData()
public static async Task<List<Attachments.Models.Attachment>> getInputAttachmentData()
{
List<Attachments.Db.Attachment> Attachments=new List<Db.Attachment>();
Attachments.Add(new Db.Attachment{ Id = 0, AnswerId = 10, ResponseId = 10, URI = "sample", IsDeleted = false,FileName="sample1" }) ;
List<Attachments.Models.Attachment> Attachments=new List<Models.Attachment>();
Attachments.Add(new Models.Attachment{ Id = 0, AnswerId = 10, ResponseId = 10, URI = "sample", IsDeleted = false,FileName="sample1" }) ;
return Attachments;
}

39
DamageAssesmentApi/DamageAssesment.Api.Attachments/Controllers/AttachmentsController.cs
View File

@ -7,7 +7,6 @@ using System.Net.Http.Headers;
namespace DamageAssesment.Api.Attachments.Controllers
{
[Route("api")]
[ApiController]
public class AttachmentsController : ControllerBase
{
@ -19,7 +18,10 @@ namespace DamageAssesment.Api.Attachments.Controllers
this.AttachmentProvider = AttachmentsProvider;
this.UploadService = uploadService;
}
//get all Attachments
/// <summary>
/// Get all attachments.
/// </summary>
[HttpGet("Attachments")]
public async Task<ActionResult> GetAttachmentsAsync()
{
@ -32,7 +34,9 @@ namespace DamageAssesment.Api.Attachments.Controllers
return NoContent();
}
//get all Attachment by Id
/// <summary>
/// Get all attachments by attachmentId.
/// </summary>
[HttpGet("Attachments/{id}")]
public async Task<ActionResult> GetAttachmentbyIdAsync(int id)
{
@ -73,7 +77,10 @@ namespace DamageAssesment.Api.Attachments.Controllers
// }
//}
//Save new Attachment
/// <summary>
/// Save new Attachment(s)
/// </summary>
[HttpPost("Attachments"), DisableRequestSizeLimit]
public async Task<IActionResult> UploadAttachmentAsync(AttachmentInfo attachmentInfo)
{
@ -81,9 +88,9 @@ namespace DamageAssesment.Api.Attachments.Controllers
{
if (attachmentInfo.Answers.Count > 0)
{
var Attachments = await this.AttachmentProvider.GetAttachmentCounter();
List<Db.Attachment> attachments = UploadService.UploadAttachment(attachmentInfo.ResponseId, Attachments.counter, attachmentInfo.Answers);
var result = await this.AttachmentProvider.PostAttachmentAsync(attachments);
var Attachments = await this.AttachmentProvider.GetAttachmentCounter();
List<Models.Attachment> attachments = UploadService.UploadAttachment(attachmentInfo.ResponseId, Attachments.counter, attachmentInfo.Answers);
var result = await this.AttachmentProvider.PostAttachmentAsync(attachments);
if (result.IsSuccess)
{
return Ok(result.Attachments);
@ -97,8 +104,10 @@ namespace DamageAssesment.Api.Attachments.Controllers
return BadRequest($"Internal server error: {ex}");
}
}
/// <summary>
/// Modify an new attachment.
/// </summary>
//Save new Attachment
[HttpPut("Attachments"), DisableRequestSizeLimit]
public async Task<IActionResult> UpdateAttachmentAsync(AttachmentInfo attachmentInfo)
{
@ -106,10 +115,10 @@ namespace DamageAssesment.Api.Attachments.Controllers
{
if (attachmentInfo.Answers.Count > 0)
{
var res = await this.AttachmentProvider.GetAttachmentInfo(attachmentInfo.Answers);
var res = await this.AttachmentProvider.GetAttachmentInfo(attachmentInfo.Answers);
if (res.IsSuccess)
{
List<Db.Attachment> attachments = UploadService.UpdateAttachments(attachmentInfo.ResponseId, attachmentInfo.Answers, res.Attachments);
List<Models.Attachment> attachments = UploadService.UpdateAttachments(attachmentInfo.ResponseId, attachmentInfo.Answers, res.Attachments);
var result = await this.AttachmentProvider.PutAttachmentAsync(attachments);
if (result.IsSuccess)
{
@ -126,12 +135,14 @@ namespace DamageAssesment.Api.Attachments.Controllers
return BadRequest($"Internal server error: {ex}");
}
}
//delete existing Attachment
[HttpDelete("Delete")]
public async Task<IActionResult> DeleteAttachment(int Id)
/// <summary>
/// Delete an existing attachment.
/// </summary>
[HttpDelete("Attachments/{id}")]
public async Task<IActionResult> DeleteAttachment(int id)
{
// database soft delete
var result = await this.AttachmentProvider.DeleteAttachmentAsync(Id);
var result = await this.AttachmentProvider.DeleteAttachmentAsync(id);
if (result.IsSuccess)
{
// deleting file from folder

1
DamageAssesmentApi/DamageAssesment.Api.Attachments/DMS_Attachments/Active/Response-1/Answer-1/Attachment_1.txt
View File

@ -1 +0,0 @@
sample

6
DamageAssesmentApi/DamageAssesment.Api.Attachments/DamageAssesment.Api.Attachments.csproj
View File

@ -4,13 +4,17 @@
<TargetFramework>net6.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
<GenerateDocumentationFile>True</GenerateDocumentationFile>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="12.0.1" />
<PackageReference Include="Azure.Storage.Blobs" Version="12.16.0" />
<PackageReference Include="Microsoft.AspNetCore.Hosting" Version="2.1.1" />
<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="6.0.21" />
<PackageReference Include="Microsoft.AspNetCore.Hosting" Version="2.2.7" />
<PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.9" />
<PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="7.0.5" />
<PackageReference Include="Microsoft.AspNetCore.Hosting" Version="2.1.1" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="7.0.9">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

7
DamageAssesmentApi/DamageAssesment.Api.Attachments/Db/AttachmentsDbContext.cs
View File

@ -16,5 +16,12 @@ namespace DamageAssesment.Api.Attachments.Db
options.UseSqlServer(_Configuration.GetConnectionString("AttachmentConnection"));
}
public DbSet<Db.Attachment> Attachments { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity<Attachment>()
.Property(item => item.Id)
.ValueGeneratedOnAdd();
}
}
}

4
DamageAssesmentApi/DamageAssesment.Api.Attachments/Interfaces/IAttachmentsProvider.cs
View File

@ -6,8 +6,8 @@ namespace DamageAssesment.Api.Attachments.Interfaces
{
Task<(bool IsSuccess, IEnumerable<Models.Attachment> Attachments, string ErrorMessage)> GetAttachmentsAsync();
Task<(bool IsSuccess, Models.Attachment Attachment, string ErrorMessage)> GetAttachmentByIdAsync(int Id);
Task<(bool IsSuccess, IEnumerable<Models.Attachment> Attachments, string ErrorMessage)> PostAttachmentAsync(List<Db.Attachment> Attachments);
Task<(bool IsSuccess, IEnumerable<Models.Attachment> Attachments, string ErrorMessage)> PutAttachmentAsync(List<Db.Attachment> Attachments);
Task<(bool IsSuccess, IEnumerable<Models.Attachment> Attachments, string ErrorMessage)> PostAttachmentAsync(List<Models.Attachment> Attachments);
Task<(bool IsSuccess, IEnumerable<Models.Attachment> Attachments, string ErrorMessage)> PutAttachmentAsync(List<Models.Attachment> Attachments);
Task<(bool IsSuccess, Models.Attachment Attachment, string Path)> DeleteAttachmentAsync(int Id);
Task<(bool IsSuccess, int counter, string Path)> DeleteAttachmentsAsync(int responseId, int answerId);
Task<(bool IsSuccess, int counter, string Path)> DeleteBulkAttachmentsAsync(int responseId, List<int> answerIds);

6
DamageAssesmentApi/DamageAssesment.Api.Attachments/Interfaces/IUploadService.cs
View File

@ -4,9 +4,9 @@ namespace DamageAssesment.Api.Attachments.Interfaces
{
public interface IUploadService
{
List<Db.Attachment> UploadAttachment(int responseId,int answerId, int counter, List<IFormFile> postedFile);
List<Db.Attachment> UploadAttachment(int responseId, int counter, List<AnswerInfo> answers);
public List<Db.Attachment> UpdateAttachments(int responseId, List<AnswerInfo> answers, IEnumerable<Models.Attachment> attachments);
List<Models.Attachment> UploadAttachment(int responseId,int answerId, int counter, List<IFormFile> postedFile);
List<Models.Attachment> UploadAttachment(int responseId, int counter, List<AnswerInfo> answers);
public List<Models.Attachment> UpdateAttachments(int responseId, List<AnswerInfo> answers, IEnumerable<Models.Attachment> attachments);
void Deletefile(string path);
void Movefile(string path);
}

10
DamageAssesmentApi/DamageAssesment.Api.Attachments/Models/Attachment.cs
View File

@ -13,10 +13,10 @@ namespace DamageAssesment.Api.Attachments.Models
public bool IsDeleted { get; set; }
public string FileName { get; set; }
public Attachment(int answerId, string uri)
{
this.AnswerId = answerId;
this.URI = uri;
}
//public Attachment(int answerId, string uri)
//{
// this.AnswerId = answerId;
// this.URI = uri;
//}
}
}

1
DamageAssesmentApi/DamageAssesment.Api.Attachments/Profiles/AttachmentsProfiles.cs
View File

@ -5,6 +5,7 @@
public AttachmentsProfiles()
{
CreateMap<Db.Attachment, Models.Attachment>();
CreateMap<Models.Attachment, Db.Attachment>();
}
}
}

10
DamageAssesmentApi/DamageAssesment.Api.Attachments/Program.cs
View File

@ -4,6 +4,7 @@ using DamageAssesment.Api.Attachments.Providers;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.FileProviders;
using System.Reflection;
var builder = WebApplication.CreateBuilder(args);
@ -12,7 +13,14 @@ var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
//builder.Services.AddSwaggerGen();
builder.Services.AddSwaggerGen(c =>
{
// Include XML comments from your assembly
var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
c.IncludeXmlComments(xmlPath);
});
builder.Services.AddScoped<IAttachmentsProvider, AttachmentsProvider>();
builder.Services.AddScoped<IUploadService, UploadService>();
builder.Services.AddScoped<IAzureBlobService,AzureBlobService>();

33
DamageAssesmentApi/DamageAssesment.Api.Attachments/Providers/AttachmentsProvider.cs
View File

@ -21,7 +21,7 @@ namespace DamageAssesment.Api.Attachments.Providers
this.logger = logger;
this.mapper = mapper;
this.uploadservice = uploadservice;
SeedData();
//SeedData();
}
public async Task<(bool IsSuccess, IEnumerable<Models.Attachment> Attachments, string ErrorMessage)> GetAttachmentsAsync()
{
@ -65,14 +65,15 @@ namespace DamageAssesment.Api.Attachments.Providers
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, IEnumerable<Models.Attachment> Attachments, string ErrorMessage)> PostAttachmentAsync(List<Db.Attachment> Attachments)
public async Task<(bool IsSuccess, IEnumerable<Models.Attachment> Attachments, string ErrorMessage)> PostAttachmentAsync(List<Models.Attachment> Attachments)
{
try
{
logger?.LogInformation("Query Attachment");
AttachmentDbContext.Attachments.AddRange(Attachments);
AttachmentDbContext.SaveChanges();
var result = mapper.Map<IEnumerable<Db.Attachment>, IEnumerable<Models.Attachment>>(Attachments);
List<Db.Attachment> attachments = mapper.Map<List<Models.Attachment>, List<Db.Attachment>>(Attachments);
AttachmentDbContext.Attachments.AddRange(attachments);
await AttachmentDbContext.SaveChangesAsync();
var result = mapper.Map<IEnumerable<Db.Attachment>, IEnumerable<Models.Attachment>>(attachments);
return (true, result, null);
}
catch (Exception ex)
@ -82,14 +83,15 @@ namespace DamageAssesment.Api.Attachments.Providers
}
}
public async Task<(bool IsSuccess, IEnumerable<Models.Attachment> Attachments, string ErrorMessage)> PutAttachmentAsync(List<Db.Attachment> Attachments)
public async Task<(bool IsSuccess, IEnumerable<Models.Attachment> Attachments, string ErrorMessage)> PutAttachmentAsync(List<Models.Attachment> Attachments)
{
try
{
logger?.LogInformation("Query Attachment");
AttachmentDbContext.Attachments.UpdateRange(Attachments);
AttachmentDbContext.SaveChanges();
var result = mapper.Map<IEnumerable<Db.Attachment>, IEnumerable<Models.Attachment>>(Attachments);
List<Db.Attachment> attachments = mapper.Map<List<Models.Attachment>, List<Db.Attachment>>(Attachments);
AttachmentDbContext.Attachments.UpdateRange(attachments);
await AttachmentDbContext.SaveChangesAsync();
var result = mapper.Map<IEnumerable<Db.Attachment>, IEnumerable<Models.Attachment>>(attachments);
return (true, result, null);
}
catch (Exception ex)
@ -108,7 +110,7 @@ namespace DamageAssesment.Api.Attachments.Providers
if (Attachments.Count > 0)
{
AttachmentDbContext.Attachments.RemoveRange(Attachments);
AttachmentDbContext.SaveChanges();
await AttachmentDbContext.SaveChangesAsync();
}
return (true, AttachmentId, "");
}
@ -141,7 +143,7 @@ namespace DamageAssesment.Api.Attachments.Providers
if (Attachments.Count > 0)
{
AttachmentDbContext.Attachments.RemoveRange(Attachments);
AttachmentDbContext.SaveChanges();
await AttachmentDbContext.SaveChangesAsync();
}
return (true, AttachmentId, "");
}
@ -152,7 +154,7 @@ namespace DamageAssesment.Api.Attachments.Providers
return (false, AttachmentId, "");
}
}
public async Task<(bool IsSuccess, IEnumerable<Models.Attachment> Attachments, string ErrorMessage)>GetAttachmentInfo(List<AnswerInfo> answers)
public async Task<(bool IsSuccess, IEnumerable<Models.Attachment> Attachments, string ErrorMessage)> GetAttachmentInfo(List<AnswerInfo> answers)
{
try
{
@ -181,7 +183,7 @@ namespace DamageAssesment.Api.Attachments.Providers
}
Attachment.IsDeleted = true;
AttachmentDbContext.Attachments.Update(Attachment);
AttachmentDbContext.SaveChanges();
await AttachmentDbContext.SaveChangesAsync();
return (true, mapper.Map<Db.Attachment, Models.Attachment>(Attachment), $"Attachment {Id} is deleted");
}
catch (Exception ex)
@ -204,10 +206,11 @@ namespace DamageAssesment.Api.Attachments.Providers
FileModel fileModel= new FileModel(){AttachmentId=0,FileName="Sample",FileContent= "c2FtcGxl",FileExtension=".txt"};
List<AnswerInfo> answerInfos=new List<AnswerInfo>();
answerInfos.Add(new AnswerInfo(){ AnswerId = 1,postedFiles=new List<FileModel> { fileModel }});
List<Db.Attachment> attachments = uploadservice.UploadAttachment(1, 0, answerInfos);
List<Models.Attachment> attachments = uploadservice.UploadAttachment(1, 0, answerInfos);
if (attachments.Count > 0)
{
AttachmentDbContext.Attachments.AddRange(attachments);
List<Db.Attachment> Attachments = mapper.Map<List<Models.Attachment>, List<Db.Attachment>>(attachments);
AttachmentDbContext.Attachments.AddRange(Attachments);
AttachmentDbContext.SaveChanges();
}
}

20
DamageAssesmentApi/DamageAssesment.Api.Attachments/Providers/UploadService.cs
View File

@ -24,7 +24,7 @@ namespace DamageAssesment.Api.Attachments.Providers
uploadpath = configuration.GetValue<string>("Fileupload:folderpath");
Deletepath = configuration.GetValue<string>("Fileupload:Deletepath");
}
public List<Db.Attachment> UploadAttachment(int responseId,int answerId,int counter, List<IFormFile> postedFile)
public List<Models.Attachment> UploadAttachment(int responseId,int answerId,int counter, List<IFormFile> postedFile)
{
var pathToSave = Path.Combine(Directory.GetCurrentDirectory(), uploadpath);
String responseDirectory = "Response-" + responseId;
@ -42,7 +42,7 @@ namespace DamageAssesment.Api.Attachments.Providers
Deletefile(searchFile);
}
}
List<Db.Attachment> attachments = new List<Db.Attachment>();
List<Models.Attachment> attachments = new List<Models.Attachment>();
foreach (IFormFile item in postedFile)
{
@ -55,15 +55,15 @@ namespace DamageAssesment.Api.Attachments.Providers
{
item.CopyTo(stream);
}
attachments.Add(new Db.Attachment { AnswerId = answerId, ResponseId = responseId, IsDeleted = false, FileName = UserfileName, URI = dbPath });
attachments.Add(new Models.Attachment { AnswerId = answerId, ResponseId = responseId, IsDeleted = false, FileName = UserfileName, URI = dbPath });
}
return attachments;
}
public List<Db.Attachment> UploadAttachment(int responseId, int counter,List<AnswerInfo> answers)
public List<Models.Attachment> UploadAttachment(int responseId, int counter,List<AnswerInfo> answers)
{
List<Db.Attachment> attachments = new List<Db.Attachment>();
List<Models.Attachment> attachments = new List<Models.Attachment>();
try
{
foreach (var item in answers)
@ -94,20 +94,20 @@ namespace DamageAssesment.Api.Attachments.Providers
var dbPath = Path.Combine(fullDirectoryPath, fileName);
File.WriteAllBytes(dbPath, Convert.FromBase64String(file.FileContent));
attachments.Add(new Db.Attachment { AnswerId = answerId, ResponseId = responseId, IsDeleted = false, FileName = UserfileName, URI = dbPath });
attachments.Add(new Models.Attachment { AnswerId = answerId, ResponseId = responseId, IsDeleted = false, FileName = UserfileName, URI = dbPath });
}
}
return attachments;
}
catch (Exception ex) {
return new List<Db.Attachment>();
return new List<Models.Attachment>();
}
}
public List<Db.Attachment> UpdateAttachments(int responseId,List<AnswerInfo> answers,IEnumerable<Models.Attachment> attachments)
public List<Models.Attachment> UpdateAttachments(int responseId,List<AnswerInfo> answers,IEnumerable<Models.Attachment> attachments)
{
List<Db.Attachment> Dbattachments = new List<Db.Attachment>();
List<Models.Attachment> Dbattachments = new List<Models.Attachment>();
foreach (Models.Attachment searchFile in attachments)
{
Deletefile(searchFile.URI);
@ -131,7 +131,7 @@ namespace DamageAssesment.Api.Attachments.Providers
var dbPath = Path.Combine(fullDirectoryPath, fileName);
File.WriteAllBytes(dbPath, Convert.FromBase64String(file.FileContent));
Dbattachments.Add(new Db.Attachment { Id=attachment.Id, AnswerId = answerId, ResponseId = responseId, IsDeleted = false, FileName = UserfileName, URI = dbPath });
Dbattachments.Add(new Models.Attachment { Id=attachment.Id, AnswerId = answerId, ResponseId = responseId, IsDeleted = false, FileName = UserfileName, URI = dbPath });
}
}
return Dbattachments;

3
DamageAssesmentApi/DamageAssesment.Api.Attachments/appsettings.json
View File

@ -1,4 +1,7 @@
{
"JwtSettings": {
"securitykey": "bWlhbWkgZGFkZSBzY2hvb2xzIHNlY3JldCBrZXk="
},
"Logging": {
"LogLevel": {
"Default": "Information",

9
DamageAssesmentApi/DamageAssesment.Api.Documents/Db/DocumentDbContext.cs
View File

@ -7,8 +7,15 @@ namespace DamageAssesment.Api.Documents.Db
{
public class DocumentDbContext : DbContext
{
public DocumentDbContext(DbContextOptions options) : base(options)
private IConfiguration _Configuration { get; set; }
public DocumentDbContext(DbContextOptions options, IConfiguration configuration) : base(options)
{
_Configuration = configuration;
}
protected override void OnConfiguring(DbContextOptionsBuilder options)
{
// connect to sql server with connection string from app settings
options.UseSqlServer(_Configuration.GetConnectionString("DocumentConnection"));
}
public DbSet<Db.Document> Documents { get; set; }
public DbSet<Db.LinkType> LinkTypes { get; set; }

2
DamageAssesmentApi/DamageAssesment.Api.Documents/Program.cs
View File

@ -17,7 +17,7 @@ builder.Services.AddScoped<IAzureBlobService, AzureBlobService>();
builder.Services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies()); //4/30
builder.Services.AddDbContext<DocumentDbContext>(option =>
{
option.UseInMemoryDatabase("DocumentConnection");
option.UseSqlServer("DocumentConnection");
});
var app = builder.Build();

3
DamageAssesmentApi/DamageAssesment.Api.Documents/appsettings.json
View File

@ -6,6 +6,9 @@
}
},
"AllowedHosts": "*",
"ConnectionStrings": {
"DocumentConnection": "Server=DESKTOP-OF5DPLQ\\SQLEXPRESS;Database=da_survey_dev;Trusted_Connection=True;TrustServerCertificate=True;"
},
"Fileupload": {
"folderpath": "DASA_Documents/Active",
"Deletepath": "DASA_Documents/Deleted"

36
DamageAssesmentApi/DamageAssesment.Api.Employees.Test/EmployeeServiceTest.cs
View File

@ -43,11 +43,11 @@ namespace DamageAssesment.Api.Employees.Test
public async Task GetEmployeeAsync_ShouldReturnStatusCode200()
{
var mockEmployeeService = new Mock<IEmployeesProvider>();
var mockResponse = await MockData.getOkResponse("Emp1");
mockEmployeeService.Setup(service => service.GetEmployeeByIdAsync("Emp1")).ReturnsAsync(mockResponse);
var mockResponse = await MockData.getOkResponse(1);
mockEmployeeService.Setup(service => service.GetEmployeeByIdAsync(1)).ReturnsAsync(mockResponse);
var EmployeeProvider = new EmployeesController(mockEmployeeService.Object);
var result = (OkObjectResult)await EmployeeProvider.GetEmployeeByIdAsync("Emp1");
var result = (OkObjectResult)await EmployeeProvider.GetEmployeeByIdAsync(1);
Assert.Equal(200, result.StatusCode);
}
@ -57,10 +57,10 @@ namespace DamageAssesment.Api.Employees.Test
{
var mockEmployeeService = new Mock<IEmployeesProvider>();
var mockResponse = await MockData.getNotFoundResponse();
mockEmployeeService.Setup(service => service.GetEmployeeByIdAsync("Emp99")).ReturnsAsync(mockResponse);
mockEmployeeService.Setup(service => service.GetEmployeeByIdAsync(99999)).ReturnsAsync(mockResponse);
var EmployeeProvider = new EmployeesController(mockEmployeeService.Object);
var result = (NotFoundResult)await EmployeeProvider.GetEmployeeByIdAsync("Emp99");
var result = (NotFoundResult)await EmployeeProvider.GetEmployeeByIdAsync(99999);
Assert.Equal(404, result.StatusCode);
}
@ -68,7 +68,7 @@ namespace DamageAssesment.Api.Employees.Test
public async Task PostEmployeeAsync_ShouldReturnStatusCode200()
{
var mockEmployeeService = new Mock<IEmployeesProvider>();
var mockResponse = await MockData.getOkResponse("Emp1");
var mockResponse = await MockData.getOkResponse(1);
var mockInputEmployee = await MockData.getInputEmployeeData();
mockEmployeeService.Setup(service => service.PostEmployeeAsync(mockInputEmployee)).ReturnsAsync(mockResponse);
@ -96,12 +96,12 @@ namespace DamageAssesment.Api.Employees.Test
public async Task PutEmployeeAsync_ShouldReturnStatusCode200()
{
var mockEmployeeService = new Mock<IEmployeesProvider>();
var mockResponse = await MockData.getOkResponse("Emp1");
var mockResponse = await MockData.getOkResponse(1);
var mockInputEmployee = await MockData.getInputEmployeeData();
mockEmployeeService.Setup(service => service.UpdateEmployeeAsync(mockInputEmployee)).ReturnsAsync(mockResponse);
mockEmployeeService.Setup(service => service.UpdateEmployeeAsync(1,mockInputEmployee)).ReturnsAsync(mockResponse);
var EmployeeProvider = new EmployeesController(mockEmployeeService.Object);
var result = (OkObjectResult)await EmployeeProvider.UpdateEmployee(mockInputEmployee);
var result = (OkObjectResult)await EmployeeProvider.UpdateEmployee(1,mockInputEmployee);
Assert.Equal(200, result.StatusCode);
}
@ -112,10 +112,10 @@ namespace DamageAssesment.Api.Employees.Test
var mockEmployeeService = new Mock<IEmployeesProvider>();
var mockResponse = await MockData.getNotFoundResponse();
var mockInputEmployee = await MockData.getInputEmployeeData();
mockEmployeeService.Setup(service => service.UpdateEmployeeAsync(mockInputEmployee)).ReturnsAsync(mockResponse);
mockEmployeeService.Setup(service => service.UpdateEmployeeAsync(1, mockInputEmployee)).ReturnsAsync(mockResponse);
var EmployeeProvider = new EmployeesController(mockEmployeeService.Object);
var result = (NotFoundObjectResult)await EmployeeProvider.UpdateEmployee(mockInputEmployee);
var result = (NotFoundObjectResult)await EmployeeProvider.UpdateEmployee(1, mockInputEmployee);
Assert.Equal(404, result.StatusCode);
}
@ -126,10 +126,10 @@ namespace DamageAssesment.Api.Employees.Test
var mockEmployeeService = new Mock<IEmployeesProvider>();
var mockResponse = await MockData.getBadRequestResponse();
var mockInputEmployee = await MockData.getInputEmployeeData();
mockEmployeeService.Setup(service => service.UpdateEmployeeAsync(mockInputEmployee)).ReturnsAsync(mockResponse);
mockEmployeeService.Setup(service => service.UpdateEmployeeAsync(1, mockInputEmployee)).ReturnsAsync(mockResponse);
var EmployeeProvider = new EmployeesController(mockEmployeeService.Object);
var result = (BadRequestObjectResult)await EmployeeProvider.UpdateEmployee(mockInputEmployee);
var result = (BadRequestObjectResult)await EmployeeProvider.UpdateEmployee(1, mockInputEmployee);
Assert.Equal(400, result.StatusCode);
}
@ -138,12 +138,12 @@ namespace DamageAssesment.Api.Employees.Test
public async Task DeleteEmployeeAsync_ShouldReturnStatusCode200()
{
var mockEmployeeService = new Mock<IEmployeesProvider>();
var mockResponse = await MockData.getOkResponse("Emp1");
var mockResponse = await MockData.getOkResponse(1);
mockEmployeeService.Setup(service => service.DeleteEmployeeAsync("Emp1")).ReturnsAsync(mockResponse);
mockEmployeeService.Setup(service => service.DeleteEmployeeAsync(1)).ReturnsAsync(mockResponse);
var EmployeeProvider = new EmployeesController(mockEmployeeService.Object);
var result = (OkObjectResult)await EmployeeProvider.DeleteEmployee("Emp1");
var result = (OkObjectResult)await EmployeeProvider.DeleteEmployee(1);
Assert.Equal(200, result.StatusCode);
}
@ -153,10 +153,10 @@ namespace DamageAssesment.Api.Employees.Test
{
var mockEmployeeService = new Mock<IEmployeesProvider>();
var mockResponse = await MockData.getNotFoundResponse();
mockEmployeeService.Setup(service => service.DeleteEmployeeAsync("Emp1")).ReturnsAsync(mockResponse);
mockEmployeeService.Setup(service => service.DeleteEmployeeAsync(1)).ReturnsAsync(mockResponse);
var EmployeeProvider = new EmployeesController(mockEmployeeService.Object);
var result = (NotFoundResult)await EmployeeProvider.DeleteEmployee("Emp1");
var result = (NotFoundResult)await EmployeeProvider.DeleteEmployee(1);
Assert.Equal(404, result.StatusCode);
}

18
DamageAssesmentApi/DamageAssesment.Api.Employees.Test/MockData.cs
View File

@ -1,8 +1,4 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text;
namespace DamageAssesment.Api.Employees.Test
{
@ -15,13 +11,13 @@ namespace DamageAssesment.Api.Employees.Test
for (int i = 0; i < 10; i++)
{
list.Append(new Employees.Models.Employee { Id = "Emp"+i, Name = "Emoployee"+i, Email = "abc"+i+"@gmail.com", OfficePhoneNumber = "12345678", BirthDate = DateTime.Now.AddYears(-18-i), IsActive = true, PreferredLanguage = "en" });
list.Append(new Employees.Models.Employee { Id = i, Name = "Emoployee"+i, Email = "abc"+i+"@gmail.com", OfficePhoneNumber = "12345678", BirthDate = DateTime.Now.AddYears(-18-i), IsActive = true, PreferredLanguage = "en" });
}
return (true, list, null);
}
public static async Task<(bool, Employees.Models.Employee, string)> getOkResponse(string Id)
public static async Task<(bool, Employees.Models.Employee, string)> getOkResponse(int Id)
{
var Employees = await getOkResponse();
var Employee = Employees.Item2.FirstOrDefault(s => s.Id == Id);
@ -33,19 +29,19 @@ namespace DamageAssesment.Api.Employees.Test
return (false, null, "Bad Request");
}
public static async Task<(bool, Employees.Models.Employee, string)> getNotFoundResponse()
public static async Task<(bool, Models.Employee, string)> getNotFoundResponse()
{
return (false, null, "Not Found");
}
public static async Task<(bool, IEnumerable<Employees.Models.Employee>, string)> getNoContentResponse()
public static async Task<(bool, IEnumerable<Models.Employee>, string)> getNoContentResponse()
{
IEnumerable<Employees.Models.Employee> list = new List<Employees.Models.Employee>();
return (false, list, null);
}
public static async Task<Employees.Db.Employee> getInputEmployeeData()
public static async Task<Models.Employee> getInputEmployeeData()
{
return new Employees.Db.Employee { Id = "Emp1", Name = "ABC1", Email = "abc1@gmail.com", OfficePhoneNumber = "12345678", BirthDate = DateTime.Now.AddYears(-18), IsActive = true, PreferredLanguage = "en" };
return new Models.Employee { Id = 1, Name = "ABC1", Email = "abc1@gmail.com", OfficePhoneNumber = "12345678", BirthDate = DateTime.Now.AddYears(-18), IsActive = true, PreferredLanguage = "en" };
}

49
DamageAssesmentApi/DamageAssesment.Api.Employees/Controllers/EmployeesController.cs
View File

@ -4,7 +4,6 @@ using Microsoft.AspNetCore.Mvc;
namespace DamageAssesment.Api.Employees.Controllers
{
[Route("api")]
[ApiController]
public class EmployeesController : ControllerBase
{
@ -15,7 +14,11 @@ namespace DamageAssesment.Api.Employees.Controllers
{
this.EmployeeProvider = EmployeesProvider;
}
//get all Employees
/// <summary>
/// GET request for retrieving employees.
/// </summary>
[HttpGet("Employees")]
public async Task<ActionResult> GetEmployeesAsync()
{
@ -28,12 +31,16 @@ namespace DamageAssesment.Api.Employees.Controllers
return NoContent();
}
//get Employee based on Employeeid
[HttpGet("Employees/{Id}")]
public async Task<ActionResult> GetEmployeeByIdAsync(string Id)
/// <summary>
/// GET request for retrieving an employee by ID.
/// </summary>
[HttpGet("Employees/{id}")]
public async Task<ActionResult> GetEmployeeByIdAsync(int id)
{
var result = await EmployeeProvider.GetEmployeeByIdAsync(Id);
var result = await EmployeeProvider.GetEmployeeByIdAsync(id);
if (result.IsSuccess)
{
return Ok(result.Employee);
@ -41,14 +48,17 @@ namespace DamageAssesment.Api.Employees.Controllers
return NotFound();
}
//update existing Employee
[HttpPut("Employees")]
public async Task<IActionResult> UpdateEmployee(Db.Employee Employee)
/// <summary>
/// PUT request for updating an existing employee.
/// </summary>
/// <param name="Employee">The updated employee object.</param>
[HttpPut("Employees/{id}")]
public async Task<IActionResult> UpdateEmployee(int id, Models.Employee Employee)
{
if (Employee != null)
{
var result = await this.EmployeeProvider.UpdateEmployeeAsync(Employee);
var result = await this.EmployeeProvider.UpdateEmployeeAsync(id,Employee);
if (result.IsSuccess)
{
return Ok(result.Employee);
@ -60,9 +70,13 @@ namespace DamageAssesment.Api.Employees.Controllers
}
return NotFound();
}
//save new Employee
/// <summary>
/// POST request for creating a new employee.
/// </summary>
/// <param name="Employee">The employee information for creating a new employee.</param>
[HttpPost("Employees")]
public async Task<IActionResult> CreateEmployee(Db.Employee Employee)
public async Task<IActionResult> CreateEmployee(Models.Employee Employee)
{
if (Employee != null)
{
@ -73,11 +87,14 @@ namespace DamageAssesment.Api.Employees.Controllers
}
return BadRequest(result.ErrorMessage);
}
return CreatedAtRoute("DefaultApi", new { id = Employee.Id }, Employee);
return CreatedAtRoute("DefaultApi", new { Id = Employee.Id }, Employee);
}
//delete existing Employee
/// <summary>
/// DELETE request for deleting an existing employee.
/// </summary>
/// <param name="id">The ID of the employee to be deleted.</param>
[HttpDelete("Employees/{id}")]
public async Task<IActionResult> DeleteEmployee(string id)
public async Task<IActionResult> DeleteEmployee(int id)
{
var result = await this.EmployeeProvider.DeleteEmployeeAsync(id);
if (result.IsSuccess)

5
DamageAssesmentApi/DamageAssesment.Api.Employees/DamageAssesment.Api.Employees.csproj
View File

@ -1,14 +1,17 @@
<Project Sdk="Microsoft.NET.Sdk.Web">
<Project Sdk="Microsoft.NET.Sdk.Web">
<PropertyGroup>
<TargetFramework>net6.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
<GenerateDocumentationFile>True</GenerateDocumentationFile>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="12.0.1" />
<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="6.0.21" />
<PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.9" />
<PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="7.0.5" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="7.0.9">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

6
DamageAssesmentApi/DamageAssesment.Api.Employees/Db/Employee.cs
View File

@ -5,7 +5,9 @@ namespace DamageAssesment.Api.Employees.Db
public class Employee
{
[Key]
public string Id { get; set; }
public int Id { get; set; }
[StringLength(50)]
public string EmployeeCode { get; set; }
[StringLength(50)]
public string Name { get; set; }
@ -17,7 +19,7 @@ namespace DamageAssesment.Api.Employees.Db
[StringLength(50)]
public string Email { get; set; }
public bool IsActive {get;set;}
public bool IsActive { get; set; }
public string? PreferredLanguage { get; set; } = "en";
}
}

7
DamageAssesmentApi/DamageAssesment.Api.Employees/Db/EmployeeDbContext.cs
View File

@ -14,6 +14,13 @@ namespace DamageAssesment.Api.Employees.Db
// connect to sql server with connection string from app settings
options.UseSqlServer(_Configuration.GetConnectionString("EmployeeConnection"));
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity<Employee>()
.Property(item => item.Id)
.ValueGeneratedOnAdd();
}
public DbSet<Db.Employee> Employees { get; set; }
}
}

9
DamageAssesmentApi/DamageAssesment.Api.Employees/Interfaces/IEmployeesProvider.cs
View File

@ -3,9 +3,10 @@
public interface IEmployeesProvider
{
Task<(bool IsSuccess, IEnumerable<Models.Employee> Employees, string ErrorMessage)> GetEmployeesAsync();
Task<(bool IsSuccess, Models.Employee Employee, string ErrorMessage)> GetEmployeeByIdAsync(string Id);
Task<(bool IsSuccess, Models.Employee Employee, string ErrorMessage)> PostEmployeeAsync(Db.Employee Employee);
Task<(bool IsSuccess, Models.Employee Employee, string ErrorMessage)> UpdateEmployeeAsync(Db.Employee Employee);
Task<(bool IsSuccess, Models.Employee Employee, string ErrorMessage)> DeleteEmployeeAsync(string Id);
Task<(bool IsSuccess, Models.Employee Employee, string ErrorMessage)> GetEmployeeByIdAsync(int Id);
Task<(bool IsSuccess, Models.Employee Employee, string ErrorMessage)> PostEmployeeAsync(Models.Employee Employee);
Task<(bool IsSuccess, Models.Employee Employee, string ErrorMessage)> UpdateEmployeeAsync(int Id, Models.Employee Employee);
Task<(bool IsSuccess, Models.Employee Employee, string ErrorMessage)> DeleteEmployeeAsync(int Id);
void SeedData();
}
}

72
DamageAssesmentApi/DamageAssesment.Api.Employees/Migrations/20230913164315_employeeupdate.Designer.cs generated Normal file
View File

@ -0,0 +1,72 @@
// <auto-generated />
using System;
using DamageAssesment.Api.Employees.Db;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Microsoft.EntityFrameworkCore.Migrations;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
#nullable disable
namespace DamageAssesment.Api.Employees.Migrations
{
[DbContext(typeof(EmployeeDbContext))]
[Migration("20230913164315_employeeupdate")]
partial class employeeupdate
{
/// <inheritdoc />
protected override void BuildTargetModel(ModelBuilder modelBuilder)
{
#pragma warning disable 612, 618
modelBuilder
.HasAnnotation("ProductVersion", "7.0.9")
.HasAnnotation("Relational:MaxIdentifierLength", 128);
SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
modelBuilder.Entity("DamageAssesment.Api.Employees.Db.Employee", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
b.Property<DateTime>("BirthDate")
.HasColumnType("datetime2");
b.Property<string>("Email")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("nvarchar(50)");
b.Property<string>("EmployeeCode")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("nvarchar(50)");
b.Property<bool>("IsActive")
.HasColumnType("bit");
b.Property<string>("Name")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("nvarchar(50)");
b.Property<string>("OfficePhoneNumber")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("nvarchar(50)");
b.Property<string>("PreferredLanguage")
.HasColumnType("nvarchar(max)");
b.HasKey("Id");
b.ToTable("Employees");
});
#pragma warning restore 612, 618
}
}
}

48
DamageAssesmentApi/DamageAssesment.Api.Employees/Migrations/20230913164315_employeeupdate.cs Normal file
View File

@ -0,0 +1,48 @@
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace DamageAssesment.Api.Employees.Migrations
{
/// <inheritdoc />
public partial class employeeupdate : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.AlterColumn<int>(
name: "Id",
table: "Employees",
type: "int",
nullable: false,
oldClrType: typeof(string),
oldType: "nvarchar(450)")
.Annotation("SqlServer:Identity", "1, 1");
migrationBuilder.AddColumn<string>(
name: "EmployeeCode",
table: "Employees",
type: "nvarchar(50)",
maxLength: 50,
nullable: false,
defaultValue: "");
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropColumn(
name: "EmployeeCode",
table: "Employees");
migrationBuilder.AlterColumn<string>(
name: "Id",
table: "Employees",
type: "nvarchar(450)",
nullable: false,
oldClrType: typeof(int),
oldType: "int")
.OldAnnotation("SqlServer:Identity", "1, 1");
}
}
}

72
DamageAssesmentApi/DamageAssesment.Api.Employees/Migrations/20230913170055_updatedemployee_id.Designer.cs generated Normal file
View File

@ -0,0 +1,72 @@
// <auto-generated />
using System;
using DamageAssesment.Api.Employees.Db;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Microsoft.EntityFrameworkCore.Migrations;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
#nullable disable
namespace DamageAssesment.Api.Employees.Migrations
{
[DbContext(typeof(EmployeeDbContext))]
[Migration("20230913170055_updatedemployee_id")]
partial class updatedemployee_id
{
/// <inheritdoc />
protected override void BuildTargetModel(ModelBuilder modelBuilder)
{
#pragma warning disable 612, 618
modelBuilder
.HasAnnotation("ProductVersion", "7.0.9")
.HasAnnotation("Relational:MaxIdentifierLength", 128);
SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
modelBuilder.Entity("DamageAssesment.Api.Employees.Db.Employee", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
b.Property<DateTime>("BirthDate")
.HasColumnType("datetime2");
b.Property<string>("Email")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("nvarchar(50)");
b.Property<string>("EmployeeCode")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("nvarchar(50)");
b.Property<bool>("IsActive")
.HasColumnType("bit");
b.Property<string>("Name")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("nvarchar(50)");
b.Property<string>("OfficePhoneNumber")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("nvarchar(50)");
b.Property<string>("PreferredLanguage")
.HasColumnType("nvarchar(max)");
b.HasKey("Id");
b.ToTable("Employees");
});
#pragma warning restore 612, 618
}
}
}

22
DamageAssesmentApi/DamageAssesment.Api.Employees/Migrations/20230913170055_updatedemployee_id.cs Normal file
View File

@ -0,0 +1,22 @@
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace DamageAssesment.Api.Employees.Migrations
{
/// <inheritdoc />
public partial class updatedemployee_id : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
}
}
}

12
DamageAssesmentApi/DamageAssesment.Api.Employees/Migrations/EmployeeDbContextModelSnapshot.cs
View File

@ -24,8 +24,11 @@ namespace DamageAssesment.Api.Employees.Migrations
modelBuilder.Entity("DamageAssesment.Api.Employees.Db.Employee", b =>
{
b.Property<string>("Id")
.HasColumnType("nvarchar(450)");
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
b.Property<DateTime>("BirthDate")
.HasColumnType("datetime2");
@ -35,6 +38,11 @@ namespace DamageAssesment.Api.Employees.Migrations
.HasMaxLength(50)
.HasColumnType("nvarchar(50)");
b.Property<string>("EmployeeCode")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("nvarchar(50)");
b.Property<bool>("IsActive")
.HasColumnType("bit");

11
DamageAssesmentApi/DamageAssesment.Api.Employees/Models/Employee.cs
View File

@ -4,18 +4,11 @@ namespace DamageAssesment.Api.Employees.Models
{
public class Employee
{
[Key]
public string Id { get; set; }
[StringLength(50)]
public int Id { get; set; }
public string EmployeeCode { get; set; }
public string Name { get; set; }
public DateTime BirthDate { get; set; }
[StringLength(50)]
public string OfficePhoneNumber { get; set; }
[StringLength(50)]
public string Email { get; set; }
public bool IsActive { get; set; }
public string? PreferredLanguage { get; set; } = "en";

1
DamageAssesmentApi/DamageAssesment.Api.Employees/Profiles/EmployeesProfile.cs
View File

@ -7,6 +7,7 @@ namespace DamageAssesment.Api.Employees.Profiles
public EmployeesProfile()
{
CreateMap<Db.Employee, Models.Employee>();
CreateMap<Models.Employee, Db.Employee>();
}
}
}

18
DamageAssesmentApi/DamageAssesment.Api.Employees/Program.cs
View File

@ -2,6 +2,7 @@ using DamageAssesment.Api.Employees.Db;
using DamageAssesment.Api.Employees.Interfaces;
using DamageAssesment.Api.Employees.Providers;
using Microsoft.EntityFrameworkCore;
using System.Reflection;
var builder = WebApplication.CreateBuilder(args);
@ -10,7 +11,15 @@ var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
//builder.Services.AddSwaggerGen();
builder.Services.AddSwaggerGen(c =>
{
// Include XML comments from your assembly
var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
c.IncludeXmlComments(xmlPath);
});
builder.Services.AddScoped<IEmployeesProvider, EmployeesProvider>();
builder.Services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies()); //4/30
builder.Services.AddDbContext<EmployeeDbContext>(option =>
@ -25,6 +34,13 @@ if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
using (var serviceScope = app.Services.CreateScope())
{
var services = serviceScope.ServiceProvider;
var employeesProvider = services.GetRequiredService<IEmployeesProvider>();
employeesProvider.SeedData();
}
}
app.UseAuthorization();

59
DamageAssesmentApi/DamageAssesment.Api.Employees/Providers/EmployeesProvider.cs
View File

@ -19,7 +19,7 @@ namespace DamageAssesment.Api.Employees.Providers
this.EmployeeDbContext = EmployeeDbContext;
this.logger = logger;
this.mapper = mapper;
SeedData();
// SeedData();
}
public async Task<(bool IsSuccess, IEnumerable<Models.Employee> Employees, string ErrorMessage)> GetEmployeesAsync()
@ -45,12 +45,12 @@ namespace DamageAssesment.Api.Employees.Providers
}
public async Task<(bool IsSuccess, Models.Employee Employee, string ErrorMessage)> GetEmployeeByIdAsync(string Id)
public async Task<(bool IsSuccess, Models.Employee Employee, string ErrorMessage)> GetEmployeeByIdAsync(int Id)
{
try
{
logger?.LogInformation("Query Employee");
var Employee = await EmployeeDbContext.Employees.AsNoTracking().FirstOrDefaultAsync(q => q.Id.ToLower() == Id.ToLower());
var Employee = await EmployeeDbContext.Employees.AsNoTracking().FirstOrDefaultAsync(q => q.Id == Id);
if (Employee != null)
{
logger?.LogInformation($"{Employee} customer(s) found");
@ -65,19 +65,21 @@ namespace DamageAssesment.Api.Employees.Providers
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.Employee Employee, string ErrorMessage)> PostEmployeeAsync(Db.Employee Employee)
public async Task<(bool IsSuccess, Models.Employee Employee, string ErrorMessage)> PostEmployeeAsync(Models.Employee Employee)
{
try
{
Db.Employee _employee = mapper.Map<Models.Employee, Db.Employee>(Employee);
logger?.LogInformation("Query Employee");
if (!EmployeeExists(Employee.Id))
if (!EmployeeCodeExists(Employee.EmployeeCode))
{
EmployeeDbContext.Employees.Add(Employee);
EmployeeDbContext.Employees.Add(_employee);
Employee.Id = _employee.Id;
EmployeeDbContext.SaveChanges();
var result = mapper.Map<Db.Employee, Models.Employee>(Employee);
return (true, result, null);
return (true, Employee, null);
}
return (false, null, "Employee is already exits");
return (false, null, "Employee code is already exits");
}
catch (Exception ex)
{
@ -85,19 +87,21 @@ namespace DamageAssesment.Api.Employees.Providers
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.Employee Employee, string ErrorMessage)> UpdateEmployeeAsync(Db.Employee Employee)
public async Task<(bool IsSuccess, Models.Employee Employee, string ErrorMessage)> UpdateEmployeeAsync(int Id, Models.Employee Employee)
{
try
{
if (Employee != null)
{
var _employee = await EmployeeDbContext.Employees.AsNoTracking().Where(s => s.Id.ToLower() == Employee.Id.ToLower()).FirstOrDefaultAsync();
var _employee = await EmployeeDbContext.Employees.AsNoTracking().Where(s => s.Id == Id).FirstOrDefaultAsync();
if (_employee != null)
{
EmployeeDbContext.Employees.Update(Employee);
Db.Employee vEmployee = mapper.Map<Models.Employee, Db.Employee>(Employee);
EmployeeDbContext.Employees.Update(vEmployee);
EmployeeDbContext.SaveChanges();
return (true, mapper.Map<Db.Employee, Models.Employee>(Employee), "Successful");
Employee.Id = Id;
return (true, Employee, "Successful");
}
else
{
@ -118,11 +122,11 @@ namespace DamageAssesment.Api.Employees.Providers
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.Employee Employee, string ErrorMessage)> DeleteEmployeeAsync(string Id)
public async Task<(bool IsSuccess, Models.Employee Employee, string ErrorMessage)> DeleteEmployeeAsync(int Id)
{
try
{
Db.Employee Employee = EmployeeDbContext.Employees.AsNoTracking().Where(a => a.Id.ToLower() == Id.ToLower()).FirstOrDefault();
Db.Employee Employee = EmployeeDbContext.Employees.AsNoTracking().Where(a => a.Id == Id).FirstOrDefault();
if (Employee == null)
{
return (false, null, "Not Found");
@ -135,24 +139,29 @@ namespace DamageAssesment.Api.Employees.Providers
{
logger?.LogError(ex.ToString());
return (false,null, ex.Message);
return (false, null, ex.Message);
}
}
private bool EmployeeExists(string id)
private bool EmployeeExists(int id)
{
return EmployeeDbContext.Employees.AsNoTracking().Count(e => e.Id.ToLower() == id.ToLower()) > 0;
return EmployeeDbContext.Employees.AsNoTracking().Count(e => e.Id == id) > 0;
}
private void SeedData()
private bool EmployeeCodeExists(string employeeCode)
{
return EmployeeDbContext.Employees.AsNoTracking().Count(e => e.EmployeeCode.ToLower() == employeeCode.ToLower()) > 0;
}
public void SeedData()
{
if (!EmployeeDbContext.Employees.Any())
{
EmployeeDbContext.Employees.Add(new Db.Employee() { Id = "Emp1", Name = "ABC1", Email = "abc1@gmail.com", OfficePhoneNumber = "12345678",BirthDate=DateTime.Now.AddYears(-18), IsActive = true,PreferredLanguage="en" });
EmployeeDbContext.Employees.Add(new Db.Employee() { Id = "Emp2", Name = "ABC2", Email = "abc2@gmail.com", OfficePhoneNumber = "12345678", BirthDate = DateTime.Now.AddYears(-22), IsActive = true, PreferredLanguage = "fr" });
EmployeeDbContext.Employees.Add(new Db.Employee() { Id = "Emp3", Name = "ABC3", Email = "abc3@gmail.com", OfficePhoneNumber = "12345678", BirthDate = DateTime.Now.AddYears(-30) ,IsActive = true, PreferredLanguage = "fr" });
EmployeeDbContext.Employees.Add(new Db.Employee() { Id = "Emp4", Name = "ABC4", Email = "abc4@gmail.com", OfficePhoneNumber = "12345678", BirthDate = DateTime.Now.AddYears(-20) ,IsActive = true, PreferredLanguage = "en" });
EmployeeDbContext.Employees.Add(new Db.Employee() { Id = "Emp5", Name = "ABC5", Email = "abc5@gmail.com", OfficePhoneNumber = "12345678", BirthDate = DateTime.Now.AddYears(-23) ,IsActive = true, PreferredLanguage = "sp" });
EmployeeDbContext.Employees.Add(new Db.Employee() { Id = "Emp6", Name = "ABC6", Email = "abc6@gmail.com", OfficePhoneNumber = "12345678", BirthDate = DateTime.Now.AddYears(-32) ,IsActive = true, PreferredLanguage = "sp" });
EmployeeDbContext.Employees.Add(new Db.Employee() { EmployeeCode = "Emp1", Name = "ABC1", Email = "abc1@gmail.com", OfficePhoneNumber = "12345678", BirthDate = DateTime.Now.AddYears(-18), IsActive = true, PreferredLanguage = "en" });
EmployeeDbContext.Employees.Add(new Db.Employee() { EmployeeCode = "Emp2", Name = "ABC2", Email = "abc2@gmail.com", OfficePhoneNumber = "12345678", BirthDate = DateTime.Now.AddYears(-22), IsActive = true, PreferredLanguage = "fr" });
EmployeeDbContext.Employees.Add(new Db.Employee() { EmployeeCode = "Emp3", Name = "ABC3", Email = "abc3@gmail.com", OfficePhoneNumber = "12345678", BirthDate = DateTime.Now.AddYears(-30), IsActive = true, PreferredLanguage = "fr" });
EmployeeDbContext.Employees.Add(new Db.Employee() { EmployeeCode = "Emp4", Name = "ABC4", Email = "abc4@gmail.com", OfficePhoneNumber = "12345678", BirthDate = DateTime.Now.AddYears(-20), IsActive = true, PreferredLanguage = "en" });
EmployeeDbContext.Employees.Add(new Db.Employee() { EmployeeCode = "Emp5", Name = "ABC5", Email = "abc5@gmail.com", OfficePhoneNumber = "12345678", BirthDate = DateTime.Now.AddYears(-23), IsActive = true, PreferredLanguage = "es" });
EmployeeDbContext.Employees.Add(new Db.Employee() { EmployeeCode = "Emp6", Name = "ABC6", Email = "abc6@gmail.com", OfficePhoneNumber = "12345678", BirthDate = DateTime.Now.AddYears(-32), IsActive = true, PreferredLanguage = "es" });
EmployeeDbContext.SaveChanges();
}

3
DamageAssesmentApi/DamageAssesment.Api.Employees/appsettings.json
View File

@ -1,4 +1,7 @@
{
"JwtSettings": {
"securitykey": "bWlhbWkgZGFkZSBzY2hvb2xzIHNlY3JldCBrZXk="
},
"Logging": {
"LogLevel": {
"Default": "Information",

191
DamageAssesmentApi/DamageAssesment.Api.Locations.Test/LocationsServiceTest.cs
View File

@ -1,11 +1,6 @@
using AutoMapper;
using DamageAssesment.Api.Locations.Controllers;
using DamageAssesment.Api.Locations.Db;
using DamageAssesment.Api.Locations.Interfaces;
using DamageAssesment.Api.Locations.Profiles;
using DamageAssesment.Api.Locations.Providers;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Moq;
using Xunit;
@ -13,7 +8,145 @@ namespace DamageAssesment.Api.Locations.Test
{
public class LocationsServiceTest
{
//Test for locations
[Fact(DisplayName = "Get Locations - Ok case")]
public async Task GetLocationsAsync_ShouldReturnStatusCode200()
{
var mockLocationService = new Mock<ILocationsProvider>();
var mockResponse = await MockData.getOkResponseLocation();
mockLocationService.Setup(service => service.GetLocationsAsync()).ReturnsAsync(mockResponse);
var locationProvider = new LocationsController(mockLocationService.Object);
var result = (OkObjectResult)await locationProvider.GetLocationsAsync();
Assert.Equal(200, result.StatusCode);
}
[Fact(DisplayName = "Get Locations - NoContent Case")]
public async Task GetLocationsAsync_ShouldReturnStatusCode204()
{
var mockLocationService = new Mock<ILocationsProvider>();
var mockResponse = await MockData.getNotFoundResponseLocation();
mockLocationService.Setup(service => service.GetLocationsAsync()).ReturnsAsync(mockResponse);
var locationProvider = new LocationsController(mockLocationService.Object);
var result = (NoContentResult)await locationProvider.GetLocationsAsync();
Assert.Equal(204, result.StatusCode);
}
[Fact(DisplayName = "Get Locations by Id- Ok case")]
public async Task GetLocationsByIdAsync_ShouldReturnStatusCode200()
{
var mockLocationService = new Mock<ILocationsProvider>();
var mockResponse = await MockData.getOkResponseLocation(1);
mockLocationService.Setup(service => service.GetLocationByIdAsync(1)).ReturnsAsync(mockResponse);
var locationProvider = new LocationsController(mockLocationService.Object);
var result = (OkObjectResult)await locationProvider.GetLocationByIdAsync(1);
Assert.Equal(200, result.StatusCode);
}
[Fact(DisplayName = "Get Locations By Id - NoFound Case")]
public async Task GetLocationsByIdAsync_ShouldReturnStatusCode404()
{
var mockLocationService = new Mock<ILocationsProvider>();
var mockResponse = await MockData.getLocationNotFoundResponse();
mockLocationService.Setup(service => service.GetLocationByIdAsync(1)).ReturnsAsync(mockResponse);
var locationProvider = new LocationsController(mockLocationService.Object);
var result = (NotFoundResult)await locationProvider.GetLocationByIdAsync(1);
Assert.Equal(404, result.StatusCode);
}
[Fact(DisplayName = "Post Location - Ok case")]
public async Task PostLocationAsync_ShouldReturnStatusCode200()
{
var mockLocationService = new Mock<ILocationsProvider>();
var mockResponse = await MockData.getOkResponseLocation(1);
var mockInputLocation = new Models.Location { Id = 1, RegionId = 1, Name = "Location 1", SchoolType = "US", MaintenanceCenter = "1" };
mockLocationService.Setup(service => service.PostLocationAsync(mockInputLocation)).ReturnsAsync(mockResponse);
var locationProvider = new LocationsController(mockLocationService.Object);
var result = (OkObjectResult)await locationProvider.CreateLocation(mockInputLocation);
Assert.Equal(200, result.StatusCode);
}
[Fact(DisplayName = "Post Location - BadRequest case")]
public async Task PostLocationAsync_ShouldReturnStatusCode400()
{
var mockLocationService = new Mock<ILocationsProvider>();
var mockResponse = await MockData.getLocationNotFoundResponse();
var mockInputLocation = new Models.Location { Id = 1, RegionId = 1, Name = "Location 1", SchoolType = "US", MaintenanceCenter = "1" };
mockLocationService.Setup(service => service.PostLocationAsync(mockInputLocation)).ReturnsAsync(mockResponse);
var locationProvider = new LocationsController(mockLocationService.Object);
var result = (BadRequestObjectResult)await locationProvider.CreateLocation(mockInputLocation);
Assert.Equal(400, result.StatusCode);
}
[Fact(DisplayName = "Put Location - Ok case")]
public async Task PutLocationAsync_ShouldReturnStatusCode200()
{
var mockLocationService = new Mock<ILocationsProvider>();
var mockResponse = await MockData.getLocation(true, "update success");
var mockInputLocation = new Models.Location { Id = 1, LocationCode ="Loc1", RegionId = 1, Name = "Location 1", SchoolType = "US", MaintenanceCenter = "1" };
mockLocationService.Setup(service => service.UpdateLocationAsync(1,mockInputLocation)).ReturnsAsync(mockResponse);
var locationProvider = new LocationsController(mockLocationService.Object);
var result = (OkObjectResult)await locationProvider.UpdateLocation(1,mockInputLocation);
Assert.Equal(200, result.StatusCode);
}
[Fact(DisplayName = "Put Location - NotFound case")]
public async Task PutLocationAsync_ShouldReturnStatusCode404()
{
var mockLocationService = new Mock<ILocationsProvider>();
var mockResponse = await MockData.getLocation(false, null);
var mockInputLocation = new Models.Location { Id = 1, RegionId = 1, Name = "Location 1", SchoolType = "US", MaintenanceCenter = "1" };
mockLocationService.Setup(service => service.UpdateLocationAsync(1,mockInputLocation)).ReturnsAsync(mockResponse);
var locationProvider = new LocationsController(mockLocationService.Object);
var result = (NotFoundResult)await locationProvider.UpdateLocation(1,mockInputLocation);
Assert.Equal(404, result.StatusCode);
}
[Fact(DisplayName = "Delete Location - Ok case")]
public async Task DeleteLocationAsync_ShouldReturnStatusCode200()
{
var mockLocationService = new Mock<ILocationsProvider>();
var mockResponse = await MockData.getLocation(true, "delete success");
mockLocationService.Setup(service => service.DeleteLocationAsync(1)).ReturnsAsync(mockResponse);
var locationProvider = new LocationsController(mockLocationService.Object);
var result = (OkObjectResult)await locationProvider.DeleteLocation(1);
Assert.Equal(200, result.StatusCode);
}
[Fact(DisplayName = "Delete Location - NotFound case")]
public async Task DeleteLocationAsync_ShouldReturnStatusCode404()
{
var mockLocationService = new Mock<ILocationsProvider>();
var mockResponse = await MockData.getLocation(false, null);
mockLocationService.Setup(service => service.DeleteLocationAsync(1)).ReturnsAsync(mockResponse);
var locationProvider = new LocationsController(mockLocationService.Object);
var result = (NotFoundResult)await locationProvider.DeleteLocation(1);
Assert.Equal(404, result.StatusCode);
}
//Tests for regions
@ -47,11 +180,11 @@ namespace DamageAssesment.Api.Locations.Test
public async Task GetRegionAsync_ShouldReturnStatusCode200()
{
var mockRegionService = new Mock<IRegionsProvider>();
var mockResponse = await MockData.getOkResponse("1");
mockRegionService.Setup(service => service.GetRegionByIdAsync("1")).ReturnsAsync(mockResponse);
var mockResponse = await MockData.getOkResponse(1);
mockRegionService.Setup(service => service.GetRegionByIdAsync(1)).ReturnsAsync(mockResponse);
var regionProvider = new RegionsController(mockRegionService.Object);
var result = (OkObjectResult)await regionProvider.GetRegionAsync("1");
var result = (OkObjectResult)await regionProvider.GetRegionAsync(1);
Assert.Equal(200, result.StatusCode);
}
@ -61,18 +194,18 @@ namespace DamageAssesment.Api.Locations.Test
{
var mockRegionService = new Mock<IRegionsProvider>();
var mockResponse = await MockData.getNotFoundResponse();
mockRegionService.Setup(service => service.GetRegionByIdAsync("99")).ReturnsAsync(mockResponse);
mockRegionService.Setup(service => service.GetRegionByIdAsync(99999)).ReturnsAsync(mockResponse);
var regionProvider = new RegionsController(mockRegionService.Object);
var result = (NotFoundResult)await regionProvider.GetRegionAsync("99");
var result = (NotFoundResult)await regionProvider.GetRegionAsync(99);
Assert.Equal(404, result.StatusCode);
}
[Fact(DisplayName = "Post Region - Ok case")]
public async Task PostSurveyAsync_ShouldReturnStatusCode200()
public async Task PostRegionAsync_ShouldReturnStatusCode200()
{
var mockRegionService = new Mock<IRegionsProvider>();
var mockResponse = await MockData.getOkResponse("1");
var mockResponse = await MockData.getOkResponse(1);
var mockInputRegion = await MockData.getInputRegionData();
mockRegionService.Setup(service => service.PostRegionAsync(mockInputRegion)).ReturnsAsync(mockResponse);
@ -83,7 +216,7 @@ namespace DamageAssesment.Api.Locations.Test
}
[Fact(DisplayName = "Post Region - BadRequest case")]
public async Task PostSurveyAsync_ShouldReturnStatusCode400()
public async Task PostRegionAsync_ShouldReturnStatusCode400()
{
var mockRegionService = new Mock<IRegionsProvider>();
var mockResponse = await MockData.getBadRequestResponse();
@ -100,68 +233,68 @@ namespace DamageAssesment.Api.Locations.Test
public async Task PutRegionAsync_ShouldReturnStatusCode200()
{
var mockRegionService = new Mock<IRegionsProvider>();
var mockResponse = await MockData.getOkResponse("1");
var mockResponse = await MockData.getOkResponse(1);
var mockInputRegion = await MockData.getInputRegionData();
mockRegionService.Setup(service => service.PutRegionAsync(mockInputRegion)).ReturnsAsync(mockResponse);
mockRegionService.Setup(service => service.PutRegionAsync(1,mockInputRegion)).ReturnsAsync(mockResponse);
var regionProvider = new RegionsController(mockRegionService.Object);
var result = (OkObjectResult)await regionProvider.PutRegionAsync(mockInputRegion);
var result = (OkObjectResult)await regionProvider.PutRegionAsync(1,mockInputRegion);
Assert.Equal(200, result.StatusCode);
}
[Fact(DisplayName = "Put Region - NotFound case")]
public async Task PutSurveyAsync_ShouldReturnStatusCode404()
public async Task PutRegionAsync_ShouldReturnStatusCode404()
{
var mockRegionService = new Mock<IRegionsProvider>();
var mockResponse = await MockData.getNotFoundResponse();
var mockInputRegion = await MockData.getInputRegionData();
mockRegionService.Setup(service => service.PutRegionAsync(mockInputRegion)).ReturnsAsync(mockResponse);
mockRegionService.Setup(service => service.PutRegionAsync(1, mockInputRegion)).ReturnsAsync(mockResponse);
var regionProvider = new RegionsController(mockRegionService.Object);
var result = (NotFoundObjectResult)await regionProvider.PutRegionAsync(mockInputRegion);
var result = (NotFoundObjectResult)await regionProvider.PutRegionAsync(1,mockInputRegion);
Assert.Equal(404, result.StatusCode);
}
[Fact(DisplayName = "Put Region - BadRequest case")]
public async Task PutSurveyAsync_ShouldReturnStatusCode400()
public async Task PutRegionyAsync_ShouldReturnStatusCode400()
{
var mockRegionService = new Mock<IRegionsProvider>();
var mockResponse = await MockData.getBadRequestResponse();
var mockInputRegion = await MockData.getInputRegionData();
mockRegionService.Setup(service => service.PutRegionAsync(mockInputRegion)).ReturnsAsync(mockResponse);
mockRegionService.Setup(service => service.PutRegionAsync(1, mockInputRegion)).ReturnsAsync(mockResponse);
var regionProvider = new RegionsController(mockRegionService.Object);
var result = (BadRequestObjectResult)await regionProvider.PutRegionAsync(mockInputRegion);
var result = (BadRequestObjectResult)await regionProvider.PutRegionAsync(1, mockInputRegion);
Assert.Equal(400, result.StatusCode);
}
[Fact(DisplayName = "Delete Region - Ok case")]
public async Task DeleteSurveyAsync_ShouldReturnStatusCode200()
public async Task DeleteRegionAsync_ShouldReturnStatusCode200()
{
var mockRegionService = new Mock<IRegionsProvider>();
var mockResponse = await MockData.getOkResponse("1");
var mockResponse = await MockData.getOkResponse(1);
mockRegionService.Setup(service => service.DeleteRegionAsync("1")).ReturnsAsync(mockResponse);
mockRegionService.Setup(service => service.DeleteRegionAsync(1)).ReturnsAsync(mockResponse);
var regionProvider = new RegionsController(mockRegionService.Object);
var result = (OkObjectResult)await regionProvider.DeleteRegionAsync("1");
var result = (OkObjectResult)await regionProvider.DeleteRegionAsync(1);
Assert.Equal(200, result.StatusCode);
}
[Fact(DisplayName = "Delete Region - NotFound case")]
public async Task DeleteSurveyAsync_ShouldReturnStatusCode404()
public async Task DeleteRegionAsync_ShouldReturnStatusCode404()
{
var mockRegionService = new Mock<IRegionsProvider>();
var mockResponse = await MockData.getNotFoundResponse();
mockRegionService.Setup(service => service.DeleteRegionAsync("1")).ReturnsAsync(mockResponse);
mockRegionService.Setup(service => service.DeleteRegionAsync(1)).ReturnsAsync(mockResponse);
var regionProvider = new RegionsController(mockRegionService.Object);
var result = (NotFoundResult)await regionProvider.DeleteRegionAsync("1");
var result = (NotFoundResult)await regionProvider.DeleteRegionAsync(1);
Assert.Equal(404, result.StatusCode);
}

48
DamageAssesmentApi/DamageAssesment.Api.Locations.Test/MockData.cs
View File

@ -9,17 +9,52 @@ namespace DamageAssesment.Api.Locations.Test
for (int i = 0; i < 10; i++)
{
list.Append(new Locations.Models.Region { Id = "R" + i, Abbreviation = "AB" + i, Name = "Region " + i });
list.Append(new Locations.Models.Region { Id = i, Abbreviation = "AB" + i, Name = "Region " + i });
}
return (true, list, null);
}
public static async Task<(bool, Locations.Models.Region, string)> getOkResponse(string Id)
public static async Task<(bool, Locations.Models.Region, string)> getOkResponse(int Id)
{
var surveys = await getOkResponse();
var survey = surveys.Item2.FirstOrDefault(s => s.Id == Id);
return (true, survey, null);
var regions = await getOkResponse();
var region = regions.Item2.FirstOrDefault(s => s.Id == Id);
return (true, region, null);
}
public static async Task<(bool, IEnumerable<Models.Location>, string)> getOkResponseLocation()
{
IEnumerable<Locations.Models.Location> list = new List<Models.Location>();
for (int i = 0; i < 10; i++)
{
list.Append(new Locations.Models.Location { Id = i, RegionId = i, Name = "Location" });
}
return (true, list, null);
}
public static async Task<(bool, IEnumerable<Models.Location>, string)> getNotFoundResponseLocation()
{
return (false, null, null);
}
public static async Task<(bool, Models.Location, string)> getOkResponseLocation(int Id)
{
var locations = await getOkResponseLocation();
var location = locations.Item2.FirstOrDefault(s => s.Id == Id);
return (true, location, null);
}
public static async Task<(bool, Models.Location, string)> getLocation(bool value, string message)
{
var location = new Models.Location { Id = 1, LocationCode = "Loc1", RegionId = 1, Name = "Location 1", SchoolType = "US", MaintenanceCenter = "1" };
return (value, location, message);
}
public static async Task<(bool, Locations.Models.Location, string)> getLocationNotFoundResponse()
{
return (false, null, "Not Found");
}
public static async Task<(bool, Locations.Models.Region, string)> getBadRequestResponse()
@ -39,8 +74,7 @@ namespace DamageAssesment.Api.Locations.Test
public static async Task<Locations.Models.Region> getInputRegionData()
{
return new Locations.Models.Region { Id = "R99", Name = "Region 99", Abbreviation = "A99" };
return new Locations.Models.Region { Id = 99999, Name = "Region 99", Abbreviation = "A99" };
}
}
}

53
DamageAssesmentApi/DamageAssesment.Api.Locations/Controllers/LocationsController.cs
View File

@ -4,17 +4,18 @@ using Microsoft.AspNetCore.Mvc;
namespace DamageAssesment.Api.Locations.Controllers
{
[Route("api")]
[ApiController]
public class LocationsController : ControllerBase
{
private ILocationsProvider LocationProvider;
public LocationsController(ILocationsProvider LocationsProvider)
{
this.LocationProvider = LocationsProvider;
}
// Get all Locations
/// <summary>
/// Get all locations.
/// </summary>
[HttpGet("Locations")]
public async Task<ActionResult> GetLocationsAsync()
{
@ -22,14 +23,17 @@ namespace DamageAssesment.Api.Locations.Controllers
var result = await LocationProvider.GetLocationsAsync();
if (result.IsSuccess)
{
return Ok(result.locations);
return Ok(result.Locations);
}
return NotFound();
return NoContent();
}
// Get all Location based on Id
/// <summary>
/// Get all locations based on locationdId.
/// </summary>
[HttpGet("Locations/{id}")]
public async Task<ActionResult> GetLocationByIdAsync(string id)
public async Task<ActionResult> GetLocationByIdAsync(int id)
{
var result = await LocationProvider.GetLocationByIdAsync(id);
@ -40,44 +44,53 @@ namespace DamageAssesment.Api.Locations.Controllers
return NotFound();
}
// Update Location entity
[HttpPut("Locations")]
public async Task<IActionResult> UpdateLocation(Db.Location Location)
/// <summary>
/// Update a Location.
/// </summary>
[HttpPut("Locations/{id}")]
public async Task<IActionResult> UpdateLocation(int id, Models.Location Location)
{
if (Location != null)
{
var result = await this.LocationProvider.UpdateLocationAsync(Location);
var result = await this.LocationProvider.UpdateLocationAsync(id, Location);
if (result.IsSuccess)
{
return Ok(result.ErrorMessage);
return Ok(result.Location);
}
return NotFound();
}
return NotFound();
}
//save new location
/// <summary>
/// Save a new location.
/// </summary>
[HttpPost("Locations")]
public async Task<IActionResult> CreateLocation(Db.Location Location)
public async Task<IActionResult> CreateLocation(Models.Location Location)
{
if (Location != null)
{
var result = await this.LocationProvider.PostLocationAsync(Location);
if (result.IsSuccess)
{
return Ok(result.Question);
return Ok(result.Location);
}
return NotFound();
return BadRequest(result.ErrorMessage);
}
return CreatedAtRoute("DefaultApi", new { id = Location.Id }, Location);
return BadRequest();
}
//delete existing location
/// <summary>
/// Delete an existing location.
/// </summary>
[HttpDelete("Locations/{id}")]
public async Task<IActionResult> DeleteLocation(string id)
public async Task<IActionResult> DeleteLocation(int id)
{
var result = await this.LocationProvider.DeleteLocationAsync(id);
if (result.IsSuccess)
{
return Ok(result.ErrorMessage);
return Ok(result.Location);
}
return NotFound();
}

42
DamageAssesmentApi/DamageAssesment.Api.Locations/Controllers/RegionsController.cs
View File

@ -3,7 +3,6 @@ using Microsoft.AspNetCore.Mvc;
namespace DamageAssesment.Api.Locations.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class RegionsController : ControllerBase
{
@ -13,31 +12,39 @@ namespace DamageAssesment.Api.Locations.Controllers
{
this.regionProvider = regionProvider;
}
/// <summary>
/// Get all regions.2
/// </summary>
// Get all Regions
[HttpGet]
[HttpGet("regions")]
public async Task<ActionResult> GetRegionsAsync()
{
var result = await regionProvider.GetRegionsAsync();
if (result.IsSuccess)
{
return Ok(result.regions);
return Ok(result.Regions);
}
return NoContent();
}
/// <summary>
/// GET request for retrieving a region by its ID.
/// </summary>
[HttpGet("{Id}")]
public async Task<ActionResult> GetRegionAsync(string Id)
[HttpGet("regions/{id}")]
public async Task<ActionResult> GetRegionAsync(int id)
{
var result = await this.regionProvider.GetRegionByIdAsync(Id);
var result = await this.regionProvider.GetRegionByIdAsync(id);
if (result.IsSuccess)
{
return Ok(result.Region);
}
return NotFound();
}
/// <summary>
/// POST request for creating a new region.
/// </summary>
[HttpPost]
[HttpPost("regions")]
public async Task<ActionResult> PostRegionAsync(Models.Region region)
{
var result = await this.regionProvider.PostRegionAsync(region);
@ -47,11 +54,14 @@ namespace DamageAssesment.Api.Locations.Controllers
}
return BadRequest(result.ErrorMessage);
}
/// <summary>
/// PUT request for updating an existing region.
/// </summary>
[HttpPut]
public async Task<ActionResult> PutRegionAsync(Models.Region region)
[HttpPut("regions/{id}")]
public async Task<ActionResult> PutRegionAsync(int id, Models.Region region)
{
var result = await this.regionProvider.PutRegionAsync(region);
var result = await this.regionProvider.PutRegionAsync(id,region);
if (result.IsSuccess)
{
return Ok(result.Region);
@ -61,11 +71,15 @@ namespace DamageAssesment.Api.Locations.Controllers
return BadRequest(result.ErrorMessage);
}
/// <summary>
/// DELETE request for deleting a region based on ID.
/// </summary>
[HttpDelete("{Id}")]
public async Task<ActionResult> DeleteRegionAsync(string Id)
[HttpDelete("regions/{id}")]
public async Task<ActionResult> DeleteRegionAsync(int id)
{
var result = await this.regionProvider.DeleteRegionAsync(Id);
var result = await this.regionProvider.DeleteRegionAsync(id);
if (result.IsSuccess)
{
return Ok(result.Region);

4
DamageAssesmentApi/DamageAssesment.Api.Locations/DamageAssesment.Api.Locations.csproj
View File

@ -4,6 +4,7 @@
<TargetFramework>net6.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
<GenerateDocumentationFile>True</GenerateDocumentationFile>
</PropertyGroup>
<ItemGroup>
@ -19,6 +20,9 @@
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="6.0.21" />
<PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.5" />
<PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="7.0.5" />
<PackageReference Include="Swashbuckle.AspNetCore" Version="6.2.3" />
</ItemGroup>

10
DamageAssesmentApi/DamageAssesment.Api.Locations/Db/Location.cs
View File

@ -6,18 +6,20 @@ namespace DamageAssesment.Api.Locations.Db
public class Location
{
[Key]
public int Id { get; set; }
[ForeignKey("Region")]
public int RegionId { get; set; }
[StringLength(4)]
public string Id { get; set; }
public string LocationCode { get; set; }
[StringLength(50)]
public string Name { get; set; }
[StringLength(1)]
[StringLength(4)]
public string MaintenanceCenter { get; set; }
[StringLength(2)]
public string SchoolType { get; set; }
[ForeignKey("Region")]
public string RegionId { get; set; }
}
}

18
DamageAssesmentApi/DamageAssesment.Api.Locations/Db/LocationDbContext.cs
View File

@ -2,7 +2,7 @@
namespace DamageAssesment.Api.Locations.Db
{
public class LocationDbContext:DbContext
public class LocationDbContext : DbContext
{
private IConfiguration _Configuration { get; set; }
public LocationDbContext(DbContextOptions options, IConfiguration configuration) : base(options)
@ -16,5 +16,21 @@ namespace DamageAssesment.Api.Locations.Db
}
public DbSet<Db.Location> Locations { get; set; }
public DbSet<Db.Region> Regions { get; set; }
public LocationDbContext(DbContextOptions options) : base(options)
{
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity<Location>()
.Property(item => item.Id)
.ValueGeneratedOnAdd();
modelBuilder.Entity<Region>()
.Property(item => item.Id)
.ValueGeneratedOnAdd();
}
}
}

7
DamageAssesmentApi/DamageAssesment.Api.Locations/Db/Region.cs
View File

@ -5,15 +5,12 @@ namespace DamageAssesment.Api.Locations.Db
public class Region
{
[Key]
[StringLength(2)]
public string Id { get; set; }
public int Id { get; set; }
[StringLength(50)]
public string Name { get; set; }
[StringLength(5)]
public string Abbreviation { get; set; }
// public ICollection<Location> Locations { get; set; }
}
}

11
DamageAssesmentApi/DamageAssesment.Api.Locations/Interfaces/ILocationsProvider.cs
View File

@ -4,10 +4,11 @@ namespace DamageAssesment.Api.Locations.Interfaces
{
public interface ILocationsProvider
{
Task<(bool IsSuccess, IEnumerable<Models.Location> locations, string ErrorMessage)> GetLocationsAsync();
Task<(bool IsSuccess, Models.Location Location, string ErrorMessage)> GetLocationByIdAsync(string Id);
Task<(bool IsSuccess, Models.Location Question, string ErrorMessage)> PostLocationAsync(Db.Location Location);
Task<(bool IsSuccess, string ErrorMessage)> UpdateLocationAsync(Db.Location Location);
Task<(bool IsSuccess, string ErrorMessage)> DeleteLocationAsync(string Id);
Task<(bool IsSuccess, IEnumerable<Models.Location> Locations, string ErrorMessage)> GetLocationsAsync();
Task<(bool IsSuccess, Models.Location Location, string ErrorMessage)> GetLocationByIdAsync(int Id);
Task<(bool IsSuccess, Models.Location Location, string ErrorMessage)> PostLocationAsync(Models.Location Location);
Task<(bool IsSuccess, Models.Location Location, string ErrorMessage)> UpdateLocationAsync(int Id, Models.Location Location);
Task<(bool IsSuccess, Models.Location Location, string ErrorMessage)> DeleteLocationAsync(int Id);
void SeedData();
}
}

9
DamageAssesmentApi/DamageAssesment.Api.Locations/Interfaces/IRegionsProvider.cs
View File

@ -2,10 +2,11 @@
{
public interface IRegionsProvider
{
Task<(bool IsSuccess, IEnumerable<Models.Region> regions, string ErrorMessage)> GetRegionsAsync();
Task<(bool IsSuccess, Models.Region Region, string ErrorMessage)> GetRegionByIdAsync(string Id);
Task<(bool IsSuccess, IEnumerable<Models.Region> Regions, string ErrorMessage)> GetRegionsAsync();
Task<(bool IsSuccess, Models.Region Region, string ErrorMessage)> GetRegionByIdAsync(int Id);
Task<(bool IsSuccess, Models.Region Region, string ErrorMessage)> PostRegionAsync(Models.Region region);
Task<(bool IsSuccess, Models.Region Region, string ErrorMessage)> PutRegionAsync(Models.Region region);
Task<(bool IsSuccess, Models.Region Region, string ErrorMessage)> DeleteRegionAsync(string Id);
Task<(bool IsSuccess, Models.Region Region, string ErrorMessage)> PutRegionAsync(int Id, Models.Region region);
Task<(bool IsSuccess, Models.Region Region, string ErrorMessage)> DeleteRegionAsync(int Id);
void SeedData();
}
}

15
DamageAssesmentApi/DamageAssesment.Api.Locations/Models/Location.cs
View File

@ -4,19 +4,12 @@ namespace DamageAssesment.Api.Locations.Models
{
public class Location
{
[StringLength(4)]
public string Id { get; set; }
[StringLength(1)]
public string RegionId { get; set; }
[StringLength(50)]
[Key]
public int Id { get; set; }
public int RegionId { get; set; }
public string LocationCode { get; set; }
public string Name { get; set; }
[StringLength(1)]
public string MaintenanceCenter { get; set; }
[StringLength(2)]
public string SchoolType { get; set; }
}
}

8
DamageAssesmentApi/DamageAssesment.Api.Locations/Models/Region.cs
View File

@ -4,14 +4,8 @@ namespace DamageAssesment.Api.Locations.Models
{
public class Region
{
[StringLength(1)]
public string Id { get; set; }
[StringLength(50)]
public int Id { get; set; }
public string Name { get; set; }
[StringLength(5)]
public string Abbreviation { get; set; }
}
}

1
DamageAssesmentApi/DamageAssesment.Api.Locations/Profiles/LocationProfile.cs
View File

@ -5,6 +5,7 @@
public LocationProfile()
{
CreateMap<Db.Location, Models.Location>();
CreateMap<Models.Location, Db.Location>();
}
}
}

20
DamageAssesmentApi/DamageAssesment.Api.Locations/Program.cs
View File

@ -2,6 +2,7 @@ using DamageAssesment.Api.Locations.Db;
using DamageAssesment.Api.Locations.Interfaces;
using DamageAssesment.Api.Locations.Providers;
using Microsoft.EntityFrameworkCore;
using System.Reflection;
var builder = WebApplication.CreateBuilder(args);
@ -10,8 +11,14 @@ var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
//builder.Services.AddSwaggerGen();
builder.Services.AddSwaggerGen(c =>
{
// Include XML comments from your assembly
var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
c.IncludeXmlComments(xmlPath);
});
builder.Services.AddScoped<ILocationsProvider, LocationsProvider>();
builder.Services.AddScoped<IRegionsProvider, RegionsProvider>();
builder.Services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies()); //4/30
@ -26,6 +33,15 @@ if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
using (var serviceScope = app.Services.CreateScope())
{
var services = serviceScope.ServiceProvider;
var locationProvider = services.GetRequiredService<ILocationsProvider>();
var regionProvider = services.GetRequiredService<IRegionsProvider>();
locationProvider.SeedData();
regionProvider.SeedData();
}
}
app.UseAuthorization();

143
DamageAssesmentApi/DamageAssesment.Api.Locations/Providers/LocationsProvider.cs
View File

@ -17,42 +17,19 @@ namespace DamageAssesment.Api.Locations.Providers
this.locationDbContext = locationDbContext;
this.logger = logger;
this.mapper = mapper;
SeedData();
//SeedData();
}
public async Task<(bool IsSuccess, IEnumerable<Models.Location> locations, string ErrorMessage)> GetLocationsAsync()
{
try
{
logger?.LogInformation("Query Question");
var Location = await locationDbContext.Locations.AsNoTracking().ToListAsync();
if (Location != null)
{
logger?.LogInformation($"{Location.Count} Locations(s) found");
var result = mapper.Map<IEnumerable<Db.Location>, IEnumerable<Models.Location>>(Location);
return (true, result, null);
}
return (false, null, "Not found");
}
catch (Exception ex)
{
logger?.LogError(ex.ToString());
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.Location Location, string ErrorMessage)> GetLocationByIdAsync(string Id)
public async Task<(bool IsSuccess, IEnumerable<Models.Location> Locations, string ErrorMessage)> GetLocationsAsync()
{
try
{
logger?.LogInformation("Query Location");
var Location = await locationDbContext.Locations.AsNoTracking().FirstOrDefaultAsync(q => q.Id == Id);
if (Location != null)
var locations = await locationDbContext.Locations.AsNoTracking().ToListAsync();
if (locations != null)
{
logger?.LogInformation($"{Location} customer(s) found");
var result = mapper.Map<Db.Location, Models.Location>(Location);
logger?.LogInformation($"{locations.Count} Locations(s) found");
var result = mapper.Map<IEnumerable<Db.Location>, IEnumerable<Models.Location>>(locations);
return (true, result, null);
}
return (false, null, "Not found");
@ -63,21 +40,42 @@ namespace DamageAssesment.Api.Locations.Providers
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.Location Question, string ErrorMessage)> PostLocationAsync(Db.Location Location)
public async Task<(bool IsSuccess, Models.Location Location, string ErrorMessage)> GetLocationByIdAsync(int Id)
{
try
{
logger?.LogInformation("Query Location");
if (!LocationExists(Location.Id))
var location = await locationDbContext.Locations.AsNoTracking().FirstOrDefaultAsync(q => q.Id == Id);
if (location != null)
{
locationDbContext.Locations.Add(Location);
locationDbContext.SaveChanges();
var result = mapper.Map<Db.Location, Models.Location>(Location);
logger?.LogInformation($"{location} found");
var result = mapper.Map<Db.Location, Models.Location>(location);
return (true, result, null);
}
return (false, null, "Not found");
}
catch (Exception ex)
{
logger?.LogError(ex.ToString());
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.Location Location, string ErrorMessage)> PostLocationAsync(Models.Location location)
{
try
{
if (!LocationCodeExists(location.LocationCode))
{
Db.Location _location = mapper.Map<Models.Location, Db.Location>(location);
locationDbContext.Locations.Add(_location);
await locationDbContext.SaveChangesAsync();
location.Id = _location.Id;
return (true, location, null);
}
else
{
return (false, null, "Location is Already exists");
return (false, null, "Location code is already exists");
}
}
catch (Exception ex)
@ -86,56 +84,67 @@ namespace DamageAssesment.Api.Locations.Providers
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, string ErrorMessage)> UpdateLocationAsync(Db.Location Location)
public async Task<(bool IsSuccess, Models.Location Location, string ErrorMessage)> UpdateLocationAsync(int Id, Models.Location location)
{
try
{
locationDbContext.Entry(Location).State = EntityState.Modified;
locationDbContext.SaveChanges();
return (true, "Record updated successfully");
}
catch (Exception ex)
{
logger?.LogError(ex.ToString());
return (false, ex.Message);
}
}
public async Task<(bool IsSuccess, string ErrorMessage)> DeleteLocationAsync(string Id)
{
try
{
Db.Location Location = locationDbContext.Locations.AsNoTracking().Where(a => a.Id == Id).FirstOrDefault();
if (Location == null)
if (LocationExists(Id))
{
return (false, "record not found");
Db.Location _location = mapper.Map<Models.Location, Db.Location>(location);
locationDbContext.Entry(_location).State = EntityState.Modified;
await locationDbContext.SaveChangesAsync();
return (true, location, "Record updated successfully");
}
else
{
return (false, null, "Location is not exists");
}
locationDbContext.Locations.Remove(Location);
locationDbContext.SaveChanges();
return (true, "Record deleted successfully");
}
catch (Exception ex)
{
logger?.LogError(ex.ToString());
return (false, ex.Message);
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.Location Location, string ErrorMessage)> DeleteLocationAsync(int Id)
{
try
{
Db.Location location = locationDbContext.Locations.AsNoTracking().Where(a => a.Id == Id).FirstOrDefault();
if (location == null)
{
return (false, null, "record not found");
}
locationDbContext.Locations.Remove(location);
await locationDbContext.SaveChangesAsync();
return (true, mapper.Map<Db.Location, Models.Location>(location), "Record deleted successfully");
}
catch (Exception ex)
{
logger?.LogError(ex.ToString());
return (false, null, ex.Message);
}
}
private bool LocationExists(string id)
private bool LocationExists(int id)
{
return locationDbContext.Locations.AsNoTracking().Count(e => e.Id == id) > 0;
}
private void SeedData()
private bool LocationCodeExists(string locationCode)
{
return locationDbContext.Locations.AsNoTracking().Count(e => e.LocationCode.ToLower() == locationCode.ToLower()) > 0;
}
public void SeedData()
{
if (!locationDbContext.Locations.Any())
{
locationDbContext.Locations.Add(new Db.Location() { Id = "Loc1", RegionId = "1", Name = "BOB GRAHAM EDUCATION CENTER 1", MaintenanceCenter = "1", SchoolType = "US" });
locationDbContext.Locations.Add(new Db.Location() { Id = "Loc2", RegionId = "2", Name = "BOB GRAHAM EDUCATION CENTER 2", MaintenanceCenter = "1", SchoolType = "US" });
locationDbContext.Locations.Add(new Db.Location() { Id = "Loc3", RegionId = "3", Name = "BOB GRAHAM EDUCATION CENTER 3", MaintenanceCenter = "1", SchoolType = "US" });
locationDbContext.Locations.Add(new Db.Location() { Id = "Loc4", RegionId = "1", Name = "BOB GRAHAM EDUCATION CENTER 4", MaintenanceCenter = "1", SchoolType = "US" });
locationDbContext.Locations.Add(new Db.Location() { Id = "Loc5", RegionId = "2", Name = "BOB GRAHAM EDUCATION CENTER 5", MaintenanceCenter = "1", SchoolType = "US" });
locationDbContext.Locations.Add(new Db.Location() { Id = "Loc6", RegionId = "3", Name = "BOB GRAHAM EDUCATION CENTER 6", MaintenanceCenter = "1", SchoolType = "US" });
locationDbContext.Locations.Add(new Db.Location() { LocationCode = "Loc1", RegionId = 1, Name = "BOB GRAHAM EDUCATION CENTER 1", MaintenanceCenter = "1", SchoolType = "US" });
locationDbContext.Locations.Add(new Db.Location() { LocationCode = "Loc2", RegionId = 2, Name = "BOB GRAHAM EDUCATION CENTER 2", MaintenanceCenter = "1", SchoolType = "US" });
locationDbContext.Locations.Add(new Db.Location() { LocationCode = "Loc3", RegionId = 3, Name = "BOB GRAHAM EDUCATION CENTER 3", MaintenanceCenter = "1", SchoolType = "US" });
locationDbContext.Locations.Add(new Db.Location() { LocationCode = "Loc4", RegionId = 1, Name = "BOB GRAHAM EDUCATION CENTER 4", MaintenanceCenter = "1", SchoolType = "US" });
locationDbContext.Locations.Add(new Db.Location() { LocationCode = "Loc5", RegionId = 2, Name = "BOB GRAHAM EDUCATION CENTER 5", MaintenanceCenter = "1", SchoolType = "US" });
locationDbContext.Locations.Add(new Db.Location() { LocationCode = "Loc6", RegionId = 3, Name = "BOB GRAHAM EDUCATION CENTER 6", MaintenanceCenter = "1", SchoolType = "US" });
locationDbContext.SaveChanges();
}

53
DamageAssesmentApi/DamageAssesment.Api.Locations/Providers/RegionsProvider.cs
View File

@ -1,7 +1,6 @@
using AutoMapper;
using DamageAssesment.Api.Locations.Db;
using DamageAssesment.Api.Locations.Interfaces;
using DamageAssesment.Api.Locations.Models;
using Microsoft.EntityFrameworkCore;
namespace DamageAssesment.Api.Locations.Providers
@ -17,10 +16,10 @@ namespace DamageAssesment.Api.Locations.Providers
this.locationDbContext = regionDbContext;
this.logger = logger;
this.mapper = mapper;
SeedData();
//SeedData();
}
public async Task<(bool IsSuccess, Models.Region Region, string ErrorMessage)> GetRegionByIdAsync(string Id)
public async Task<(bool IsSuccess, Models.Region Region, string ErrorMessage)> GetRegionByIdAsync(int Id)
{
try
{
@ -42,7 +41,7 @@ namespace DamageAssesment.Api.Locations.Providers
}
}
public async Task<(bool IsSuccess, IEnumerable<Models.Region> regions, string ErrorMessage)> GetRegionsAsync()
public async Task<(bool IsSuccess, IEnumerable<Models.Region> Regions, string ErrorMessage)> GetRegionsAsync()
{
try
{
@ -70,11 +69,10 @@ namespace DamageAssesment.Api.Locations.Providers
{
if (region != null)
{
var regions = await locationDbContext.Regions.AsNoTracking().ToListAsync();
region.Id = Convert.ToString(regions.Count + 1);
locationDbContext.Regions.Add(mapper.Map<Models.Region, Db.Region>(region));
locationDbContext.SaveChanges();
var _region = mapper.Map<Models.Region, Db.Region>(region);
locationDbContext.Regions.Add(_region);
await locationDbContext.SaveChangesAsync();
region.Id = _region.Id;
logger?.LogInformation($"{region} added successfuly");
return (true, region, "Successful");
}
@ -91,30 +89,38 @@ namespace DamageAssesment.Api.Locations.Providers
}
}
public async Task<(bool IsSuccess, Models.Region Region, string ErrorMessage)> PutRegionAsync(Models.Region region)
public async Task<(bool IsSuccess, Models.Region Region, string ErrorMessage)> PutRegionAsync(int Id, Models.Region region)
{
try
{
if (region != null)
{
var _region = await locationDbContext.Regions.AsNoTracking().Where(s => s.Id == region.Id).FirstOrDefaultAsync();
var _region = await locationDbContext.Regions.AsNoTracking().Where(s => s.Id == Id).FirstOrDefaultAsync();
if (_region != null)
{
locationDbContext.Regions.Update(mapper.Map<Models.Region, Db.Region>(region));
locationDbContext.SaveChanges();
return (true, region, "Region updated Successfuly");
if (RegionExists(region.Id))
{
locationDbContext.Regions.Update(mapper.Map<Models.Region, Db.Region>(region));
locationDbContext.SaveChanges();
return (true, region, "Region updated Successfuly");
}
else
{
logger?.LogInformation($"RegionID: {Id} Not exists");
return (false, null, "Region not exists");
}
}
else
{
logger?.LogInformation($"RegionID: {region.Id} Not found");
logger?.LogInformation($"RegionID: {Id} Not found");
return (false, null, "Not Found");
}
}
else
{
logger?.LogInformation($"RegionID: {region.Id} Bad Request");
logger?.LogInformation($"RegionID: {Id} Bad Request");
return (false, null, "Bad request");
}
}
@ -125,7 +131,7 @@ namespace DamageAssesment.Api.Locations.Providers
}
}
public async Task<(bool IsSuccess, Models.Region Region, string ErrorMessage)> DeleteRegionAsync(string Id)
public async Task<(bool IsSuccess, Models.Region Region, string ErrorMessage)> DeleteRegionAsync(int Id)
{
try
{
@ -150,13 +156,18 @@ namespace DamageAssesment.Api.Locations.Providers
}
}
private void SeedData()
private bool RegionExists(int id)
{
return locationDbContext.Regions.AsNoTracking().Count(e => e.Id == id) > 0;
}
public void SeedData()
{
if (!locationDbContext.Regions.Any())
{
locationDbContext.Regions.Add(new Db.Region() { Id = "1", Name = "North", Abbreviation = "N" });
locationDbContext.Regions.Add(new Db.Region() { Id = "2", Name = "South", Abbreviation = "S" });
locationDbContext.Regions.Add(new Db.Region() { Id = "3", Name = "Central", Abbreviation = "C" });
locationDbContext.Regions.Add(new Db.Region() { Name = "North", Abbreviation = "N" });
locationDbContext.Regions.Add(new Db.Region() { Name = "South", Abbreviation = "S" });
locationDbContext.Regions.Add(new Db.Region() { Name = "Central", Abbreviation = "C" });
locationDbContext.SaveChanges();
}
}

3
DamageAssesmentApi/DamageAssesment.Api.Locations/appsettings.json
View File

@ -1,4 +1,7 @@
{
"JwtSettings": {
"securitykey": "bWlhbWkgZGFkZSBzY2hvb2xzIHNlY3JldCBrZXk="
},
"Logging": {
"LogLevel": {
"Default": "Information",

105
DamageAssesmentApi/DamageAssesment.Api.Questions/Controllers/QuestionsController.cs
View File

@ -1,13 +1,8 @@
using DamageAssesment.Api.Questions.Db;
using DamageAssesment.Api.Questions.Interfaces;
using DamageAssesment.Api.Questions.Models;
using DamageAssesment.Api.Questions.Providers;
using Microsoft.AspNetCore.Http;
using DamageAssesment.Api.Questions.Interfaces;
using Microsoft.AspNetCore.Mvc;
namespace DamageAssesment.Api.Questions.Controllers
{
[Route("api")]
[ApiController]
public class QuestionsController : ControllerBase
{
@ -19,41 +14,63 @@ namespace DamageAssesment.Api.Questions.Controllers
this.questionsProvider = questionsProvider;
}
/// <summary>
/// GET request for retrieving questions.
/// </summary>
// get all questions
[HttpGet("Questions")]
public async Task<IActionResult> GetQuestionsAsync()
[Route("Questions")]
[Route("Questions/{language:alpha}")]
[HttpGet]
public async Task<IActionResult> GetQuestionsAsync(string? language)
{
var result = await this.questionsProvider.GetQuestionsAsync();
var result = await this.questionsProvider.GetQuestionsAsync(language);
if (result.IsSuccess)
{
return Ok(result.Questions);
}
return NoContent();
}
//Get questions based on question id
[HttpGet("Questions/{id}")]
public async Task<IActionResult> GetQuestionAsync(int id)
/// <summary>
/// GET request for retrieving a question by ID.
/// </summary>
[Route("Questions/{id}/{language:alpha}")]
[Route("Questions/{id:int}")]
[HttpGet]
public async Task<IActionResult> GetQuestionByIdAsync(int id, string? language)
{
var result = await this.questionsProvider.GetQuestionAsync(id);
var result = await this.questionsProvider.GetQuestionAsync(id, language);
if (result.IsSuccess)
{
return Ok(result.Question);
}
return NotFound();
}
//get all questions based on survey id
[HttpGet("GetSurveyQuestions/{surveyId}")]
public async Task<IActionResult> GetSurveyQuestions(int surveyId,string? Language)
/// <summary>
/// GET request for retrieving survey questions based on a survey ID.
/// Uri: {Optional language}/GetSurveyQuestions/{surveyId} :Default returns question in all languages
/// </summary>
[Route("Questions/BySurvey/{surveyId:int}")]
[Route("Questions/BySurvey/{surveyId:int}/{language:alpha}")]
[HttpGet]
public async Task<IActionResult> GetSurveyQuestions(int surveyId,string? language)
{
if (string.IsNullOrEmpty(Language)) Language = "en";
var result = await this.questionsProvider.GetSurveyQuestionAsync(surveyId, Language);
var result = await this.questionsProvider.GetSurveyQuestionAsync(surveyId, language);
if (result.IsSuccess)
{
return Ok(result.SurveyQuestions);
}
return NotFound();
}
//update existing question
/// <summary>
/// PUT request for updating a question (multilingual).
/// </summary>
[HttpPut("Questions")]
public async Task<IActionResult> UpdateQuestion(Models.Question question)
{
@ -71,7 +88,10 @@ namespace DamageAssesment.Api.Questions.Controllers
}
return CreatedAtRoute("DefaultApi", new { id = question.Id }, question);
}
//save new question
/// <summary>
/// POST request for creating a new question (multilingual).
/// </summary>
[HttpPost("Questions")]
public async Task<IActionResult> CreateQuestion(Models.Question question)
{
@ -86,7 +106,10 @@ namespace DamageAssesment.Api.Questions.Controllers
}
return CreatedAtRoute("DefaultApi", new { id = question.Id }, question);
}
// delete existing question
/// <summary>
/// DELETE request for deleting a question based on ID.
/// </summary>
[HttpDelete("Questions/{id}")]
public async Task<IActionResult> DeleteQuestion(int id)
{
@ -98,23 +121,30 @@ namespace DamageAssesment.Api.Questions.Controllers
return NotFound();
}
/// <summary>
/// GET request for retrieving question categories.
/// </summary>
// get all questions
[HttpGet("QuestionCategories")]
public async Task<IActionResult> GetQuestionCategoriesAsync()
[HttpGet("Questions/Categories")]
[HttpGet("Questions/Categories/{language:alpha}")]
public async Task<IActionResult> GetQuestionCategoriesAsync(string? language)
{
var result = await this.questionsProvider.GetQuestionCategoriesAsync();
var result = await this.questionsProvider.GetQuestionCategoriesAsync(language);
if (result.IsSuccess)
{
return Ok(result.QuestionCategories);
}
return NoContent();
}
//Get questions based on question id
[HttpGet("QuestionCategories/{id}")]
public async Task<IActionResult> GetQuestionCategoryAsync(int id)
/// <summary>
/// GET request for retrieving a question category by ID.
/// </summary>
[HttpGet("Questions/Categories/{id:int}")]
[HttpGet("Questions/Categories/{id:int}/{language:alpha}")]
public async Task<IActionResult> GetQuestionCategoryAsync(int id,string? language)
{
var result = await this.questionsProvider.GetQuestionCategoryAsync(id);
var result = await this.questionsProvider.GetQuestionCategoryAsync(id, language);
if (result.IsSuccess)
{
return Ok(result.QuestionCategory);
@ -123,8 +153,11 @@ namespace DamageAssesment.Api.Questions.Controllers
}
//update existing question
[HttpPut("QuestionCategories")]
/// <summary>
/// PUT request for updating a question category.
/// </summary>
[HttpPut("Questions/Categories")]
public async Task<IActionResult> UpdateQuestionCategory(Models.QuestionCategory questionCategory)
{
if (questionCategory != null)
@ -141,8 +174,11 @@ namespace DamageAssesment.Api.Questions.Controllers
}
return CreatedAtRoute("DefaultApi", new { id = questionCategory.Id }, questionCategory);
}
//save new question
[HttpPost("QuestionCategories")]
/// <summary>
/// POST request for creating a new question category.
/// </summary>
[HttpPost("Questions/Categories")]
public async Task<IActionResult> CreateQuestionCategory(Models.QuestionCategory questionCategory)
{
if (questionCategory != null)
@ -156,8 +192,11 @@ namespace DamageAssesment.Api.Questions.Controllers
}
return CreatedAtRoute("DefaultApi", new { id = questionCategory.Id }, questionCategory);
}
// delete existing question
[HttpDelete("QuestionCategories/{id}")]
/// <summary>
/// DELETE request for deleting a question category based on ID.
/// </summary>
[HttpDelete("Questions/Categories/{id}")]
public async Task<IActionResult> DeleteQuestionCategory(int id)
{
var result = await this.questionsProvider.DeleteQuestionCategoryAsync(id);

6
DamageAssesmentApi/DamageAssesment.Api.Questions/DamageAssesment.Api.Questions.csproj
View File

@ -1,9 +1,10 @@
<Project Sdk="Microsoft.NET.Sdk.Web">
<Project Sdk="Microsoft.NET.Sdk.Web">
<PropertyGroup>
<TargetFramework>net6.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
<GenerateDocumentationFile>True</GenerateDocumentationFile>
</PropertyGroup>
<ItemGroup>
@ -19,6 +20,9 @@
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="6.0.21" />
<PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.5" />
<PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="7.0.5" />
<PackageReference Include="Swashbuckle.AspNetCore" Version="6.2.3" />
</ItemGroup>

15
DamageAssesmentApi/DamageAssesment.Api.Questions/Db/CategoryTranslation.cs Normal file
View File

@ -0,0 +1,15 @@
using System.ComponentModel.DataAnnotations.Schema;
using System.ComponentModel.DataAnnotations;
namespace DamageAssesment.Api.Questions.Db
{
public class CategoryTranslation
{
[Key]
public int Id { get; set; }
[ForeignKey("QuestionCategory")]
public int CategoryId { get; set; }
public string Title { get; set; }
public string Language { get; set; }
}
}

1
DamageAssesmentApi/DamageAssesment.Api.Questions/Db/Question.cs
View File

@ -20,7 +20,6 @@ namespace DamageAssesment.Api.Questions.Db
public bool Key { get; set; }
[ForeignKey("Survey")]
public int? SurveyId { get; set; }
public string QuestionGroup { get; set; }
[ForeignKey("QuestionCategory")]
public int CategoryId { get; set; }

4
DamageAssesmentApi/DamageAssesment.Api.Questions/Db/QuestionCategory.cs
View File

@ -7,8 +7,8 @@ namespace DamageAssesment.Api.Questions.Db
{
[Key]
public int Id { get; set; }
public string CategoryName { get; set; }
public string CategoryImage { get; set; }
public string IconName { get; set; }
public string IconLibrary { get; set; }
}
}

31
DamageAssesmentApi/DamageAssesment.Api.Questions/Db/QuestionDbContext.cs
View File

@ -20,12 +20,29 @@ namespace DamageAssesment.Api.Questions.Db
public DbSet<Db.QuestionType> QuestionTypes { get; set; }
public DbSet<Db.QuestionsTranslation> QuestionsTranslations { get; set; }
public DbSet<Db.QuestionCategory> QuestionCategories { get; set; }
//protected override void OnModelCreating(ModelBuilder modelBuilder)
//{
// modelBuilder.Entity<Question>()
// .HasOne(a => a.QuestionType)
// .WithOne(b => b.Question)
// .HasForeignKey<QuestionType>(b => b.QuestionTypeID);
//}
public DbSet<Db.CategoryTranslation> CategoryTranslations { get; set; }
public QuestionDbContext(DbContextOptions options) : base(options)
{
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity<Question>()
.Property(item => item.Id)
.ValueGeneratedOnAdd();
modelBuilder.Entity<QuestionType>()
.Property(item => item.Id)
.ValueGeneratedOnAdd();
modelBuilder.Entity<QuestionsTranslation>()
.Property(item => item.Id)
.ValueGeneratedOnAdd();
modelBuilder.Entity<QuestionCategory>()
.Property(item => item.Id)
.ValueGeneratedOnAdd();
modelBuilder.Entity<CategoryTranslation>()
.Property(item => item.Id)
.ValueGeneratedOnAdd();
}
}
}

23
DamageAssesmentApi/DamageAssesment.Api.Questions/Interfaces/IQuestionsProvider.cs
View File

@ -4,18 +4,19 @@ namespace DamageAssesment.Api.Questions.Interfaces
{
public interface IQuestionsProvider : IQuestionTypesProvider
{
Task<(bool IsSuccess, Models.Question Question, string ErrorMessage)> GetQuestionAsync(int Id);
Task<(bool IsSuccess, IEnumerable<Models.Question> Questions, string ErrorMessage)> GetQuestionsAsync();
Task<(bool IsSuccess, List<SurveyQuestions> SurveyQuestions, string ErrorMessage)> GetSurveyQuestionAsync(int surveyId,string Language);
Task<(bool IsSuccess, Models.Question Question, string ErrorMessage)> PostQuestionAsync(Models.Question Question);
Task<(bool IsSuccess, Models.Question Question, string ErrorMessage)> UpdateQuestionAsync(Models.Question Question);
Task<(bool IsSuccess, Models.Question Question, string ErrorMessage)> DeleteQuestionAsync(int Id);
Task<(bool IsSuccess, Models.MultiLanguage Question, string ErrorMessage)> GetQuestionAsync(int id, string language);
Task<(bool IsSuccess, IEnumerable<Models.MultiLanguage> Questions, string ErrorMessage)> GetQuestionsAsync(string language);
Task<(bool IsSuccess, List<SurveyQuestions> SurveyQuestions, string ErrorMessage)> GetSurveyQuestionAsync(int surveyId,string language);
Task<(bool IsSuccess, Models.MultiLanguage Question, string ErrorMessage)> PostQuestionAsync(Models.Question Question);
Task<(bool IsSuccess, Models.MultiLanguage Question, string ErrorMessage)> UpdateQuestionAsync(Models.Question Question);
Task<(bool IsSuccess, Models.MultiLanguage Question, string ErrorMessage)> DeleteQuestionAsync(int id);
Task<(bool IsSuccess, IEnumerable<Models.QuestionCategory> QuestionCategories, string ErrorMessage)> GetQuestionCategoriesAsync();
Task<(bool IsSuccess, Models.QuestionCategory QuestionCategory, string ErrorMessage)> GetQuestionCategoryAsync(int Id);
Task<(bool IsSuccess, Models.QuestionCategory QuestionCategory, string ErrorMessage)> PostQuestionCategoryAsync(Models.QuestionCategory QuestionCategory);
Task<(bool IsSuccess, Models.QuestionCategory QuestionCategory, string ErrorMessage)> UpdateQuestionCategoryAsync(Models.QuestionCategory QuestionCategory);
Task<(bool IsSuccess, Models.QuestionCategory QuestionCategory, string ErrorMessage)> DeleteQuestionCategoryAsync(int Id);
Task<(bool IsSuccess, IEnumerable<Models.MultiLanQuestionCategory> QuestionCategories, string ErrorMessage)> GetQuestionCategoriesAsync(string? language);
Task<(bool IsSuccess, Models.MultiLanQuestionCategory QuestionCategory, string ErrorMessage)> GetQuestionCategoryAsync(int id, string? language);
Task<(bool IsSuccess, Models.MultiLanQuestionCategory QuestionCategory, string ErrorMessage)> PostQuestionCategoryAsync(Models.QuestionCategory QuestionCategory);
Task<(bool IsSuccess, Models.MultiLanQuestionCategory QuestionCategory, string ErrorMessage)> UpdateQuestionCategoryAsync(Models.QuestionCategory QuestionCategory);
Task<(bool IsSuccess, Models.MultiLanQuestionCategory QuestionCategory, string ErrorMessage)> DeleteQuestionCategoryAsync(int id);
void SeedData();
}
}

8
DamageAssesmentApi/DamageAssesment.Api.Questions/Models/CategoryTranslation.cs Normal file
View File

@ -0,0 +1,8 @@
namespace DamageAssesment.Api.Questions.Models
{
public class CategoryTranslation
{
public string Title { get; set; }
public string Language { get; set; }
}
}

18
DamageAssesmentApi/DamageAssesment.Api.Questions/Models/Question.cs
View File

@ -1,24 +1,18 @@
using System.ComponentModel.DataAnnotations;
namespace DamageAssesment.Api.Questions.Models
namespace DamageAssesment.Api.Questions.Models
{
public class Question
public class Question: BaseQuestion
{
public List<QuestionsTranslation> Questions { get; set; }
}
public class BaseQuestion
{
public int Id { get; set; }
public List<QuestionsTranslation> Questions { get; set; }
//public int QuestionTypeID { get; set; }
public string TypeText { get; set; } = string.Empty;
public int QuestionNumber { get; set; }
public bool IsRequired { get; set; }
public bool Comment { get; set; }
public bool Key { get; set; }
public int? SurveyId { get; set; }
public string QuestionGroup { get; set; }
public int CategoryId { get; set; }
// public int? Survey_SurveyID { get; set; }
}
}

14
DamageAssesmentApi/DamageAssesment.Api.Questions/Models/QuestionCategory.cs
View File

@ -1,9 +1,17 @@
namespace DamageAssesment.Api.Questions.Models
{
public class QuestionCategory
public class MultiLanQuestionCategory : BaseQuestionCategory
{
public object Titles { get; set; }
}
public class QuestionCategory : BaseQuestionCategory
{
public List<CategoryTranslation> Categories { get; set; }
}
public class BaseQuestionCategory
{
public int Id { get; set; }
public string CategoryName { get; set; }
public string CategoryImage { get; set; }
public string IconName { get; set; }
public string IconLibrary { get; set; }
}
}

6
DamageAssesmentApi/DamageAssesment.Api.Questions/Models/QuestionsTranslation.cs
View File

@ -3,6 +3,10 @@
public class QuestionsTranslation
{
public string QuestionText { get; set; }
public string Language { get; set; } = "En";
public string Language { get; set; } = "en";
}
public class MultiLanguage : BaseQuestion
{
public Dictionary<string,string> Text { get; set; }
}
}

6
DamageAssesmentApi/DamageAssesment.Api.Questions/Models/SurveyQuestion.cs
View File

@ -3,8 +3,8 @@
public class SurveyQuestions
{
public int CategoryId { get; set; }
public string CategoryName { get; set; }
public string CategoryImage { get; set; }
public List<Question> Questions { get; set; }
public string IconName { get; set; }
public string IconLibrary { get; set; }
public List<MultiLanguage> QuestionsText { get; set; }
}
}

6
DamageAssesmentApi/DamageAssesment.Api.Questions/Profiles/QuestionProfile.cs
View File

@ -8,11 +8,15 @@ namespace DamageAssesment.Api.Questions.Profiles
{
CreateMap<Db.Question, Models.Question>().ForMember(dest => dest.TypeText,
opt => opt.MapFrom(src => src.QuestionType.TypeText));
CreateMap<Db.Question, Models.MultiLanguage>().ForMember(dest => dest.TypeText,
opt => opt.MapFrom(src => src.QuestionType.TypeText));
CreateMap<Models.QuestionCategory, Db.QuestionCategory>();
CreateMap<Db.QuestionCategory, Models.QuestionCategory>();
CreateMap<Db.QuestionCategory, Models.MultiLanQuestionCategory>();
CreateMap<Models.Question, Db.Question>();
CreateMap<Db.QuestionsTranslation, Models.QuestionsTranslation>();
CreateMap<Models.QuestionsTranslation, Db.QuestionsTranslation>();
CreateMap<Db.CategoryTranslation, Models.CategoryTranslation>();
CreateMap<Models.CategoryTranslation, Db.CategoryTranslation>();
}
}
}

19
DamageAssesmentApi/DamageAssesment.Api.Questions/Program.cs
View File

@ -2,7 +2,7 @@ using DamageAssesment.Api.Questions.Db;
using DamageAssesment.Api.Questions.Interfaces;
using DamageAssesment.Api.Questions.Providers;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;
using System.Reflection;
var builder = WebApplication.CreateBuilder(args);
@ -15,9 +15,15 @@ builder.Services.AddControllers();
builder.Services.AddScoped<IQuestionsProvider, QuestionsProvider>();
builder.Services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
//builder.Services.AddSwaggerGen();
builder.Services.AddSwaggerGen(c =>
{
// Include XML comments from your assembly
var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
c.IncludeXmlComments(xmlPath);
});
builder.Services.AddDbContext<QuestionDbContext>(option =>
{
option.UseSqlServer("QuestionConnection");
@ -29,6 +35,13 @@ if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
using (var serviceScope = app.Services.CreateScope())
{
var services = serviceScope.ServiceProvider;
var questionProvider = services.GetRequiredService<IQuestionsProvider>();
questionProvider.SeedData();
}
}
app.UseAuthorization();

208
DamageAssesmentApi/DamageAssesment.Api.Questions/Providers/QuestionsProvider.cs
View File

@ -2,9 +2,7 @@
using DamageAssesment.Api.Questions.Db;
using DamageAssesment.Api.Questions.Interfaces;
using DamageAssesment.Api.Questions.Models;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
namespace DamageAssesment.Api.Questions.Providers
{
@ -24,18 +22,16 @@ namespace DamageAssesment.Api.Questions.Providers
SeedData();
}
private void SeedData()
public void SeedData()
{
if (!questionDbContext.QuestionCategories.Any())
{
questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { CategoryName = "Electrical", CategoryImage = "img1" });
questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { CategoryName = "Flooding", CategoryImage = "img1" });
questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { CategoryName = "Structural", CategoryImage = "img1" });
questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { CategoryName = "Utility", CategoryImage = "img1" });
questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { CategoryName = "Debris", CategoryImage = "img1" });
questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { IconName = "Electrical", IconLibrary = "img1" });
questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { IconName = "Flooding", IconLibrary = "img1" });
questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { IconName = "Structural", IconLibrary = "img1" });
questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { IconName = "Utility", IconLibrary = "img1" });
questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { IconName = "Debris", IconLibrary = "img1" });
questionDbContext.SaveChanges();
}
if (!questionDbContext.QuestionTypes.Any())
@ -47,9 +43,9 @@ namespace DamageAssesment.Api.Questions.Providers
}
if (!questionDbContext.Questions.Any())
{
questionDbContext.Questions.Add(new Db.Question() { QuestionTypeId = 2, SurveyId = 1, QuestionNumber = 1, IsRequired = true, Comment = false, Key = true, QuestionGroup = "group1",CategoryId=1 });
questionDbContext.Questions.Add(new Db.Question() { QuestionTypeId = 3, SurveyId = 1, QuestionNumber = 2, IsRequired = false, Comment = true, Key = false, QuestionGroup = "group1", CategoryId = 1 });
questionDbContext.Questions.Add(new Db.Question() { QuestionTypeId = 1, SurveyId = 1, QuestionNumber = 3, IsRequired = true, Comment = false, Key = true, QuestionGroup = "group1", CategoryId = 2 });
questionDbContext.Questions.Add(new Db.Question() { QuestionTypeId = 2, SurveyId = 1, QuestionNumber = 1, IsRequired = true, Comment = false, Key = true, CategoryId=1 });
questionDbContext.Questions.Add(new Db.Question() { QuestionTypeId = 3, SurveyId = 1, QuestionNumber = 2, IsRequired = false, Comment = true, Key = false, CategoryId = 1 });
questionDbContext.Questions.Add(new Db.Question() { QuestionTypeId = 1, SurveyId = 1, QuestionNumber = 3, IsRequired = true, Comment = false, Key = true, CategoryId = 2 });
questionDbContext.SaveChanges();
}
if (!questionDbContext.QuestionsTranslations.Any())
@ -66,9 +62,81 @@ namespace DamageAssesment.Api.Questions.Providers
questionDbContext.SaveChanges();
}
if (!questionDbContext.CategoryTranslations.Any())
{
questionDbContext.CategoryTranslations.Add(new Db.CategoryTranslation() { CategoryId = 1, Title = "Flooding", Language = "en" });
questionDbContext.CategoryTranslations.Add(new Db.CategoryTranslation() { CategoryId = 2, Title = "Electrical", Language = "en" });
questionDbContext.CategoryTranslations.Add(new Db.CategoryTranslation() { CategoryId = 3, Title = "Structural", Language = "en" });
questionDbContext.CategoryTranslations.Add(new Db.CategoryTranslation() { CategoryId = 4, Title = "Utility", Language = "en" });
questionDbContext.CategoryTranslations.Add(new Db.CategoryTranslation() { CategoryId = 5, Title = "Debris", Language = "en" });
questionDbContext.CategoryTranslations.Add(new Db.CategoryTranslation() { CategoryId = 1, Title = "Inondation", Language = "fr" });
questionDbContext.CategoryTranslations.Add(new Db.CategoryTranslation() { CategoryId = 2, Title = "Électrique", Language = "fr" });
questionDbContext.CategoryTranslations.Add(new Db.CategoryTranslation() { CategoryId = 3, Title = "De construction", Language = "fr" });
questionDbContext.CategoryTranslations.Add(new Db.CategoryTranslation() { CategoryId = 4, Title = "Utilitaire", Language = "fr" });
questionDbContext.CategoryTranslations.Add(new Db.CategoryTranslation() { CategoryId = 5, Title = "Débris", Language = "fr" });
questionDbContext.CategoryTranslations.Add(new Db.CategoryTranslation() { CategoryId = 1, Title = "Inundación", Language = "es" });
questionDbContext.CategoryTranslations.Add(new Db.CategoryTranslation() { CategoryId = 2, Title = "Eléctrica", Language = "es" });
questionDbContext.CategoryTranslations.Add(new Db.CategoryTranslation() { CategoryId = 3, Title = "Estructural", Language = "es" });
questionDbContext.CategoryTranslations.Add(new Db.CategoryTranslation() { CategoryId = 4, Title = "Utilidad", Language = "es" });
questionDbContext.CategoryTranslations.Add(new Db.CategoryTranslation() { CategoryId = 5, Title = "Escombros", Language = "es" });
questionDbContext.SaveChanges();
}
}
public async Task<(bool IsSuccess, IEnumerable<Models.Question> Questions, string ErrorMessage)> GetQuestionsAsync()
public List<Models.CategoryTranslation> GetCategoryTranslations(int id, string? language)
{
List<Models.CategoryTranslation> categoryTranslations = new List<Models.CategoryTranslation>();
if (string.IsNullOrEmpty(language))
{
categoryTranslations = mapper.Map<List<Db.CategoryTranslation>, List<Models.CategoryTranslation>>(
questionDbContext.CategoryTranslations.AsNoTracking().Where(a => a.CategoryId == id).ToList());
}
else
{
categoryTranslations = mapper.Map<List<Db.CategoryTranslation>, List<Models.CategoryTranslation>>(
questionDbContext.CategoryTranslations.AsNoTracking().Where(a => a.CategoryId == id && a.Language == language).ToList());
}
return categoryTranslations;
}
public object CreateCategoryMultiLanguageObject(List<Models.CategoryTranslation> categoryTranslations)
{
object MultiLanguage = new object();
Dictionary<string, string> dict = new Dictionary<string, string>();
foreach (Models.CategoryTranslation item in categoryTranslations)
{
dict.Add(item.Language, item.Title);
}
MultiLanguage = dict;
return MultiLanguage;
}
public List<Models.QuestionsTranslation> GetQuestionsTranslations(int id, string? language)
{
List<Models.QuestionsTranslation> QuestionTranslations;
if (string.IsNullOrEmpty(language))
{
QuestionTranslations = mapper.Map<List<Db.QuestionsTranslation>, List<Models.QuestionsTranslation>>(
questionDbContext.QuestionsTranslations.AsNoTracking().Where(a => a.QuestionId == id).ToList());
}
else
{
QuestionTranslations = mapper.Map<List<Db.QuestionsTranslation>, List<Models.QuestionsTranslation>>(
questionDbContext.QuestionsTranslations.AsNoTracking().Where(a => a.QuestionId == id && a.Language == language).ToList());
}
return QuestionTranslations;
}
public Dictionary<string, string> CreateMultiLanguageObject(List<Models.QuestionsTranslation> questions)
{
MultiLanguage MultiLanguage = new MultiLanguage();
Dictionary<string, string> dict = new Dictionary<string, string>();
foreach (Models.QuestionsTranslation item in questions)
{
dict.Add(item.Language, item.QuestionText);
}
//MultiLanguage.questionText = dict;
return dict;
}
public async Task<(bool IsSuccess, IEnumerable<Models.MultiLanguage> Questions, string ErrorMessage)> GetQuestionsAsync(string language)
{
try
{
@ -78,11 +146,10 @@ namespace DamageAssesment.Api.Questions.Providers
{
//logger?.LogInformation($"{question} customer(s) found");
var result = mapper.Map<IEnumerable<Db.Question>, IEnumerable<Models.Question>>(questions);
foreach (var question in result)
var result = mapper.Map<IEnumerable<Db.Question>, IEnumerable<Models.MultiLanguage>>(questions);
foreach (var item in result)
{
question.Questions=mapper.Map<List<Db.QuestionsTranslation>,List<Models.QuestionsTranslation>>(
questionDbContext.QuestionsTranslations.Where(a=>a.QuestionId==question.Id).ToList());
item.Text = CreateMultiLanguageObject(GetQuestionsTranslations(item.Id, language));
}
return (true, result, null);
}
@ -94,18 +161,17 @@ namespace DamageAssesment.Api.Questions.Providers
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.Question Question, string ErrorMessage)> GetQuestionAsync(int Id)
public async Task<(bool IsSuccess, Models.MultiLanguage Question, string ErrorMessage)> GetQuestionAsync(int id, string language)
{
try
{
logger?.LogInformation("Query Question");
var question = await questionDbContext.Questions.Include("QuestionType").AsNoTracking().FirstOrDefaultAsync(q => q.Id == Id);
var question = await questionDbContext.Questions.Include("QuestionType").AsNoTracking().FirstOrDefaultAsync(q => q.Id == id);
if (question != null)
{
logger?.LogInformation($"{question} customer(s) found");
var result = mapper.Map<Db.Question, Models.Question>(question);
result.Questions = mapper.Map<List<Db.QuestionsTranslation>, List<Models.QuestionsTranslation>>(
questionDbContext.QuestionsTranslations.Where(a => a.QuestionId == result.Id).ToList());
var result = mapper.Map<Db.Question, Models.MultiLanguage>(question);
result.Text = CreateMultiLanguageObject(GetQuestionsTranslations(id, language));
return (true, result, null);
}
return (false, null, "Not found");
@ -116,35 +182,34 @@ namespace DamageAssesment.Api.Questions.Providers
return (false, null, ex.Message);
}
}
public List<Models.Question> GetSurveyQuestion(List<Models.Question> questions,string Language)
public List<Models.MultiLanguage> GetSurveyQuestion(List<Models.MultiLanguage> questions, string language)
{
foreach (var item in questions)
{
item.Questions= mapper.Map<List<Db.QuestionsTranslation>, List<Models.QuestionsTranslation>>(
questionDbContext.QuestionsTranslations.Where(a => a.QuestionId == item.Id && a.Language== Language).ToList());
item.Text = CreateMultiLanguageObject(GetQuestionsTranslations(item.Id, language));
}
return questions;
}
public async Task<(bool IsSuccess, List<SurveyQuestions> SurveyQuestions, string ErrorMessage)> GetSurveyQuestionAsync(int SurveyId, string Language)
public async Task<(bool IsSuccess, List<SurveyQuestions> SurveyQuestions, string ErrorMessage)> GetSurveyQuestionAsync(int SurveyId, string language)
{
try
{
logger?.LogInformation("Query Question");
var questions = await questionDbContext.Questions.Include("QuestionType").Where(a=>a.SurveyId==SurveyId).AsNoTracking().ToListAsync();
var questions = await questionDbContext.Questions.Include("QuestionType").Where(a => a.SurveyId == SurveyId).AsNoTracking().ToListAsync();
if (questions != null)
{
List<SurveyQuestions> surveyQuestionsList = new List<SurveyQuestions>();
List<int> CategoryIds=questions.Select(a=>a.CategoryId).Distinct().ToList();
var questioncategories = await questionDbContext.QuestionCategories.Where(a =>CategoryIds.Contains(a.Id)).ToListAsync();
List<int> CategoryIds = questions.Select(a => a.CategoryId).Distinct().ToList();
var questioncategories = await questionDbContext.QuestionCategories.Where(a => CategoryIds.Contains(a.Id)).ToListAsync();
//logger?.LogInformation($"{question} customer(s) found");
foreach (var item in questioncategories)
{
surveyQuestionsList.Add(new SurveyQuestions()
{
CategoryId = item.Id,
CategoryImage = item.CategoryImage,
CategoryName = item.CategoryName,
Questions = GetSurveyQuestion(mapper.Map<List<Db.Question>, List<Models.Question>>(questions.Where(a => a.CategoryId == item.Id).ToList()), Language)
IconLibrary = item.IconLibrary,
IconName = item.IconName,
QuestionsText = GetSurveyQuestion(mapper.Map<List<Db.Question>, List<Models.MultiLanguage>>(questions.Where(a => a.CategoryId == item.Id).ToList()), language)
});
}
@ -159,20 +224,22 @@ namespace DamageAssesment.Api.Questions.Providers
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.Question Question, string ErrorMessage)> PostQuestionAsync(Models.Question Question)
public async Task<(bool IsSuccess, Models.MultiLanguage Question, string ErrorMessage)> PostQuestionAsync(Models.Question Question)
{
try
{
logger?.LogInformation("Query Question");
var dbquestion = mapper.Map<Models.Question, Db.Question>(Question);
var dbquestiontranslation = mapper.Map<List<Models.QuestionsTranslation>, List<Db.QuestionsTranslation>>(Question.Questions);
dbquestion.QuestionTypeId=questionDbContext.QuestionTypes.Where(a=>a.TypeText==Question.TypeText).Select(a=>a.Id).FirstOrDefault();
dbquestion.QuestionTypeId = questionDbContext.QuestionTypes.Where(a => a.TypeText == Question.TypeText).Select(a => a.Id).FirstOrDefault();
questionDbContext.Questions.Add(dbquestion);
dbquestiontranslation.ForEach(i => i.QuestionId = dbquestion.Id);
questionDbContext.QuestionsTranslations.AddRange(dbquestiontranslation);
questionDbContext.SaveChanges();
questionDbContext.SaveChanges();
Question.Id = dbquestion.Id;
return (true, Question, null);
var result = mapper.Map<Db.Question, Models.MultiLanguage>(dbquestion);
result.Text = CreateMultiLanguageObject(GetQuestionsTranslations(result.Id,""));
return (true, result, null);
}
catch (Exception ex)
{
@ -180,7 +247,7 @@ namespace DamageAssesment.Api.Questions.Providers
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.Question Question, string ErrorMessage)> UpdateQuestionAsync(Models.Question Question)
public async Task<(bool IsSuccess, Models.MultiLanguage Question, string ErrorMessage)> UpdateQuestionAsync(Models.Question Question)
{
try
{
@ -189,12 +256,14 @@ namespace DamageAssesment.Api.Questions.Providers
dbquestion.QuestionTypeId = questionDbContext.QuestionTypes.Where(a => a.TypeText == Question.TypeText).Select(a => a.Id).FirstOrDefault();
questionDbContext.Entry(dbquestion).State = EntityState.Modified;
var oldquestions = questionDbContext.QuestionsTranslations.Where(a => a.QuestionId == dbquestion.Id).ToList();
if(oldquestions!=null)
if (oldquestions != null)
questionDbContext.QuestionsTranslations.RemoveRange(oldquestions);
dbquestiontranslation.ForEach(i => i.QuestionId = dbquestion.Id);
questionDbContext.QuestionsTranslations.AddRange(dbquestiontranslation);
questionDbContext.SaveChanges();
return (true, Question, null);
var result = mapper.Map<Db.Question, Models.MultiLanguage>(dbquestion);
result.Text = CreateMultiLanguageObject(GetQuestionsTranslations(result.Id, ""));
return (true, result, null);
}
catch (Exception ex)
{
@ -203,21 +272,23 @@ namespace DamageAssesment.Api.Questions.Providers
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.Question Question, string ErrorMessage)> DeleteQuestionAsync(int Id)
public async Task<(bool IsSuccess, Models.MultiLanguage Question, string ErrorMessage)> DeleteQuestionAsync(int id)
{
try
{
var question = await questionDbContext.Questions.Where(x => x.Id == Id).FirstOrDefaultAsync();
var question = await questionDbContext.Questions.Where(x => x.Id == id).FirstOrDefaultAsync();
if (question != null)
{
var result = mapper.Map<Db.Question, Models.MultiLanguage>(question);
result.Text = CreateMultiLanguageObject(GetQuestionsTranslations(result.Id, ""));
questionDbContext.Questions.Remove(question);
questionDbContext.SaveChanges();
return (true, mapper.Map<Db.Question, Models.Question>(question), $"QuestionID {Id} deleted Successfuly");
return (true, result, $"QuestionID {id} deleted Successfuly");
}
else
{
logger?.LogInformation($"QuestionID: {Id} Not found");
logger?.LogInformation($"QuestionID: {id} Not found");
return (false, null, "Not Found");
}
}
@ -228,11 +299,9 @@ namespace DamageAssesment.Api.Questions.Providers
}
}
//Question Category Logic
public async Task<(bool IsSuccess, IEnumerable<Models.QuestionCategory> QuestionCategories, string ErrorMessage)> GetQuestionCategoriesAsync()
public async Task<(bool IsSuccess, IEnumerable<Models.MultiLanQuestionCategory> QuestionCategories, string ErrorMessage)> GetQuestionCategoriesAsync(string? language)
{
try
{
@ -241,7 +310,11 @@ namespace DamageAssesment.Api.Questions.Providers
if (questionCategories != null)
{
//logger?.LogInformation($"{question} customer(s) found");
var result = mapper.Map<IEnumerable<Db.QuestionCategory>, IEnumerable<Models.QuestionCategory>>(questionCategories);
var result = mapper.Map<IEnumerable<Db.QuestionCategory>, IEnumerable<Models.MultiLanQuestionCategory>>(questionCategories);
foreach (var category in result)
{
category.Titles = CreateCategoryMultiLanguageObject(GetCategoryTranslations(category.Id, language));
}
return (true, result, null);
}
return (false, null, "Not found");
@ -252,16 +325,17 @@ namespace DamageAssesment.Api.Questions.Providers
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.QuestionCategory QuestionCategory, string ErrorMessage)> GetQuestionCategoryAsync(int Id)
public async Task<(bool IsSuccess, Models.MultiLanQuestionCategory QuestionCategory, string ErrorMessage)> GetQuestionCategoryAsync(int id, string? language)
{
try
{
logger?.LogInformation("Query Question");
var questioncategory = await questionDbContext.QuestionCategories.AsNoTracking().FirstOrDefaultAsync(q => q.Id == Id);
var questioncategory = await questionDbContext.QuestionCategories.AsNoTracking().FirstOrDefaultAsync(q => q.Id == id);
if (questioncategory != null)
{
logger?.LogInformation($"{questioncategory} customer(s) found");
var result = mapper.Map<Db.QuestionCategory, Models.QuestionCategory>(questioncategory);
var result = mapper.Map<Db.QuestionCategory, Models.MultiLanQuestionCategory>(questioncategory);
result.Titles = CreateCategoryMultiLanguageObject(GetCategoryTranslations(result.Id, language));
return (true, result, null);
}
return (false, null, "Not found");
@ -272,17 +346,23 @@ namespace DamageAssesment.Api.Questions.Providers
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.QuestionCategory QuestionCategory, string ErrorMessage)> PostQuestionCategoryAsync(Models.QuestionCategory QuestionCategory)
public async Task<(bool IsSuccess, Models.MultiLanQuestionCategory QuestionCategory, string ErrorMessage)> PostQuestionCategoryAsync(Models.QuestionCategory QuestionCategory)
{
try
{
logger?.LogInformation("Query Question");
var dbQuestionCategory = mapper.Map<Models.QuestionCategory, Db.QuestionCategory>(QuestionCategory);
var dbCategorytranslations = mapper.Map<List<Models.CategoryTranslation>, List<Db.CategoryTranslation>>(QuestionCategory.Categories);
// Question.QuestionType = GetQuestionType(Question.QuestionTypeId);
questionDbContext.QuestionCategories.Add(dbQuestionCategory);
questionDbContext.SaveChanges();
QuestionCategory.Id=dbQuestionCategory.Id;
return (true, QuestionCategory, null);
QuestionCategory.Id = dbQuestionCategory.Id;
dbCategorytranslations.ForEach(i => i.CategoryId = QuestionCategory.Id);
questionDbContext.CategoryTranslations.AddRange(dbCategorytranslations);
questionDbContext.SaveChanges();
var result = mapper.Map<Db.QuestionCategory, Models.MultiLanQuestionCategory>(dbQuestionCategory);
result.Titles = CreateCategoryMultiLanguageObject(GetCategoryTranslations(result.Id, ""));
return (true, result, null);
}
catch (Exception ex)
{
@ -290,15 +370,23 @@ namespace DamageAssesment.Api.Questions.Providers
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.QuestionCategory QuestionCategory, string ErrorMessage)> UpdateQuestionCategoryAsync(Models.QuestionCategory QuestionCategory)
public async Task<(bool IsSuccess, Models.MultiLanQuestionCategory QuestionCategory, string ErrorMessage)> UpdateQuestionCategoryAsync(Models.QuestionCategory QuestionCategory)
{
try
{
var dbQuestionCategory = mapper.Map<Models.QuestionCategory, Db.QuestionCategory>(QuestionCategory);
var dbCategorytranslations = mapper.Map<List<Models.CategoryTranslation>, List<Db.CategoryTranslation>>(QuestionCategory.Categories);
questionDbContext.Entry(dbQuestionCategory).State = EntityState.Modified;
QuestionCategory.Id = dbQuestionCategory.Id;
var oldcategories = questionDbContext.CategoryTranslations.Where(a => a.CategoryId == dbQuestionCategory.Id).ToList();
if (oldcategories != null)
questionDbContext.CategoryTranslations.RemoveRange(oldcategories);
dbCategorytranslations.ForEach(i => i.CategoryId = QuestionCategory.Id);
questionDbContext.CategoryTranslations.AddRange(dbCategorytranslations);
questionDbContext.SaveChanges();
return (true, QuestionCategory, null);
var result = mapper.Map<Db.QuestionCategory, Models.MultiLanQuestionCategory>(dbQuestionCategory);
result.Titles = CreateCategoryMultiLanguageObject(GetCategoryTranslations(result.Id, ""));
return (true, result, null);
}
catch (Exception ex)
{
@ -307,18 +395,20 @@ namespace DamageAssesment.Api.Questions.Providers
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.QuestionCategory QuestionCategory, string ErrorMessage)> DeleteQuestionCategoryAsync(int Id)
public async Task<(bool IsSuccess, Models.MultiLanQuestionCategory QuestionCategory, string ErrorMessage)> DeleteQuestionCategoryAsync(int Id)
{
try
{
var questioncategory = await questionDbContext.QuestionCategories.Where(x => x.Id == Id).FirstOrDefaultAsync();
if (questioncategory != null)
{
var result = mapper.Map<Db.QuestionCategory, Models.MultiLanQuestionCategory>(questioncategory);
result.Titles = CreateCategoryMultiLanguageObject(GetCategoryTranslations(result.Id, ""));
var question = await questionDbContext.Questions.Where(x => x.Id == Id).ToListAsync();
questionDbContext.Questions.RemoveRange(question);
questionDbContext.QuestionCategories.Remove(questioncategory);
questionDbContext.SaveChanges();
return (true, mapper.Map<Db.QuestionCategory, Models.QuestionCategory>(questioncategory), $"QuestionID {Id} deleted Successfuly");
return (true, result, $"QuestionID {Id} deleted Successfuly");
}
else
{

3
DamageAssesmentApi/DamageAssesment.Api.Questions/appsettings.json
View File

@ -1,4 +1,7 @@
{
"JwtSettings": {
"securitykey": "bWlhbWkgZGFkZSBzY2hvb2xzIHNlY3JldCBrZXk="
},
"Logging": {
"LogLevel": {
"Default": "Information",

18
DamageAssesmentApi/DamageAssesment.Api.QuestionsTest/CategoryMockData.cs
View File

@ -8,42 +8,42 @@ namespace DamageAssesment.Api.Questions.Test
{
public class CategoryMockData
{
public static async Task<(bool, IEnumerable<Questions.Models.QuestionCategory>, string)> getOkResponse()
public static async Task<(bool, IEnumerable<Questions.Models.MultiLanQuestionCategory>, string)> getOkResponse()
{
IEnumerable<Questions.Models.QuestionCategory> list = new List<Questions.Models.QuestionCategory>();
IEnumerable<Questions.Models.MultiLanQuestionCategory> list = new List<Questions.Models.MultiLanQuestionCategory>();
for (int i = 0; i < 10; i++)
{
list.Append(new Questions.Models.QuestionCategory { Id = i, CategoryImage = "img"+i,CategoryName="Category "+i });
list.Append(new Questions.Models.MultiLanQuestionCategory { Id = i, IconLibrary = "img"+i,IconName="Category "+i });
}
return (true, list, null);
}
public static async Task<(bool, Questions.Models.QuestionCategory, string)> getOkResponse(int Id)
public static async Task<(bool, Questions.Models.MultiLanQuestionCategory, string)> getOkResponse(int Id)
{
var Questions = await getOkResponse();
var Question = Questions.Item2.FirstOrDefault(s => s.Id == Id);
return (true, Question, null);
}
public static async Task<(bool, Questions.Models.QuestionCategory, string)> getBadRequestResponse()
public static async Task<(bool, Questions.Models.MultiLanQuestionCategory, string)> getBadRequestResponse()
{
return (false, null, "Bad Request");
}
public static async Task<(bool, Questions.Models.QuestionCategory, string)> getNotFoundResponse()
public static async Task<(bool, Questions.Models.MultiLanQuestionCategory, string)> getNotFoundResponse()
{
return (false, null, "Not Found");
}
public static async Task<(bool, IEnumerable<Questions.Models.QuestionCategory>, string)> getNoContentResponse()
public static async Task<(bool, IEnumerable<Questions.Models.MultiLanQuestionCategory>, string)> getNoContentResponse()
{
IEnumerable<Questions.Models.QuestionCategory> list = new List<Questions.Models.QuestionCategory>();
IEnumerable<Questions.Models.MultiLanQuestionCategory> list = new List<Questions.Models.MultiLanQuestionCategory>();
return (false, list, null);
}
public static async Task<Questions.Models.QuestionCategory> getInputQuestionCategoryData()
{
return new Questions.Models.QuestionCategory { Id = 1, CategoryName = "Category 1",CategoryImage="img 1" };
return new Questions.Models.QuestionCategory { Id = 1, IconName = "Category 1",IconLibrary="img 1" };
}
}

37
DamageAssesmentApi/DamageAssesment.Api.QuestionsTest/MockData.cs
View File

@ -1,24 +1,17 @@
using DamageAssesment.Api.Questions.Db;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text;
namespace DamageAssesment.Api.Questions.Test
{
public class MockData
{
public static async Task<(bool, IEnumerable<Questions.Models.Question>, string)> getOkResponse()
public static async Task<(bool, IEnumerable<Questions.Models.MultiLanguage>, string)> getOkResponse()
{
IEnumerable<Questions.Models.Question> list = new List<Questions.Models.Question>();
IEnumerable<Questions.Models.MultiLanguage> list = new List<Questions.Models.MultiLanguage>();
for (int i = 0; i < 10; i++)
{
list.Append(new Questions.Models.Question { Id = i, TypeText = "Text" + i, SurveyId = 1, QuestionNumber = 1, IsRequired = true, Comment = false, Key = true, QuestionGroup = "group1",CategoryId=i });
list.Append(new Questions.Models.MultiLanguage { Id = i, TypeText = "Text" + i, SurveyId = 1, QuestionNumber = 1, IsRequired = true, Comment = false, Key = true, CategoryId=i });
}
return (true, list, null);
}
@ -30,38 +23,38 @@ namespace DamageAssesment.Api.Questions.Test
for (int i = 0; i < 10; i++)
{
List<Models.Question> question = new List<Models.Question>();
question.Add(new Models.Question { Id = i, TypeText = "Text" + i, SurveyId = 1, QuestionNumber = 1, IsRequired = true, Comment = false, Key = true, QuestionGroup = "group1", CategoryId = i });
List<Models.MultiLanguage> question = new List<Models.MultiLanguage>();
question.Add(new Models.MultiLanguage { Id = i, TypeText = "Text" + i, SurveyId = 1, QuestionNumber = 1, IsRequired = true, Comment = false, Key = true, CategoryId = i });
list.Append(new Questions.Models.SurveyQuestions
{
CategoryId = i,
CategoryImage = "img" + i,
CategoryName = "Category " + i,
Questions = question
IconLibrary = "img" + i,
IconName = "Category " + i,
QuestionsText = question
});
}
return (true, list, null);
}
public static async Task<(bool, Questions.Models.Question, string)> getOkResponse(int Id)
public static async Task<(bool, Questions.Models.MultiLanguage, string)> getOkResponse(int Id)
{
var Questions = await getOkResponse();
var Question = Questions.Item2.FirstOrDefault(s => s.Id == Id);
return (true, Question, null);
}
public static async Task<(bool, Questions.Models.Question, string)> getBadRequestResponse()
public static async Task<(bool, Questions.Models.MultiLanguage, string)> getBadRequestResponse()
{
return (false, null, "Bad Request");
}
public static async Task<(bool, Questions.Models.Question, string)> getNotFoundResponse()
public static async Task<(bool, Questions.Models.MultiLanguage, string)> getNotFoundResponse()
{
return (false, null, "Not Found");
}
public static async Task<(bool, IEnumerable<Questions.Models.Question>, string)> getNoContentResponse()
public static async Task<(bool, IEnumerable<Questions.Models.MultiLanguage>, string)> getNoContentResponse()
{
IEnumerable<Questions.Models.Question> list = new List<Questions.Models.Question>();
IEnumerable<Questions.Models.MultiLanguage> list = new List<Questions.Models.MultiLanguage>();
return (false, list, null);
}
public static async Task<(bool, List<Questions.Models.SurveyQuestions>, string)> getNoSurveyContentResponse()
@ -79,7 +72,7 @@ namespace DamageAssesment.Api.Questions.Test
};
List<Models.QuestionsTranslation> QuestionsTranslations = new List<Models.QuestionsTranslation>();
QuestionsTranslations.Add(QuestionsTranslation);
return new Questions.Models.Question { Id = 1, Questions=QuestionsTranslations, TypeText = "Text 1", SurveyId = 1, QuestionNumber = 1, IsRequired = true, Comment = false, Key = true, QuestionGroup = "group1" ,CategoryId=1};
return new Questions.Models.Question { Id = 1, Questions=QuestionsTranslations, TypeText = "Text 1", SurveyId = 1, QuestionNumber = 1, IsRequired = true, Comment = false, Key = true, CategoryId=1};
}

41
DamageAssesmentApi/DamageAssesment.Api.QuestionsTest/QuestionsServiceTest.cs
View File

@ -1,16 +1,7 @@
using AutoMapper;
using DamageAssesment.Api.Questions.Controllers;
using DamageAssesment.Api.Questions.Db;
using DamageAssesment.Api.Questions.Interfaces;
using DamageAssesment.Api.Questions.Models;
using DamageAssesment.Api.Questions.Profiles;
using DamageAssesment.Api.Questions.Providers;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using Moq;
using Newtonsoft.Json;
using Xunit;
namespace DamageAssesment.Api.Questions.Test
@ -22,10 +13,10 @@ namespace DamageAssesment.Api.Questions.Test
{
var mockQuestionService = new Mock<IQuestionsProvider>();
var mockResponse = await MockData.getOkResponse();
mockQuestionService.Setup(service => service.GetQuestionsAsync()).ReturnsAsync(mockResponse);
mockQuestionService.Setup(service => service.GetQuestionsAsync(null)).ReturnsAsync(mockResponse);
var QuestionProvider = new QuestionsController(mockQuestionService.Object);
var result = (OkObjectResult)await QuestionProvider.GetQuestionsAsync();
var result = (OkObjectResult)await QuestionProvider.GetQuestionsAsync(null);
Assert.Equal(200, result.StatusCode);
}
@ -35,10 +26,10 @@ namespace DamageAssesment.Api.Questions.Test
{
var mockQuestionService = new Mock<IQuestionsProvider>();
var mockResponse = await MockData.getNoContentResponse();
mockQuestionService.Setup(service => service.GetQuestionsAsync()).ReturnsAsync(mockResponse);
mockQuestionService.Setup(service => service.GetQuestionsAsync(null)).ReturnsAsync(mockResponse);
var QuestionProvider = new QuestionsController(mockQuestionService.Object);
var result = (NoContentResult)await QuestionProvider.GetQuestionsAsync();
var result = (NoContentResult)await QuestionProvider.GetQuestionsAsync(null);
Assert.Equal(204, result.StatusCode);
}
@ -48,10 +39,10 @@ namespace DamageAssesment.Api.Questions.Test
{
var mockQuestionService = new Mock<IQuestionsProvider>();
var mockResponse = await MockData.getOkResponse(1);
mockQuestionService.Setup(service => service.GetQuestionAsync(1)).ReturnsAsync(mockResponse);
mockQuestionService.Setup(service => service.GetQuestionAsync(1,null)).ReturnsAsync(mockResponse);
var QuestionProvider = new QuestionsController(mockQuestionService.Object);
var result = (OkObjectResult)await QuestionProvider.GetQuestionAsync(1);
var result = (OkObjectResult)await QuestionProvider.GetQuestionByIdAsync(1,null);
Assert.Equal(200, result.StatusCode);
}
@ -61,10 +52,10 @@ namespace DamageAssesment.Api.Questions.Test
{
var mockQuestionService = new Mock<IQuestionsProvider>();
var mockResponse = await MockData.getNotFoundResponse();
mockQuestionService.Setup(service => service.GetQuestionAsync(99)).ReturnsAsync(mockResponse);
mockQuestionService.Setup(service => service.GetQuestionAsync(99,null)).ReturnsAsync(mockResponse);
var QuestionProvider = new QuestionsController(mockQuestionService.Object);
var result = (NotFoundResult)await QuestionProvider.GetQuestionAsync(99);
var result = (NotFoundResult)await QuestionProvider.GetQuestionByIdAsync(99,null);
Assert.Equal(404, result.StatusCode);
}
@ -197,10 +188,10 @@ namespace DamageAssesment.Api.Questions.Test
{
var mockQuestionService = new Mock<IQuestionsProvider>();
var mockResponse = await CategoryMockData.getOkResponse();
mockQuestionService.Setup(service => service.GetQuestionCategoriesAsync()).ReturnsAsync(mockResponse);
mockQuestionService.Setup(service => service.GetQuestionCategoriesAsync("en")).ReturnsAsync(mockResponse);
var QuestionProvider = new QuestionsController(mockQuestionService.Object);
var result = (OkObjectResult)await QuestionProvider.GetQuestionCategoriesAsync();
var result = (OkObjectResult)await QuestionProvider.GetQuestionCategoriesAsync("en");
Assert.Equal(200, result.StatusCode);
}
@ -210,10 +201,10 @@ namespace DamageAssesment.Api.Questions.Test
{
var mockQuestionService = new Mock<IQuestionsProvider>();
var mockResponse = await CategoryMockData.getNoContentResponse();
mockQuestionService.Setup(service => service.GetQuestionCategoriesAsync()).ReturnsAsync(mockResponse);
mockQuestionService.Setup(service => service.GetQuestionCategoriesAsync("en")).ReturnsAsync(mockResponse);
var QuestionProvider = new QuestionsController(mockQuestionService.Object);
var result = (NoContentResult)await QuestionProvider.GetQuestionCategoriesAsync();
var result = (NoContentResult)await QuestionProvider.GetQuestionCategoriesAsync("en");
Assert.Equal(204, result.StatusCode);
}
@ -223,10 +214,10 @@ namespace DamageAssesment.Api.Questions.Test
{
var mockQuestionService = new Mock<IQuestionsProvider>();
var mockResponse = await CategoryMockData.getOkResponse(1);
mockQuestionService.Setup(service => service.GetQuestionCategoryAsync(1)).ReturnsAsync(mockResponse);
mockQuestionService.Setup(service => service.GetQuestionCategoryAsync(1, "en")).ReturnsAsync(mockResponse);
var QuestionProvider = new QuestionsController(mockQuestionService.Object);
var result = (OkObjectResult)await QuestionProvider.GetQuestionCategoryAsync(1);
var result = (OkObjectResult)await QuestionProvider.GetQuestionCategoryAsync(1, "en");
Assert.Equal(200, result.StatusCode);
}
@ -236,10 +227,10 @@ namespace DamageAssesment.Api.Questions.Test
{
var mockQuestionService = new Mock<IQuestionsProvider>();
var mockResponse = await CategoryMockData.getNotFoundResponse();
mockQuestionService.Setup(service => service.GetQuestionCategoryAsync(99)).ReturnsAsync(mockResponse);
mockQuestionService.Setup(service => service.GetQuestionCategoryAsync(99, "en")).ReturnsAsync(mockResponse);
var QuestionProvider = new QuestionsController(mockQuestionService.Object);
var result = (NotFoundResult)await QuestionProvider.GetQuestionCategoryAsync(99);
var result = (NotFoundResult)await QuestionProvider.GetQuestionCategoryAsync(99, "en");
Assert.Equal(404, result.StatusCode);
}

114
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Controllers/SurveyResponsesController.cs
View File

@ -6,7 +6,6 @@ using Microsoft.Extensions.Configuration;
namespace DamageAssesment.Api.SurveyResponses.Controllers
{
[Route("api")]
[ApiController]
public class SurveyResponsesController : ControllerBase
{
@ -16,8 +15,11 @@ namespace DamageAssesment.Api.SurveyResponses.Controllers
{
this.surveyResponseProvider = surveyResponseProvider;
}
/// <summary>
/// GET request for retrieving survey responses.
/// </summary>
[HttpGet("SurveyResponses")]
[HttpGet("Responses")]
public async Task<ActionResult> GetSurveyResponsesAsync()
{
var result = await this.surveyResponseProvider.GetSurveyResponsesAsync();
@ -31,22 +33,30 @@ namespace DamageAssesment.Api.SurveyResponses.Controllers
return BadRequest(result.ErrorMessage);
}
[HttpGet("SurveyResponses/{surveyId}")]
public async Task<ActionResult> GetSurveyResponsesAsync(int surveyId)
/// <summary>
/// GET request for retrieving survey responses by survey ID.
/// </summary>
[HttpGet("Responses/BySurvey/{surveyid}")]
public async Task<ActionResult> GetSurveyResponsesAsync(int surveyid)
{
var result = await this.surveyResponseProvider.GetSurveyResponsesBySurveyAsync(surveyId);
var result = await this.surveyResponseProvider.GetSurveyResponsesBySurveyAsync(surveyid);
if (result.IsSuccess)
{
return Ok(result.SurveyResponses);
}
return NoContent();
}
/// <summary>
/// GET request for retrieving survey responses by survey and location IDs.
/// </summary>
/// <param name="surveyid">The ID of the survey for which responses are to be retrieved.</param>
/// <param name="locationid">The ID of the location for which responses are to be retrieved.</param>
[HttpGet("Responses/{surveyId}/{locationId}")]
public async Task<ActionResult> GetSurveyResponsesBySurveyAndLocationAsync(int surveyId, string locationId)
[HttpGet("Responses/{surveyid}/{locationid}")]
public async Task<ActionResult> GetSurveyResponsesBySurveyAndLocationAsync(int surveyid, int locationid)
{
var result = await this.surveyResponseProvider.GetSurveyResponsesBySurveyAndLocationAsync(surveyId, locationId);
var result = await this.surveyResponseProvider.GetSurveyResponsesBySurveyAndLocationAsync(surveyid, locationid);
if (result.IsSuccess)
{
return Ok(result.SurveyResponses);
@ -54,11 +64,17 @@ namespace DamageAssesment.Api.SurveyResponses.Controllers
return NoContent();
}
/// <summary>
/// GET request for retrieving survey responses by survey, question, and answer.
/// </summary>
/// <param name="surveyId">The ID of the survey for which responses are to be retrieved.</param>
/// <param name="questionId">The ID of the question for which responses are to be retrieved.</param>
/// <param name="answer">The answer for which responses are to be retrieved.</param>
[HttpGet("ResponsesByAnswer/{surveyId}/{questionId}/{answer}")]
public async Task<ActionResult> GetSurveyResponsesByAnswerAsyncAsync(int surveyId, int questionId, string answer)
[HttpGet("Responses/ByAnswer/{surveyid}/{questionid}/{answer}")]
public async Task<ActionResult> GetSurveyResponsesByAnswerAsyncAsync(int surveyid, int questionid, string answer)
{
var result = await surveyResponseProvider.GetResponsesByAnswerAsync(surveyId, questionId, answer);
var result = await surveyResponseProvider.GetResponsesByAnswerAsync(surveyid, questionid, answer);
if (result.IsSuccess)
{
return Ok(result.SurveyResponses);
@ -66,33 +82,45 @@ namespace DamageAssesment.Api.SurveyResponses.Controllers
return NoContent();
}
/// <summary>
/// GET request for retrieving answers from survey responses by survey ID and region.
/// </summary>
/// <param name="surveyId">The ID of the survey for which answers are to be retrieved.</param>
[HttpGet("AnswersByRegion/{surveyId}")]
public async Task<ActionResult> GetAnswersByRegionAsync(int surveyId)
[HttpGet("Responses/ByRegion/{surveyid}")]
public async Task<ActionResult> GetAnswersByRegionAsync(int surveyid)
{
var result = await this.surveyResponseProvider.GetAnswersByRegionAsync(surveyId);
var result = await this.surveyResponseProvider.GetAnswersByRegionAsync(surveyid);
if (result.IsSuccess)
{
return Ok(result.Answers);
}
return NoContent();
}
/// <summary>
/// GET request for retrieving survey responses by survey ID and maintenance center.
/// </summary>
/// <param name="surveyId">The ID of the survey for which responses are to be retrieved.</param>
[HttpGet("AnswersByMaintenanceCenter/{surveyId}")]
public async Task<ActionResult> GetAnswersByMaintenaceCentersync(int surveyId)
[HttpGet("Responses/ByMaintenanceCenter/{surveyid}")]
public async Task<ActionResult> GetAnswersByMaintenaceCentersync(int surveyid)
{
var result = await this.surveyResponseProvider.GetSurveyResponsesByMaintenanceCenterAsync(surveyId);
var result = await this.surveyResponseProvider.GetSurveyResponsesByMaintenanceCenterAsync(surveyid);
if (result.IsSuccess)
{
return Ok(result.SurveyResponses);
}
return NoContent();
}
/// <summary>
/// GET request for retrieving a survey response by response ID.
/// </summary>
/// <param name="responseId">The ID of the survey response to be retrieved.</param>
[HttpGet("SurveyResponse/{responseId}")]
public async Task<ActionResult> GetSurveyResponseByIdAsync(int responseId)
[HttpGet("Responses/{id}")]
public async Task<ActionResult> GetSurveyResponseByIdAsync(int id)
{
var result = await this.surveyResponseProvider.GetSurveyResponseByIdAsync(responseId);
var result = await this.surveyResponseProvider.GetSurveyResponseByIdAsync(id);
if (result.IsSuccess)
{
return Ok(result.SurveyResponse);
@ -100,8 +128,12 @@ namespace DamageAssesment.Api.SurveyResponses.Controllers
return NoContent();
}
/// <summary>
/// POST request for creating a new survey response.
/// </summary>
/// <param name="surveyResponse">The survey response object to be created.</param>
[HttpPost("SurveyResponses")]
[HttpPost("Responses")]
public async Task<ActionResult> PostSurveysAsync(Models.SurveyResponse surveyResponse)
{
var result = await this.surveyResponseProvider.PostSurveyResponseAsync(surveyResponse);
@ -111,11 +143,16 @@ namespace DamageAssesment.Api.SurveyResponses.Controllers
}
return BadRequest(result.ErrorMessage);
}
/// <summary>
/// PUT request for updating an existing survey response.
/// </summary>
/// <param name="Id">The ID of the survey response to be updated.</param>
/// <param name="surveyResponse">The updated survey response object.</param>
[HttpPut("SurveyResponses/{Id}")]
public async Task<ActionResult> PutSurveyResponseAsync(int Id, Models.SurveyResponse surveyResponse)
[HttpPut("Responses/{id}")]
public async Task<ActionResult> PutSurveyResponseAsync(int id, Models.SurveyResponse surveyResponse)
{
var result = await this.surveyResponseProvider.PutSurveyResponseAsync(Id, surveyResponse);
var result = await this.surveyResponseProvider.PutSurveyResponseAsync(id, surveyResponse);
if (result.IsSuccess)
{
return Ok(result.SurveyResponse);
@ -125,28 +162,29 @@ namespace DamageAssesment.Api.SurveyResponses.Controllers
return BadRequest(result.ErrorMessage);
}
[HttpDelete("SurveyResponses/{Id}")]
public async Task<ActionResult> DeleteSurveyResponseAsync(int Id)
/// <summary>
/// DELETE request for deleting an existing survey response.
/// </summary>
[HttpDelete("Responses/{id}")]
public async Task<ActionResult> DeleteSurveyResponseAsync(int id)
{
var result = await this.surveyResponseProvider.DeleteSurveyResponseAsync(Id);
var result = await this.surveyResponseProvider.DeleteSurveyResponseAsync(id);
if (result.IsSuccess)
{
return Ok(result.SurveyResponse);
}
return NotFound();
}
/// <summary>
/// POST request for submitting survey with multiple answers.
/// </summary>
/// <param name="request">The answers to be submitted for the survey.</param>
[HttpPost("SurveyResponses/Answers")]
public async Task<ActionResult> PostSurveyAnswersAsync(AnswerRequest answers)
[HttpPost("Responses/Answers")]
public async Task<ActionResult> PostSurveyAnswersAsync(Request request)
{
/* var result = await this.surveyResponseProvider.PostSurveyAnswersAsync(surveyAnswers);
if (result.IsSuccess)
{
return Ok(result.SurveyResponse);
}
return BadRequest(result.ErrorMessage);*/
var result = await this.surveyResponseProvider.PostSurveyAnswersAsync(answers);
var result = await this.surveyResponseProvider.PostSurveyAnswersAsync(request);
if (result.IsSuccess)
return Ok(result.SurveyResponse);

5
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/DamageAssesment.Api.SurveyResponses.csproj
View File

@ -4,6 +4,7 @@
<TargetFramework>net6.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
<GenerateDocumentationFile>True</GenerateDocumentationFile>
</PropertyGroup>
<ItemGroup>
@ -21,6 +22,10 @@
</PackageReference>
<PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="7.0.0" />
<PackageReference Include="Microsoft.Extensions.Http.Polly" Version="7.0.9" />
<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="6.0.21" />
<PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.5" />
<PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="7.0.5" />
<PackageReference Include="Microsoft.Extensions.Http.Polly" Version="7.0.5" />
<PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
<PackageReference Include="Swashbuckle.AspNetCore" Version="6.2.3" />
</ItemGroup>

19
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Db/SurveyResponse.cs
View File

@ -10,21 +10,22 @@ namespace DamageAssesment.Api.SurveyResponses.Db
[ForeignKey("Survey")]
public int SurveyId { get; set; }
[StringLength(4)]
[ForeignKey("Location")]
public string LocationId { get; set; }
public int LocationId { get; set; }
[StringLength(6)]
[ForeignKey("Employee")]
public string EmployeeId { get; set; }
public int EmployeeId { get; set; }
//public DateTime? CreatedDate { get; set; }
public DateTime? CreatedDate { get; set; } = DateTime.Now;
//[StringLength(50)]
// public string ClientDevice { get; set; }
[StringLength(50)]
public string? ClientDevice { get; set; }
[StringLength(250)]
public string? KeyAnswerResult { get; set; }
public double? Longitute { get; set; }
public double? Latitude { get; set; }
// [StringLength(250)]
//public string KeyAnswerResult { get; set; }
}
}

8
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Db/SurveyResponseDbContext.cs
View File

@ -15,5 +15,13 @@ namespace DamageAssesment.Api.SurveyResponses.Db
options.UseSqlServer(_Configuration.GetConnectionString("SurveyResponseConnection"));
}
public DbSet<Db.SurveyResponse> SurveyResponses { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity<SurveyResponse>()
.Property(item => item.Id)
.ValueGeneratedOnAdd();
}
}
}

2
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Interfaces/IEmployeeServiceProvider.cs
View File

@ -5,6 +5,6 @@ namespace DamageAssesment.Api.SurveyResponses.Interfaces
public interface IEmployeeServiceProvider
{
Task<List<Employee>> getEmployeesAsync();
Task<Employee> getEmployeeAsync(string employeeID);
Task<Employee> getEmployeeAsync(int employeeId);
}
}

9
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Interfaces/IHttpUtil.cs Normal file
View File

@ -0,0 +1,9 @@
using DamageAssesment.Api.SurveyResponses.Models;
namespace DamageAssesment.Api.SurveyResponses.Interfaces
{
public interface IHttpUtil
{
Task<string> SendAsync(HttpMethod method, string url, string JsonInput);
}
}

4
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Interfaces/ISurveysResponse.cs
View File

@ -13,11 +13,11 @@ namespace DamageAssesment.Api.SurveyResponses.Interfaces
Task<(bool IsSuccess, Models.SurveyResponse SurveyResponse, string ErrorMessage)> DeleteSurveyResponseAsync(int Id);
Task<(bool IsSuccess, dynamic SurveyResponse, string ErrorMessage)> GetSurveyResponseByIdAsync(int responseId);
Task<(bool IsSuccess, dynamic SurveyResponses, string ErrorMessage)> GetSurveyResponsesBySurveyAsync(int surveyId);
Task<(bool IsSuccess, dynamic SurveyResponses, string ErrorMessage)> GetSurveyResponsesBySurveyAndLocationAsync(int surveyId, string location);
Task<(bool IsSuccess, dynamic SurveyResponses, string ErrorMessage)> GetSurveyResponsesBySurveyAndLocationAsync(int surveyId, int locationId);
Task<(bool IsSuccess, dynamic SurveyResponses, string ErrorMessage)> GetSurveyResponsesByMaintenanceCenterAsync(int surveyId);
Task<(bool IsSuccess, dynamic SurveyResponses, string ErrorMessage)> GetResponsesByAnswerAsync(int surveyId, int questionId, string answer);
Task<(bool IsSuccess, Models.SurveyResponse SurveyResponse, string ErrorMessage)> PostSurveyAnswersAsync(Models.AnswerRequest answers);
Task<(bool IsSuccess, Models.SurveyResponse SurveyResponse, string ErrorMessage)> PostSurveyAnswersAsync(Request request);
}
}

11
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Models/AggregateAnswer.cs
View File

@ -1,11 +0,0 @@
using System.ComponentModel.DataAnnotations;
namespace DamageAssesment.Api.SurveyResponses.Models
{
public class AggregateAnswer
{
public string? Answer { get; set; }
public int Counter { get; set; }
}
}

11
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Models/AggregateResult.cs
View File

@ -1,11 +0,0 @@
using System.ComponentModel.DataAnnotations;
namespace DamageAssesment.Api.SurveyResponses.Models
{
public class AggregateResult
{
public string RegionId { get; set; }
public AggregateAnswer Answers { get; set; }
}
}

6
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Models/Answer.cs
View File

@ -6,11 +6,11 @@ namespace DamageAssesment.Api.SurveyResponses.Models
{
public int Id { get; set; }
public int QuestionId { get; set; }
public string? LocationId { get; set; }
public int LocationId { get; set; }
public string AnswerText { get; set; }
public string? Comment { get; set; }
public string Comment { get; set; }
public int SurveyResponseId { get; set; }
public string? RegionId { get; set; }
public int RegionId { get; set; }
// public string? Name { get; set; }
// public string? Abbreviation { get; set; }

13
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Models/AnswerData.cs
View File

@ -1,13 +0,0 @@
using System.ComponentModel.DataAnnotations;
namespace DamageAssesment.Api.SurveyResponses.Models
{
public class AnswerData
{
public string RegionId { get; set; }
public string Name { get; set; }
public string Abbreviation { get; set; }
public List<AggregateAnswer> Answers { get; set; }
}
}

8
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Models/AnswerRequest.cs
View File

@ -2,9 +2,9 @@
{
public class AnswerRequest
{
public int SurveyId { get; set; }
public string LocationId { get; set; }
public string EmployeeId { get; set; }
public List<QuestionRequest> Answers { get; set; }
public int QuestionId { get; set; }
public string AnswerText { get; set; }
public string Comment { get; set; }
public List<FileModel> PostedFiles { get; set; } = new List<FileModel>();
}
}

11
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Models/Employee.cs
View File

@ -4,18 +4,13 @@ namespace DamageAssesment.Api.SurveyResponses.Models
{
public class Employee
{
public string Id { get; set; }
[StringLength(50)]
public int Id { get; set; }
public string EmployeeCode { get; set; }
public string Name { get; set; }
public DateTime BirthDate { get; set; }
[StringLength(50)]
public string OfficePhoneNumber { get; set; }
[StringLength(50)]
public string Email { get; set; }
public bool IsActive { get; set; }
public string? PreferredLanguage { get; set; }
}
}

4
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Models/Location.cs
View File

@ -2,8 +2,8 @@
{
public class Location
{
public string Id { get; set; }
public string RegionId { get; set; }
public int Id { get; set; }
public int RegionId { get; set; }
public string Name { get; set; }
public string MaintenanceCenter { get; set; }
public string SchoolType { get; set; }

17
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Models/Question.cs
View File

@ -1,24 +1,17 @@
using System.ComponentModel.DataAnnotations;
using System.Collections.Generic;
namespace DamageAssesment.Api.SurveyResponses.Models
{
public class Question
public class Question
{
public int Id { get; set; }
public List<QuestionsTranslation> Questions { get; set; }
//public int QuestionTypeID { get; set; }
public string TypeText { get; set; } = string.Empty;
public string TypeText { get; set; }
public int QuestionNumber { get; set; }
public bool IsRequired { get; set; }
public bool Comment { get; set; }
public bool Key { get; set; }
public int? SurveyId { get; set; }
public string QuestionGroup { get; set; }
public int SurveyId { get; set; }
public int CategoryId { get; set; }
// public int? Survey_SurveyID { get; set; }
public Dictionary<string, string> Text { get; set; }
}
}

10
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Models/QuestionRequest.cs
View File

@ -1,10 +0,0 @@
namespace DamageAssesment.Api.SurveyResponses.Models
{
public class QuestionRequest
{
public int QuestionId { get; set; }
public string AnswerText { get; set; }
public string Comment { get; set; }
public List<FileModel> PostedFiles { get; set; } = new List<FileModel>();
}
}

8
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Models/QuestionsTranslation.cs
View File

@ -1,8 +0,0 @@
namespace DamageAssesment.Api.SurveyResponses.Models
{
public class QuestionsTranslation
{
public string QuestionText { get; set; }
public string Language { get; set; } = "En";
}
}

2
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Models/Region.cs
View File

@ -4,7 +4,7 @@ namespace DamageAssesment.Api.SurveyResponses.Models
{
public class Region
{
public string Id { get; set; }
public int Id { get; set; }
public string Name { get; set; }
public string Abbreviation { get; set; }
}

15
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Models/Request.cs Normal file
View File

@ -0,0 +1,15 @@
namespace DamageAssesment.Api.SurveyResponses.Models
{
public class Request
{
public int SurveyId { get; set; }
public int LocationId { get; set; }
public int EmployeeId { get; set; }
public string? ClientDevice { get; set; }
public string? KeyAnswerResult { get; set; }
public double? Longitute { get; set; }
public double? Latitude { get; set; }
public DateTime? CreatedDate { get; set; } = DateTime.Now;
public List<AnswerRequest> Answers { get; set; }
}
}

10
DamageAssesmentApi/DamageAssesment.Api.SurveyResponses/Models/ResultData.cs
View File

@ -1,10 +0,0 @@
using System.ComponentModel.DataAnnotations;
namespace DamageAssesment.Api.SurveyResponses.Models
{
public class ResultData
{
public List<AnswerData> Regions { get; set; }
}
}

Some files were not shown because too many files have changed in this diff Show More