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

Merge branch 'dev' into docker-branch

Browse Source
This commit is contained in:
Santhosh S 2023-09-03 18:47:12 -04:00
commit 220f18da8d
40 changed files with 2052 additions and 394 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,50 +0,0 @@
using DamageAssesment.Api.Answers.Db;
using DamageAssesment.Api.Answers.Interfaces;
using DamageAssesment.Api.Answers.Providers;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;
using Microsoft.OpenApi.Models;
using System.Reflection;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
//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.UseInMemoryDatabase("Answers");
});
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI(options =>
{
options.SwaggerEndpoint("/swagger/v1/swagger.json","" );
});
}
app.UseAuthorization();
app.MapControllers();
app.Run();

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

@ -1,53 +0,0 @@
using DamageAssesment.Api.Attachments.Db;
using DamageAssesment.Api.Attachments.Interfaces;
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);
// Add services to the container.
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
//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>();
builder.Services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies()); //4/30
builder.Services.AddDbContext<AttachmentsDbContext>(option =>
{
option.UseInMemoryDatabase("Attachments");
});
builder.Services.Configure<FormOptions>(o =>
{
o.ValueLengthLimit = int.MaxValue;
o.MultipartBodyLengthLimit = int.MaxValue;
o.MemoryBufferThreshold = int.MaxValue;
});
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
app.UseAuthorization();
app.UseHttpsRedirection();
app.MapControllers();
app.UseStaticFiles();
app.Run();

9
DamageAssesmentApi/DamageAssesment.Api.Surveys.Test/DamageAssesment.Api.Survey.Test.csproj → DamageAssesmentApi/DamageAssesment.Api.Documents.Test/DamageAssesment.Api.Documents.Test.csproj
View File

@ -1,4 +1,4 @@
<Project Sdk="Microsoft.NET.Sdk">
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net6.0</TargetFramework>
@ -12,19 +12,16 @@
<ItemGroup>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
<PackageReference Include="Moq" Version="4.18.4" />
<PackageReference Include="coverlet.collector" Version="3.2.0" />
<PackageReference Include="xunit" Version="2.4.2" />
<PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
<PrivateAssets>all</PrivateAssets>
</PackageReference>
<PackageReference Include="coverlet.collector" Version="3.2.0">
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
<PrivateAssets>all</PrivateAssets>
</PackageReference>
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\DamageAssesment.Api.Surveys\DamageAssesment.Api.Survey.csproj" />
<ProjectReference Include="..\DamageAssesment.Api.Documents\DamageAssesment.Api.Documents.csproj" />
</ItemGroup>
</Project>

331
DamageAssesmentApi/DamageAssesment.Api.Documents.Test/DocumentsServiceTest.cs Normal file
View File

@ -0,0 +1,331 @@
using DamageAssesment.Api.Documents.Controllers;
using DamageAssesment.Api.Documents.Interfaces;
using DamageAssesment.Api.Documents.Models;
using Microsoft.AspNetCore.Mvc;
using Moq;
using Xunit;
namespace DamageAssesment.Api.Documents.Test
{
public class DocumentServiceTest
{
[Fact(DisplayName = "Get Documents - NoContent Case")]
public async Task GetDocumentsLanguageAsync_ShouldReturnStatusCode204()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getNoContentResponse();
mockDocumentService.Setup(service => service.GetDocumnetsAsync()).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (NoContentResult)await DocumentProvider.GetDocumentsbyFormsandLanguageAsync("", "");
Assert.Equal(204, result.StatusCode);
}
[Fact(DisplayName = "Get Documents - NoContent Case")]
public async Task GetDocumentsLinkTypeAsync_ShouldReturnStatusCode204()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getNoContentResponse();
mockDocumentService.Setup(service => service.GetDocumnetsAsync()).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (NoContentResult)await DocumentProvider.GetDocumentsbyFormsandLanguageAsync("", "");
Assert.Equal(204, result.StatusCode);
}
[Fact(DisplayName = "Get Documents - Ok case")]
public async Task GetDocumentsAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getOkResponse();
mockDocumentService.Setup(service => service.GetDocumnetsAsync()).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (OkObjectResult)await DocumentProvider.GetDocumentsAsync();
Assert.Equal(200, result.StatusCode);
}
[Fact(DisplayName = "Get Documents - NoContent Case")]
public async Task GetDocumentsAsync_ShouldReturnStatusCode204()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getNoContentResponse();
mockDocumentService.Setup(service => service.GetDocumnetsAsync()).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (NoContentResult)await DocumentProvider.GetDocumentsAsync();
Assert.Equal(204, result.StatusCode);
}
[Fact(DisplayName = "Get Document by Id - Ok case")]
public async Task GetDocumentAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getOkResponse(1);
mockDocumentService.Setup(service => service.GetDocumentAsync(1)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (OkObjectResult)await DocumentProvider.GetDocumentAsync(1);
Assert.Equal(200, result.StatusCode);
}
[Fact(DisplayName = "Get Document by Id - NotFound case")]
public async Task GetDocumentAsync_ShouldReturnStatusCode404()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getNotFoundResponse();
mockDocumentService.Setup(service => service.GetDocumentAsync(99)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (NotFoundResult)await DocumentProvider.GetDocumentAsync(99);
Assert.Equal(404, result.StatusCode);
}
[Fact(DisplayName = "Post Document - Ok case")]
public async Task PostDocumentAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getOkResponse(1);
var mockInputDocument = await MockData.getInputDocumentData();
var DocumentResponse = await MockData.GetDocumentsInfo(0);
mockDocumentService.Setup(service => service.PostDocumentAsync(mockInputDocument)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (NoContentResult)await DocumentProvider.CreateDocument(DocumentResponse);
Assert.Equal(204, result.StatusCode);
}
[Fact(DisplayName = "Post Document - BadRequest case")]
public async Task PostDocumentAsync_ShouldReturnStatusCode400()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockInputDocument = await MockData.getInputDocumentData();
var mockResponse = await MockData.getBadRequestResponse();
DocumentInfo documentInfo = null;
mockDocumentService.Setup(service => service.PostDocumentAsync(mockInputDocument)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (BadRequestObjectResult)await DocumentProvider.CreateDocument(documentInfo);
Assert.Equal(400, result.StatusCode);
}
[Fact(DisplayName = "Put Document - Ok case")]
public async Task PutDocumentAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getOkResponse(1);
var mockInputDocument = await MockData.getInputDocumentData();
var DocumentResponse = await MockData.GetDocumentsInfo(1);
mockDocumentService.Setup(service => service.UpdateDocumentAsync(mockInputDocument)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (NoContentResult)await DocumentProvider.UpdateDocument(DocumentResponse);
Assert.Equal(204, result.StatusCode);
}
[Fact(DisplayName = "Put Document - BadRequest case")]
public async Task PutDocumentAsync_ShouldReturnStatusCode400()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getBadRequestResponse();
var mockInputDocument = await MockData.getInputDocumentData();
mockDocumentService.Setup(service => service.UpdateDocumentAsync(mockInputDocument)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (BadRequestObjectResult)await DocumentProvider.UpdateDocument(null);
Assert.Equal(400, result.StatusCode);
}
[Fact(DisplayName = "Delete Document - Ok case")]
public async Task DeleteDocumentAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getOkResponse(1);
mockDocumentService.Setup(service => service.DeleteDocumentAsync(1)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (OkObjectResult)await DocumentProvider.DeleteDocument(1);
Assert.Equal(200, result.StatusCode);
}
[Fact(DisplayName = "Delete Document - NotFound case")]
public async Task DeleteDocumentAsync_ShouldReturnStatusCode404()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getNotFoundResponse();
mockDocumentService.Setup(service => service.DeleteDocumentAsync(1)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (NotFoundResult)await DocumentProvider.DeleteDocument(1);
Assert.Equal(404, result.StatusCode);
}
// Link Type Test cases
[Fact(DisplayName = "Get Link types - Ok case")]
public async Task GetDocumentCategoriesAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await LinkTypeMockData.getOkResponse();
mockDocumentService.Setup(service => service.GetLinkTypesAsync()).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (OkObjectResult)await DocumentProvider.GetLinkTypesAsync();
Assert.Equal(200, result.StatusCode);
}
[Fact(DisplayName = "Get Link types - NoContent Case")]
public async Task GetDocumentCategoriesAsync_ShouldReturnStatusCode204()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await LinkTypeMockData.getNoContentResponse();
mockDocumentService.Setup(service => service.GetLinkTypesAsync()).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (NoContentResult)await DocumentProvider.GetLinkTypesAsync();
Assert.Equal(204, result.StatusCode);
}
[Fact(DisplayName = "Get Link Type by Id - Ok case")]
public async Task GetDocumentcategoryAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await LinkTypeMockData.getOkResponse(1);
mockDocumentService.Setup(service => service.GetLinkTypeAsync(1)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (OkObjectResult)await DocumentProvider.GetLinkTypeAsync(1);
Assert.Equal(200, result.StatusCode);
}
[Fact(DisplayName = "Get Link Type by Id - NotFound case")]
public async Task GetDocumentcategoryAsync_ShouldReturnStatusCode404()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await LinkTypeMockData.getNotFoundResponse();
mockDocumentService.Setup(service => service.GetLinkTypeAsync(99)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (NotFoundResult)await DocumentProvider.GetLinkTypeAsync(99);
Assert.Equal(404, result.StatusCode);
}
[Fact(DisplayName = "Post Link Type - Ok case")]
public async Task PostDocumentcategoryAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await LinkTypeMockData.getOkResponse(1);
var mockInputDocument = await LinkTypeMockData.getInputLinkData(0);
mockDocumentService.Setup(service => service.PostLinkTypeAsync(mockInputDocument)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (OkObjectResult)await DocumentProvider.CreateLinkType(mockInputDocument);
Assert.Equal(200, result.StatusCode);
}
[Fact(DisplayName = "Post Link Type - BadRequest case")]
public async Task PostDocumentcategoryAsync_ShouldReturnStatusCode400()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockInputDocument = await LinkTypeMockData.getInputLinkData(99);
var mockResponse = await LinkTypeMockData.getBadRequestResponse();
mockDocumentService.Setup(service => service.PostLinkTypeAsync(mockInputDocument)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (BadRequestObjectResult)await DocumentProvider.CreateLinkType(mockInputDocument);
Assert.Equal(400, result.StatusCode);
}
[Fact(DisplayName = "Put Document - Ok case")]
public async Task PutDocumentcategoryAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await LinkTypeMockData.getOkResponse(1);
var mockInputDocument = await LinkTypeMockData.getInputLinkData(1);
mockDocumentService.Setup(service => service.UpdateLinkTypeAsync(mockInputDocument)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (OkObjectResult)await DocumentProvider.UpdateLinkType(mockInputDocument);
Assert.Equal(200, result.StatusCode);
}
[Fact(DisplayName = "Put Document - NotFound case")]
public async Task PutDocumentcategoryAsync_ShouldReturnStatusCode404()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await LinkTypeMockData.getNotFoundResponse();
var mockInputDocument = await LinkTypeMockData.getInputLinkData(99);
mockDocumentService.Setup(service => service.UpdateLinkTypeAsync(mockInputDocument)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (NotFoundObjectResult)await DocumentProvider.UpdateLinkType(mockInputDocument);
Assert.Equal(404, result.StatusCode);
}
[Fact(DisplayName = "Put Document - BadRequest case")]
public async Task PutDocumentcategoryAsync_ShouldReturnStatusCode400()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await LinkTypeMockData.getBadRequestResponse();
var mockInputDocument = await LinkTypeMockData.getInputLinkData(1);
mockDocumentService.Setup(service => service.UpdateLinkTypeAsync(mockInputDocument)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (BadRequestObjectResult)await DocumentProvider.UpdateLinkType(mockInputDocument);
Assert.Equal(400, result.StatusCode);
}
[Fact(DisplayName = "Delete Document - Ok case")]
public async Task DeleteDocumentcategoryAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await LinkTypeMockData.getOkResponse(1);
mockDocumentService.Setup(service => service.DeleteLinkTypeAsync(1)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (OkObjectResult)await DocumentProvider.DeleteLinkType(1);
Assert.Equal(200, result.StatusCode);
}
[Fact(DisplayName = "Delete Document - NotFound case")]
public async Task DeleteDocumentcategoryAsync_ShouldReturnStatusCode404()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await LinkTypeMockData.getNotFoundResponse();
mockDocumentService.Setup(service => service.DeleteLinkTypeAsync(1)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (NotFoundResult)await DocumentProvider.DeleteLinkType(99);
Assert.Equal(404, result.StatusCode);
}
}
}

61
DamageAssesmentApi/DamageAssesment.Api.Documents.Test/LinkTypeMockData.cs Normal file
View File

@ -0,0 +1,61 @@
using DamageAssesment.Api.Documents.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Mail;
using System.Text;
using System.Threading.Tasks;
namespace DamageAssesment.Api.Documents.Test
{
public class LinkTypeMockData
{
public static async Task<(bool, List<Documents.Models.LinkType>, string)> getOkResponse()
{
List<Documents.Models.LinkType> list = new List<Documents.Models.LinkType>();
for (int i = 1; i < 4; i++)
{
list.Add(new Documents.Models.LinkType()
{
Id = i,
TypeText = "sample"+i,
IsActive = true
});
}
return (true, list, null);
}
public static async Task<(bool, Documents.Models.LinkType, string)> getOkResponse(int Id)
{
var Documents = await getOkResponse();
var Document = Documents.Item2.FirstOrDefault(s => s.Id == Id);
return (true, Document, null);
}
public static async Task<(bool, Documents.Models.LinkType, string)> getBadRequestResponse()
{
return (false, null, "Bad Request");
}
public static async Task<(bool, Documents.Models.LinkType, string)> getNotFoundResponse()
{
return (false, null, "Not Found");
}
public static async Task<(bool, IEnumerable<Documents.Models.LinkType>, string)> getNoContentResponse()
{
IEnumerable<Documents.Models.LinkType> list = new List<Documents.Models.LinkType>();
return (false, list, null);
}
public static async Task<Documents.Models.LinkType> getInputLinkData(int id)
{
return new Models.LinkType
{
Id = id,
TypeText = "sample",
IsActive = true
};
}
}
}

117
DamageAssesmentApi/DamageAssesment.Api.Documents.Test/MockData.cs Normal file
View File

@ -0,0 +1,117 @@
using DamageAssesment.Api.Documents.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Mail;
using System.Text;
using System.Threading.Tasks;
namespace DamageAssesment.Api.Documents.Test
{
public class MockData
{
public static async Task<(bool, List<Documents.Models.Document>, string)> getOkResponse()
{
List<Documents.Models.Document> list = new List<Documents.Models.Document>();
for (int i = 1; i < 4; i++)
{
List<Documents.Models.DocumentsTranslation> documentsTranslations = new List<DocumentsTranslation>();
documentsTranslations.Add(new DocumentsTranslation()
{
Language = "en",
title = "tel"+i,
description = "Sample"+i
});
list.Add(new Documents.Models.Document()
{
Id = i,
linkTypeId = i,
docName = "sample"+i,
url = "testurl" + i,
Path = "testpath" + i,
IsActive = true,
documentsTranslations= documentsTranslations,
dateCreated = DateTime.Now,
dateUpdated = DateTime.Now
});
}
return (true, list, null);
}
public static async Task<(bool, Documents.Models.Document, string)> getOkResponse(int Id)
{
var Documents = await getOkResponse();
var Document = Documents.Item2.FirstOrDefault(s => s.Id == Id);
return (true, Document, null);
}
public static async Task<(bool, Documents.Models.Document, string)> getBadRequestResponse()
{
return (false, null, "Bad Request");
}
public static async Task<(bool, Documents.Models.Document, string)> getNotFoundResponse()
{
return (false, null, "Not Found");
}
public static async Task<(bool, IEnumerable<Documents.Models.Document>, string)> getNoContentResponse()
{
IEnumerable<Documents.Models.Document> list = new List<Documents.Models.Document>();
return (false, list, null);
}
public static async Task<Documents.Models.DocumentInfo> GetDocumentsInfo(int id)
{
FileModel fileModel = new FileModel() { FileName = "Sample", FileContent = "c2FtcGxl", FileExtension = ".txt" };
return new DocumentInfo() { Id=id, linkTypeId = 1, url = "Sample", File = fileModel };
}
public static async Task<Documents.Models.Document> getInputDocumentData()
{
List<Documents.Models.DocumentsTranslation> documentsTranslations = new List<DocumentsTranslation>();
documentsTranslations.Add(new DocumentsTranslation()
{
Language = "en",
title = "tel",
description = "Sample"
});
return new Models.Document
{
Id = 1,
linkTypeId = 1,
docName = "sample",
url = "testurl",
Path = "testpath",
IsActive = true,
documentsTranslations= documentsTranslations,
dateCreated = DateTime.Now,
dateUpdated = DateTime.Now
};
}
public static async Task<List<Documents.Models.Document>> getInputDocumentsData()
{
List<Documents.Models.DocumentsTranslation> documentsTranslations = new List<DocumentsTranslation>();
documentsTranslations.Add(new DocumentsTranslation()
{
Language = "en",
title = "tel",
description="Sample"
});
List<Documents.Models.Document> Documents = new List<Models.Document>();
Documents.Add(new Models.Document
{
Id = 1,
linkTypeId = 1,
docName = "sample",
url = "testurl",
Path = "testpath",
IsActive = true,
documentsTranslations= documentsTranslations,
dateCreated = DateTime.Now,
dateUpdated = DateTime.Now
});
return Documents;
}
}
}

222
DamageAssesmentApi/DamageAssesment.Api.Documents/Controllers/DocumentsController.cs Normal file
View File

@ -0,0 +1,222 @@
using DamageAssesment.Api.Documents.Db;
using DamageAssesment.Api.Documents.Interfaces;
using DamageAssesment.Api.Documents.Models;
using DamageAssesment.Api.Documents.Providers;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
namespace DamageAssesment.Api.Documents.Controllers
{
[Route("api")]
[ApiController]
public class DocumentsController : ControllerBase
{
private readonly IDocumentsProvider documentsProvider;
private readonly IUploadService uploadService;
public DocumentsController(IDocumentsProvider documentsProvider,IUploadService uploadService)
{
this.documentsProvider = documentsProvider;
this.uploadService = uploadService;
}
/// <summary>
/// Get all documnets.
/// </summary>
[HttpGet("{language}/{LinkType}/documents")]
public async Task<IActionResult> GetDocumentsbyFormsandLanguageAsync(string language,string LinkType)
{
var result = await this.documentsProvider.GetDocumnetsByLinkAsync(language, LinkType);
if (result.IsSuccess)
{
return Ok(result.documents);
}
return NoContent();
}
/// <summary>
/// Get all documnets.
/// </summary>
[HttpGet("{LinkType}/documents")]
public async Task<IActionResult> GetDocumentsbyFormAsync(string LinkType)
{
var result = await this.documentsProvider.GetDocumnetsByLinkAsync(null, LinkType);
if (result.IsSuccess)
{
return Ok(result.documents);
}
return NoContent();
}
/// <summary>
/// Get all documnets.
/// </summary>
[HttpGet("documents")]
public async Task<IActionResult> GetDocumentsAsync()
{
var result = await this.documentsProvider.GetDocumnetsAsync();
if (result.IsSuccess)
{
return Ok(result.documents);
}
return NoContent();
}
/// <summary>
/// Get a documnet by id.
/// </summary>
[HttpGet("documents/{id}")]
public async Task<IActionResult> GetDocumentAsync(int id)
{
var result = await this.documentsProvider.GetDocumentAsync(id);
if (result.IsSuccess)
{
return Ok(result.Document);
}
return NotFound();
}
/// <summary>
/// Upload new document.
/// </summary>
[HttpPut("documents")]
public async Task<IActionResult> UpdateDocument(DocumentInfo documentInfo)
{
if (documentInfo != null)
{
var dbdoc = await this.documentsProvider.GetDocumentAsync(documentInfo.Id);
if (dbdoc.IsSuccess)
{
Models.Document document = uploadService.UpdateDocuments(dbdoc.Document, documentInfo);
var result = await this.documentsProvider.UpdateDocumentAsync(document);
if (result.IsSuccess)
{
return Ok(result.Document);
}
return NoContent();
}
return NoContent();
}
return BadRequest(documentInfo);
}
/// <summary>
/// update existing document.
/// </summary>
[HttpPost("documents")]
public async Task<IActionResult> CreateDocument(DocumentInfo documentInfo)
{
try
{
if (documentInfo != null)
{
var documents = await this.documentsProvider.GetDocumentCounter();
Models.Document document = uploadService.UploadDocument(documents.counter, documentInfo);
var result = await this.documentsProvider.PostDocumentAsync(document);
if (result.IsSuccess)
{
return Ok(result.Document);
}
return NoContent();
}
return BadRequest(documentInfo);
}
catch (Exception ex)
{
return BadRequest($"Internal server error: {ex}");
}
}
/// <summary>
/// Delete documnet by id.
/// </summary>
[HttpDelete("documents/{id}")]
public async Task<IActionResult> DeleteDocument(int id)
{
// database soft delete
var result = await this.documentsProvider.DeleteDocumentAsync(id);
if (result.IsSuccess)
{
// deleting file from folder
uploadService.Movefile(result.Document.Path);
return Ok(result.Document);
}
return NotFound();
}
/// <summary>
/// Get all document link type.
/// </summary>
[HttpGet("LinkTypes")]
public async Task<IActionResult> GetLinkTypesAsync()
{
var result = await this.documentsProvider.GetLinkTypesAsync();
if (result.IsSuccess)
{
return Ok(result.LinkTypes);
}
return NoContent();
}
/// <summary>
/// Get a document link type by id.
/// </summary>
[HttpGet("LinkTypes/{id}")]
public async Task<IActionResult> GetLinkTypeAsync(int id)
{
var result = await this.documentsProvider.GetLinkTypeAsync(id);
if (result.IsSuccess)
{
return Ok(result.LinkType);
}
return NotFound();
}
/// <summary>
/// Update a existing document link type.
/// </summary>
[HttpPut("LinkTypes")]
public async Task<IActionResult> UpdateLinkType(Models.LinkType linkType)
{
if (linkType != null)
{
var result = await this.documentsProvider.UpdateLinkTypeAsync(linkType);
if (result.IsSuccess)
{
return Ok(result.LinkType);
}
if (result.ErrorMessage == "Not Found")
return NotFound(result.ErrorMessage);
return BadRequest(result.ErrorMessage);
}
return CreatedAtRoute("DefaultApi", new { id = linkType.Id }, linkType);
}
/// <summary>
/// Create a new document link type.
/// </summary>
[HttpPost("LinkTypes")]
public async Task<IActionResult> CreateLinkType(Models.LinkType linkType)
{
if (linkType != null)
{
var result = await this.documentsProvider.PostLinkTypeAsync(linkType);
if (result.IsSuccess)
{
return Ok(result.LinkType);
}
return BadRequest(result.ErrorMessage);
}
return CreatedAtRoute("DefaultApi", new { id = linkType.Id }, linkType);
}
/// <summary>
/// Delete a existing document link type by id.
/// </summary>
[HttpDelete("LinkTypes/{id}")]
public async Task<IActionResult> DeleteLinkType(int id)
{
var result = await this.documentsProvider.DeleteLinkTypeAsync(id);
if (result.IsSuccess)
{
return Ok(result.LinkType);
}
return NotFound();
}
}
}

1
DamageAssesmentApi/DamageAssesment.Api.Documents/DASA_Documents/Active/Document_1.txt Normal file
View File

@ -0,0 +1 @@
sample

31
DamageAssesmentApi/DamageAssesment.Api.Documents/DamageAssesment.Api.Documents.csproj Normal file
View File

@ -0,0 +1,31 @@
<Project Sdk="Microsoft.NET.Sdk.Web">
<PropertyGroup>
<TargetFramework>net6.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
</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.2.7" />
<PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.9" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="7.0.9">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
<PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="7.0.5" />
<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="7.0.9" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="7.0.9">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
<PackageReference Include="Swashbuckle.AspNetCore" Version="6.2.3" />
</ItemGroup>
<ItemGroup>
<Folder Include="DASA_Documents\" />
</ItemGroup>
</Project>

22
DamageAssesmentApi/DamageAssesment.Api.Documents/Db/Document.cs Normal file
View File

@ -0,0 +1,22 @@
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace DamageAssesment.Api.Documents.Db
{
public class Document
{
[Key]
public int Id { get; set; }
[ForeignKey("LinkType")]
public int linkTypeId { get; set; }
public string docName { get; set; }
public string url { get; set; }
public string Path { get; set; }
public bool IsActive { get; set; }
public DateTime dateCreated { get; set; }
public DateTime dateUpdated { get; set; }
}
}

30
DamageAssesmentApi/DamageAssesment.Api.Documents/Db/DocumentDbContext.cs Normal file
View File

@ -0,0 +1,30 @@
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using System.ComponentModel.DataAnnotations;
namespace DamageAssesment.Api.Documents.Db
{
public class DocumentDbContext : DbContext
{
public DocumentDbContext(DbContextOptions options) : base(options)
{
}
public DbSet<Db.Document> Documents { get; set; }
public DbSet<Db.LinkType> LinkTypes { get; set; }
public DbSet<Db.DocumentsTranslation> DocumentsTranslations { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity<Document>()
.Property(item => item.Id)
.ValueGeneratedOnAdd();
modelBuilder.Entity<LinkType>()
.Property(item => item.Id)
.ValueGeneratedOnAdd();
modelBuilder.Entity<DocumentsTranslation>()
.Property(item => item.Id)
.ValueGeneratedOnAdd();
}
}
}

16
DamageAssesmentApi/DamageAssesment.Api.Documents/Db/DocumentsTranslation.cs Normal file
View File

@ -0,0 +1,16 @@
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace DamageAssesment.Api.Documents.Db
{
public class DocumentsTranslation
{
[Key]
public int Id { get; set; }
[ForeignKey("Document")]
public int DocumentId { get; set; }
public string title { get; set; }
public string description { get; set; }
public string Language { get; set; }
}
}

13
DamageAssesmentApi/DamageAssesment.Api.Documents/Db/LinkType.cs Normal file
View File

@ -0,0 +1,13 @@
using System.ComponentModel.DataAnnotations;
namespace DamageAssesment.Api.Documents.Db
{
public class LinkType
{
[Key]
public int Id { get; set; }
public string TypeText { get; set; }
public bool IsActive { get; set; }
public bool IsAttachment { get; set; }
}
}

10
DamageAssesmentApi/DamageAssesment.Api.Documents/Interfaces/IAzureBlobService.cs Normal file
View File

@ -0,0 +1,10 @@
using Azure.Storage.Blobs.Models;
namespace DamageAssesment.Api.Documents.Interfaces
{
public interface IAzureBlobService
{
Task<List<Azure.Response<BlobContentInfo>>> UploadFiles(List<IFormFile> files);
void DeleteFile(string path);
}
}

11
DamageAssesmentApi/DamageAssesment.Api.Documents/Interfaces/IDocumentTypeProvider.cs Normal file
View File

@ -0,0 +1,11 @@
namespace DamageAssesment.Api.Documents.Interfaces
{
public interface ILinkTypesProvider
{
Task<(bool IsSuccess, Models.LinkType LinkType, string ErrorMessage)> GetLinkTypeAsync(int Id);
Task<(bool IsSuccess, IEnumerable<Models.LinkType> LinkTypes, string ErrorMessage)> GetLinkTypesAsync();
Task<(bool IsSuccess, Models.LinkType LinkType, string ErrorMessage)> PostLinkTypeAsync(Models.LinkType LinkType);
Task<(bool IsSuccess, Models.LinkType LinkType, string ErrorMessage)> UpdateLinkTypeAsync(Models.LinkType LinkType);
Task<(bool IsSuccess, Models.LinkType LinkType, string ErrorMessage)> DeleteLinkTypeAsync(int Id);
}
}

17
DamageAssesmentApi/DamageAssesment.Api.Documents/Interfaces/IDocumentsProvider.cs Normal file
View File

@ -0,0 +1,17 @@
using DamageAssesment.Api.Documents.Models;
namespace DamageAssesment.Api.Documents.Interfaces
{
public interface IDocumentsProvider : ILinkTypesProvider
{
Task<(bool IsSuccess, Models.Document Document, string ErrorMessage)> GetDocumentAsync(int Id);
Task<(bool IsSuccess, IEnumerable<Models.Document> documents, string ErrorMessage)> GetDocumnetsAsync();
Task<(bool IsSuccess, IEnumerable<Models.Document> documents, string ErrorMessage)> GetDocumnetsByLinkAsync(string Language,string LinkType);
Task<(bool IsSuccess, Models.Document Document, string ErrorMessage)> PostDocumentAsync(Models.Document Document);
Task<(bool IsSuccess, Models.Document Document, string ErrorMessage)> UpdateDocumentAsync(Models.Document Document);
Task<(bool IsSuccess, Models.Document Document, string ErrorMessage)> DeleteDocumentAsync(int Id);
Task<(bool IsSuccess, int counter, string message)> GetDocumentCounter();
}
}

12
DamageAssesmentApi/DamageAssesment.Api.Documents/Interfaces/IUploadService.cs Normal file
View File

@ -0,0 +1,12 @@
using DamageAssesment.Api.Documents.Models;
namespace DamageAssesment.Api.Documents.Interfaces
{
public interface IUploadService
{
Models.Document UploadDocument( int counter, DocumentInfo documentInfo);
public Models.Document UpdateDocuments( Models.Document document, DocumentInfo documentInfo);
void Deletefile(string path);
void Movefile(string path);
}
}

95
DamageAssesmentApi/DamageAssesment.Api.Documents/Migrations/20230828165655_InitialDocumentCreate.Designer.cs generated Normal file
View File

@ -0,0 +1,95 @@
// <auto-generated />
using System;
using DamageAssesment.Api.Documents.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.Documents.Migrations
{
[DbContext(typeof(DocumentDbContext))]
[Migration("20230828165655_InitialDocumentCreate")]
partial class InitialDocumentCreate
{
/// <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.Documents.Db.Document", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
b.Property<bool>("IsActive")
.HasColumnType("bit");
b.Property<string>("Path")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.Property<DateTime>("dateCreated")
.HasColumnType("datetime2");
b.Property<DateTime>("dateUpdated")
.HasColumnType("datetime2");
b.Property<string>("description")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.Property<string>("docName")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.Property<int>("linkTypeId")
.HasColumnType("int");
b.Property<string>("title")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.Property<string>("url")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.HasKey("Id");
b.ToTable("Documents");
});
modelBuilder.Entity("DamageAssesment.Api.Documents.Db.LinkType", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
b.Property<bool>("IsActive")
.HasColumnType("bit");
b.Property<string>("TypeText")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.HasKey("Id");
b.ToTable("LinkTypes");
});
#pragma warning restore 612, 618
}
}
}

60
DamageAssesmentApi/DamageAssesment.Api.Documents/Migrations/20230828165655_InitialDocumentCreate.cs Normal file
View File

@ -0,0 +1,60 @@
using System;
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace DamageAssesment.Api.Documents.Migrations
{
/// <inheritdoc />
public partial class InitialDocumentCreate : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTable(
name: "Documents",
columns: table => new
{
Id = table.Column<int>(type: "int", nullable: false)
.Annotation("SqlServer:Identity", "1, 1"),
title = table.Column<string>(type: "nvarchar(max)", nullable: false),
linkTypeId = table.Column<int>(type: "int", nullable: false),
description = table.Column<string>(type: "nvarchar(max)", nullable: false),
docName = table.Column<string>(type: "nvarchar(max)", nullable: false),
url = table.Column<string>(type: "nvarchar(max)", nullable: false),
Path = table.Column<string>(type: "nvarchar(max)", nullable: false),
IsActive = table.Column<bool>(type: "bit", nullable: false),
dateCreated = table.Column<DateTime>(type: "datetime2", nullable: false),
dateUpdated = table.Column<DateTime>(type: "datetime2", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_Documents", x => x.Id);
});
migrationBuilder.CreateTable(
name: "LinkTypes",
columns: table => new
{
Id = table.Column<int>(type: "int", nullable: false)
.Annotation("SqlServer:Identity", "1, 1"),
TypeText = table.Column<string>(type: "nvarchar(max)", nullable: false),
IsActive = table.Column<bool>(type: "bit", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_LinkTypes", x => x.Id);
});
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropTable(
name: "Documents");
migrationBuilder.DropTable(
name: "LinkTypes");
}
}
}

118
DamageAssesmentApi/DamageAssesment.Api.Documents/Migrations/20230830200432_DocumentTranslation.Designer.cs generated Normal file
View File

@ -0,0 +1,118 @@
// <auto-generated />
using System;
using DamageAssesment.Api.Documents.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.Documents.Migrations
{
[DbContext(typeof(DocumentDbContext))]
[Migration("20230830200432_DocumentTranslation")]
partial class DocumentTranslation
{
/// <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.Documents.Db.Document", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
b.Property<bool>("IsActive")
.HasColumnType("bit");
b.Property<string>("Path")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.Property<DateTime>("dateCreated")
.HasColumnType("datetime2");
b.Property<DateTime>("dateUpdated")
.HasColumnType("datetime2");
b.Property<string>("docName")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.Property<int>("linkTypeId")
.HasColumnType("int");
b.Property<string>("url")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.HasKey("Id");
b.ToTable("Documents");
});
modelBuilder.Entity("DamageAssesment.Api.Documents.Db.DocumentsTranslation", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
b.Property<int>("DocumentId")
.HasColumnType("int");
b.Property<string>("Language")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.Property<string>("description")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.Property<string>("title")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.HasKey("Id");
b.ToTable("DocumentsTranslations");
});
modelBuilder.Entity("DamageAssesment.Api.Documents.Db.LinkType", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
b.Property<bool>("IsActive")
.HasColumnType("bit");
b.Property<bool>("IsAttachment")
.HasColumnType("bit");
b.Property<string>("TypeText")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.HasKey("Id");
b.ToTable("LinkTypes");
});
#pragma warning restore 612, 618
}
}
}

70
DamageAssesmentApi/DamageAssesment.Api.Documents/Migrations/20230830200432_DocumentTranslation.cs Normal file
View File

@ -0,0 +1,70 @@
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace DamageAssesment.Api.Documents.Migrations
{
/// <inheritdoc />
public partial class DocumentTranslation : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropColumn(
name: "description",
table: "Documents");
migrationBuilder.DropColumn(
name: "title",
table: "Documents");
migrationBuilder.AddColumn<bool>(
name: "IsAttachment",
table: "LinkTypes",
type: "bit",
nullable: false,
defaultValue: false);
migrationBuilder.CreateTable(
name: "DocumentsTranslations",
columns: table => new
{
Id = table.Column<int>(type: "int", nullable: false)
.Annotation("SqlServer:Identity", "1, 1"),
DocumentId = table.Column<int>(type: "int", nullable: false),
title = table.Column<string>(type: "nvarchar(max)", nullable: false),
description = table.Column<string>(type: "nvarchar(max)", nullable: false),
Language = table.Column<string>(type: "nvarchar(max)", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_DocumentsTranslations", x => x.Id);
});
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropTable(
name: "DocumentsTranslations");
migrationBuilder.DropColumn(
name: "IsAttachment",
table: "LinkTypes");
migrationBuilder.AddColumn<string>(
name: "description",
table: "Documents",
type: "nvarchar(max)",
nullable: false,
defaultValue: "");
migrationBuilder.AddColumn<string>(
name: "title",
table: "Documents",
type: "nvarchar(max)",
nullable: false,
defaultValue: "");
}
}
}

115
DamageAssesmentApi/DamageAssesment.Api.Documents/Migrations/DocumentDbContextModelSnapshot.cs Normal file
View File

@ -0,0 +1,115 @@
// <auto-generated />
using System;
using DamageAssesment.Api.Documents.Db;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
#nullable disable
namespace DamageAssesment.Api.Documents.Migrations
{
[DbContext(typeof(DocumentDbContext))]
partial class DocumentDbContextModelSnapshot : ModelSnapshot
{
protected override void BuildModel(ModelBuilder modelBuilder)
{
#pragma warning disable 612, 618
modelBuilder
.HasAnnotation("ProductVersion", "7.0.9")
.HasAnnotation("Relational:MaxIdentifierLength", 128);
SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
modelBuilder.Entity("DamageAssesment.Api.Documents.Db.Document", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
b.Property<bool>("IsActive")
.HasColumnType("bit");
b.Property<string>("Path")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.Property<DateTime>("dateCreated")
.HasColumnType("datetime2");
b.Property<DateTime>("dateUpdated")
.HasColumnType("datetime2");
b.Property<string>("docName")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.Property<int>("linkTypeId")
.HasColumnType("int");
b.Property<string>("url")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.HasKey("Id");
b.ToTable("Documents");
});
modelBuilder.Entity("DamageAssesment.Api.Documents.Db.DocumentsTranslation", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
b.Property<int>("DocumentId")
.HasColumnType("int");
b.Property<string>("Language")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.Property<string>("description")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.Property<string>("title")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.HasKey("Id");
b.ToTable("DocumentsTranslations");
});
modelBuilder.Entity("DamageAssesment.Api.Documents.Db.LinkType", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
b.Property<bool>("IsActive")
.HasColumnType("bit");
b.Property<bool>("IsAttachment")
.HasColumnType("bit");
b.Property<string>("TypeText")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.HasKey("Id");
b.ToTable("LinkTypes");
});
#pragma warning restore 612, 618
}
}
}

19
DamageAssesmentApi/DamageAssesment.Api.Documents/Models/Document.cs Normal file
View File

@ -0,0 +1,19 @@
using System.ComponentModel.DataAnnotations;
namespace DamageAssesment.Api.Documents.Models
{
public class Document
{
public int Id { get; set; }
public int linkTypeId { get; set; }
public string docName { get; set; }
public string url { get; set; }
public string Path { get; set; }
public bool IsActive { get; set; }
public DateTime dateCreated { get; set; }
public DateTime dateUpdated { get; set; }
public List<DocumentsTranslation> documentsTranslations { get; set; }
}
}

19
DamageAssesmentApi/DamageAssesment.Api.Documents/Models/DocumentInfo.cs Normal file
View File

@ -0,0 +1,19 @@
using System.ComponentModel.DataAnnotations.Schema;
namespace DamageAssesment.Api.Documents.Models
{
public class DocumentInfo
{
public int Id { get; set; }
public int linkTypeId { get; set; }
public string url { get; set; }
public List<DocumentsTranslation> documentsTranslations { get; set; }
public FileModel? File { get; set; }
}
public class FileModel
{
public string? FileName { get; set; }
public string? FileContent { get; set; }
public string? FileExtension { get; set; }
}
}

12
DamageAssesmentApi/DamageAssesment.Api.Documents/Models/DocumentsTranslation.cs Normal file
View File

@ -0,0 +1,12 @@
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace DamageAssesment.Api.Documents.Models
{
public class DocumentsTranslation
{
public string title { get; set; }
public string description { get; set; }
public string Language { get; set; }
}
}

12
DamageAssesmentApi/DamageAssesment.Api.Documents/Models/LinkType.cs Normal file
View File

@ -0,0 +1,12 @@
using System.ComponentModel.DataAnnotations;
namespace DamageAssesment.Api.Documents.Models
{
public class LinkType
{
public int Id { get; set; }
public string TypeText { get; set; }
public bool IsActive { get; set; }
public bool IsAttachment { get; set; }
}
}

17
DamageAssesmentApi/DamageAssesment.Api.Documents/Profiles/DocumentProfile.cs Normal file
View File

@ -0,0 +1,17 @@
using AutoMapper;
namespace DamageAssesment.Api.Documents.Profiles
{
public class DocumentProfile : AutoMapper.Profile
{
public DocumentProfile()
{
CreateMap<Db.Document, Models.Document>();
CreateMap<Models.Document, Db.Document>();
CreateMap<Db.LinkType, Models.LinkType>();
CreateMap<Models.LinkType, Db.LinkType>();
CreateMap<Db.DocumentsTranslation, Models.DocumentsTranslation>();
CreateMap<Models.DocumentsTranslation, Db.DocumentsTranslation>();
}
}
}

35
DamageAssesmentApi/DamageAssesment.Api.Documents/Program.cs Normal file
View File

@ -0,0 +1,35 @@
using DamageAssesment.Api.Documents.Db;
using DamageAssesment.Api.Documents.Interfaces;
using DamageAssesment.Api.Documents.Providers;
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
builder.Services.AddScoped<IDocumentsProvider, documentsProvider>();
builder.Services.AddScoped<IUploadService, UploadService>();
builder.Services.AddScoped<IAzureBlobService, AzureBlobService>();
builder.Services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies()); //4/30
builder.Services.AddDbContext<DocumentDbContext>(option =>
{
option.UseInMemoryDatabase("DocumentConnection");
});
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
app.UseAuthorization();
app.MapControllers();
app.Run();

31
DamageAssesmentApi/DamageAssesment.Api.Documents/Properties/launchSettings.json Normal file
View File

@ -0,0 +1,31 @@
{
"$schema": "https://json.schemastore.org/launchsettings.json",
"iisSettings": {
"windowsAuthentication": false,
"anonymousAuthentication": true,
"iisExpress": {
"applicationUrl": "http://localhost:60754",
"sslPort": 0
}
},
"profiles": {
"DamageAssesment.Api.Questions": {
"commandName": "Project",
"dotnetRunMessages": true,
"launchBrowser": true,
"launchUrl": "swagger",
"applicationUrl": "http://localhost:5133",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
},
"IIS Express": {
"commandName": "IISExpress",
"launchBrowser": true,
"launchUrl": "swagger",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
}
}
}

44
DamageAssesmentApi/DamageAssesment.Api.Documents/Providers/AzureBlobService.cs Normal file
View File

@ -0,0 +1,44 @@

using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;
using Azure.Storage.Blobs.Specialized;
using DamageAssesment.Api.Documents.Interfaces;
namespace DamageAssesment.Api.Documents.Providers
{
public class AzureBlobService: IAzureBlobService
{
BlobServiceClient _blobClient;
BlobContainerClient _containerClient;
string azureConnectionString = "<Primary Connection String>";
public AzureBlobService()
{
_blobClient = new BlobServiceClient(azureConnectionString);
_containerClient = _blobClient.GetBlobContainerClient("apiimages");
}
public async Task<List<Azure.Response<BlobContentInfo>>> UploadFiles(List<IFormFile> files)
{
var azureResponse = new List<Azure.Response<BlobContentInfo>>();
foreach (var file in files)
{
string fileName = file.FileName;
using (var memoryStream = new MemoryStream())
{
file.CopyTo(memoryStream);
memoryStream.Position = 0;
var client = await _containerClient.UploadBlobAsync(fileName, memoryStream, default);
azureResponse.Add(client);
}
};
return azureResponse;
}
public void DeleteFile(string url)
{
var blob = _containerClient.GetBlockBlobClient(url);
blob.DeleteIfExists();
}
}
}

363
DamageAssesmentApi/DamageAssesment.Api.Documents/Providers/DocumentsProvider.cs Normal file
View File

@ -0,0 +1,363 @@
using AutoMapper;
using DamageAssesment.Api.Documents.Db;
using DamageAssesment.Api.Documents.Interfaces;
using DamageAssesment.Api.Documents.Models;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using System;
using System.Diagnostics.Eventing.Reader;
namespace DamageAssesment.Api.Documents.Providers
{
public class documentsProvider : IDocumentsProvider
{
private DocumentDbContext DocumentDbContext;
private ILogger<documentsProvider> logger;
private IUploadService uploadservice;
private IMapper mapper;
public documentsProvider(DocumentDbContext DocumentDbContext, ILogger<documentsProvider> logger, IMapper mapper, IUploadService uploadservice)
{
this.DocumentDbContext = DocumentDbContext;
this.logger = logger;
this.mapper = mapper;
this.uploadservice = uploadservice;
SeedData();
}
private void SeedData()
{
if (!DocumentDbContext.LinkTypes.Any())
{
DocumentDbContext.LinkTypes.Add(new Db.LinkType() {TypeText = "Forms",IsActive=true, IsAttachment=true });
DocumentDbContext.LinkTypes.Add(new Db.LinkType() {TypeText = "Communiques",IsActive = true,IsAttachment=false });
DocumentDbContext.LinkTypes.Add(new Db.LinkType() {TypeText = "Memos",IsActive = true,IsAttachment=true });
DocumentDbContext.SaveChanges();
}
if (!DocumentDbContext.Documents.Any())
{
FileModel fileModel = new FileModel() { FileName = "Sample", FileContent = "c2FtcGxl", FileExtension = ".txt" };
DocumentInfo documentInfo = new DocumentInfo() { linkTypeId = 1, url = "Sample", File = fileModel };
Models.Document document = uploadservice.UploadDocument(0, documentInfo);
DocumentDbContext.Documents.Add(mapper.Map<Models.Document, Db.Document>(document));
DocumentDbContext.SaveChanges();
}
if (!DocumentDbContext.DocumentsTranslations.Any())
{
Db.DocumentsTranslation documents = new Db.DocumentsTranslation { DocumentId = 1, title = "Test", description = "ss", Language = "en" };
DocumentDbContext.DocumentsTranslations.Add(documents);
DocumentDbContext.SaveChanges();
}
}
public async Task<(bool IsSuccess, IEnumerable<Models.Document> documents, string ErrorMessage)> GetDocumnetsByLinkAsync(string Language, string LinkType)
{
try
{
logger?.LogInformation("Query Question");
var documents=new List<Db.Document>();
if(String.IsNullOrEmpty(LinkType))
documents = await DocumentDbContext.Documents.AsNoTracking().Where(q => q.IsActive).ToListAsync();
else
documents = await DocumentDbContext.Documents.AsNoTracking().Where(q => q.IsActive &&
q.linkTypeId == (DocumentDbContext.LinkTypes.AsNoTracking().Where(a => a.TypeText.ToLower() == LinkType.ToLower()).Select(a => a.Id).FirstOrDefault())).ToListAsync();
if (documents != null)
{
var result = mapper.Map<IEnumerable<Db.Document>, IEnumerable<Models.Document>>(documents);
foreach (var item in result)
{
if(!String.IsNullOrEmpty(Language))
item.documentsTranslations = mapper.Map<List<Db.DocumentsTranslation>, List<Models.DocumentsTranslation>>(
DocumentDbContext.DocumentsTranslations.Where(a => a.DocumentId == item.Id && (a.Language.ToLower() == Language.ToLower())).ToList());
else
item.documentsTranslations = mapper.Map<List<Db.DocumentsTranslation>, List<Models.DocumentsTranslation>>(
DocumentDbContext.DocumentsTranslations.Where(a => a.DocumentId == item.Id).ToList());
}
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, IEnumerable<Models.Document> documents, string ErrorMessage)> GetDocumnetsAsync()
{
try
{
logger?.LogInformation("Query Question");
var documents = await DocumentDbContext.Documents.AsNoTracking().Where(q => q.IsActive).ToListAsync();
if (documents != null)
{
logger?.LogInformation($"{documents.Count} Document(s) found");
var result = mapper.Map<IEnumerable<Db.Document>, IEnumerable<Models.Document>>(documents);
foreach (var item in result)
{
item.documentsTranslations = mapper.Map<List<Db.DocumentsTranslation>, List<Models.DocumentsTranslation>>(
DocumentDbContext.DocumentsTranslations.Where(a => a.DocumentId == item.Id).ToList());
}
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.Document Document, string ErrorMessage)> GetDocumentAsync(int Id)
{
try
{
logger?.LogInformation("Query LinkType");
var Document = await DocumentDbContext.Documents.AsNoTracking().FirstOrDefaultAsync(q => q.Id == Id && q.IsActive);
if (Document != null)
{
logger?.LogInformation($"{Document} customer(s) found");
var result = mapper.Map<Db.Document, Models.Document>(Document);
result.documentsTranslations = mapper.Map<List<Db.DocumentsTranslation>, List<Models.DocumentsTranslation>>(
DocumentDbContext.DocumentsTranslations.Where(a => a.DocumentId == result.Id).ToList());
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.Document Document, string ErrorMessage)> PostDocumentAsync(Models.Document Document)
{
try
{
var document = mapper.Map<Models.Document, Db.Document>(Document);
DocumentDbContext.Documents.Add(document);
DocumentDbContext.SaveChanges();
var dbtranslation = mapper.Map<List<Models.DocumentsTranslation>, List<Db.DocumentsTranslation>>(Document.documentsTranslations);
dbtranslation.ForEach(i => i.DocumentId = document.Id);
DocumentDbContext.DocumentsTranslations.AddRange(dbtranslation);
DocumentDbContext.SaveChanges();
Document.Id = document.Id;
return (true, Document, null);
}
catch (Exception ex)
{
logger?.LogError(ex.ToString());
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.Document Document, string ErrorMessage)> UpdateDocumentAsync(Models.Document Document)
{
try
{
if (Document != null)
{
var existing = DocumentDbContext.Documents.AsNoTracking().FirstOrDefault(x => x.Id == Document.Id);
if (existing != null)
{
var document = mapper.Map<Models.Document, Db.Document>(Document);
DocumentDbContext.Documents.Update(document);
DocumentDbContext.SaveChanges();
var oldtranslations = DocumentDbContext.DocumentsTranslations.Where(a => a.DocumentId == Document.Id).ToList();
if (oldtranslations != null)
DocumentDbContext.DocumentsTranslations.RemoveRange(oldtranslations);
var dbtranslation = mapper.Map<List<Models.DocumentsTranslation>, List<Db.DocumentsTranslation>>(Document.documentsTranslations);
dbtranslation.ForEach(i => i.DocumentId = Document.Id);
return (true, Document, "Successful");
}
else
{
logger?.LogInformation($"{Document} Not found");
return (false, null, "Not Found");
}
}
else
{
logger?.LogInformation($"{Document} Bad Request");
return (false, null, "Bad request");
}
}
catch (Exception ex)
{
logger?.LogError(ex.ToString());
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.Document Document, string ErrorMessage)> DeleteDocumentAsync(int Id)
{
try
{
Db.Document Document = DocumentDbContext.Documents.AsNoTracking().Where(a => a.Id == Id).FirstOrDefault();
if (Document == null)
{
return (false, null, "Not Found");
}
Document.IsActive = false;
DocumentDbContext.Documents.Update(Document);
DocumentDbContext.SaveChanges();
return (true, mapper.Map<Db.Document, Models.Document>(Document), $"DocumentId {Id} deleted Successfuly");
}
catch (Exception ex)
{
logger?.LogError(ex.ToString());
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, int counter, string message)> GetDocumentCounter()
{
try
{
int AttachmentId = DocumentDbContext.Documents.Max(a => a.Id);
return (true, AttachmentId, "");
}
catch (Exception ex)
{
return (false, 0, ex.Message);
}
}
//Link Type methods
public async Task<(bool IsSuccess, IEnumerable<Models.LinkType> LinkTypes, string ErrorMessage)> GetLinkTypesAsync()
{
try
{
logger?.LogInformation("Query Question");
var LinkType = await DocumentDbContext.LinkTypes.AsNoTracking().Where(q=>q.IsActive).ToListAsync();
if (LinkType != null)
{
logger?.LogInformation($"{LinkType.Count} LinkTypes(s) found");
var result = mapper.Map<IEnumerable<Db.LinkType>, IEnumerable<Models.LinkType>>(LinkType);
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.LinkType LinkType, string ErrorMessage)> GetLinkTypeAsync(int Id)
{
try
{
logger?.LogInformation("Query LinkType");
var LinkType = await DocumentDbContext.LinkTypes.AsNoTracking().FirstOrDefaultAsync(q => q.Id == Id&&q.IsActive);
if (LinkType != null)
{
logger?.LogInformation($"{LinkType} customer(s) found");
var result = mapper.Map<Db.LinkType, Models.LinkType>(LinkType);
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.LinkType LinkType, string ErrorMessage)> PostLinkTypeAsync(Models.LinkType LinkType)
{
try
{
logger?.LogInformation("Query LinkType");
if (!LinkTypeExists(LinkType.Id))
{
var dbLink = mapper.Map<Models.LinkType, Db.LinkType>(LinkType);
DocumentDbContext.LinkTypes.Add(dbLink);
DocumentDbContext.SaveChanges();
var result = mapper.Map<Db.LinkType, Models.LinkType>(dbLink);
return (true, result, null);
}
return (false, null, "LinkType is already exits");
}
catch (Exception ex)
{
logger?.LogError(ex.ToString());
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.LinkType LinkType, string ErrorMessage)> UpdateLinkTypeAsync(Models.LinkType LinkType)
{
try
{
if (LinkType != null)
{
var existing = DocumentDbContext.LinkTypes.AsNoTracking().FirstOrDefault(x => x.Id == LinkType.Id);
if (existing != null)
{
var dbLink = mapper.Map<Models.LinkType, Db.LinkType>(LinkType);
DocumentDbContext.LinkTypes.Update(dbLink);
DocumentDbContext.SaveChanges();
return (true, mapper.Map<Db.LinkType, Models.LinkType>(dbLink), "Successful");
}
else
{
logger?.LogInformation($"{LinkType} Not found");
return (false, null, "Not Found");
}
}
else
{
logger?.LogInformation($"{LinkType} Bad Request");
return (false, null, "Bad request");
}
}
catch (Exception ex)
{
logger?.LogError(ex.ToString());
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.LinkType LinkType, string ErrorMessage)> DeleteLinkTypeAsync(int Id)
{
try
{
Db.LinkType LinkType = DocumentDbContext.LinkTypes.AsNoTracking().Where(a => a.Id == Id).FirstOrDefault();
if (LinkType == null)
{
return (false, null, "Not Found");
}
LinkType.IsActive = false;
DocumentDbContext.LinkTypes.Update(LinkType);
DocumentDbContext.SaveChanges();
return (true, mapper.Map<Db.LinkType, Models.LinkType>(LinkType), $"LinkTypeId {Id} deleted Successfuly");
}
catch (Exception ex)
{
logger?.LogError(ex.ToString());
return (false, null, ex.Message);
}
}
private bool LinkTypeExists(int id)
{
return DocumentDbContext.LinkTypes.AsNoTracking().Count(e => e.Id == id) > 0;
}
}
}

123
DamageAssesmentApi/DamageAssesment.Api.Documents/Providers/UploadService.cs Normal file
View File

@ -0,0 +1,123 @@
using AutoMapper;
using Azure;
using DamageAssesment.Api.Documents.Db;
using DamageAssesment.Api.Documents.Interfaces;
using DamageAssesment.Api.Documents.Models;
using Microsoft.AspNetCore.Http;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using System.Diagnostics.Metrics;
using System.Net.Http;
using System.Security.AccessControl;
using System.Security.Principal;
namespace DamageAssesment.Api.Documents.Providers
{
public class UploadService : IUploadService
{
private ILogger<UploadService> logger;
private IMapper mapper;
private string uploadpath = "";
private string Deletepath = "";
public UploadService(IConfiguration configuration, ILogger<UploadService> logger, IMapper mapper)
{
this.logger = logger;
this.mapper = mapper;
uploadpath = configuration.GetValue<string>("Fileupload:folderpath");
Deletepath = configuration.GetValue<string>("Fileupload:Deletepath");
}
public Models.Document UploadDocument(int counter, DocumentInfo documentInfo)
{
Models.Document Documents = new Models.Document();
try
{
string path = "", UserfileName="";
if (documentInfo.File != null)
{
counter++;
var fullDirectoryPath = Path.Combine(Directory.GetCurrentDirectory(), uploadpath);
if (!Directory.Exists(fullDirectoryPath)) //Create deirectory if does not exist
Directory.CreateDirectory(fullDirectoryPath);
UserfileName = Path.GetFileName(documentInfo.File.FileName);
var fileName = String.Format("Document_{0}{1}", counter, documentInfo.File.FileExtension);
path = Path.Combine(fullDirectoryPath, fileName);
File.WriteAllBytes(path, Convert.FromBase64String(documentInfo.File.FileContent));
}
Documents=new Models.Document (){ linkTypeId = documentInfo.linkTypeId,
documentsTranslations = documentInfo.documentsTranslations,
docName = UserfileName,
url = documentInfo.url, Path = path,IsActive =true,dateCreated=DateTime.Now,dateUpdated=DateTime.Now};
return Documents;
}
catch (Exception ex) {
return new Models.Document();
}
}
public Models.Document UpdateDocuments(Models.Document document, DocumentInfo documentInfo)
{
try
{
Deletefile(document.Path);
var fullDirectoryPath = Path.Combine(Directory.GetCurrentDirectory(), uploadpath);
if (!Directory.Exists(fullDirectoryPath)) //Create deirectory if does not exist
Directory.CreateDirectory(fullDirectoryPath);
string path = "", UserfileName = "";
if (documentInfo.File != null)
{
UserfileName = Path.GetFileName(documentInfo.File.FileName);
var fileName = String.Format("Document_{0}{1}", documentInfo.Id, documentInfo.File.FileExtension);
path = Path.Combine(fullDirectoryPath, fileName);
File.WriteAllBytes(path, Convert.FromBase64String(documentInfo.File.FileContent));
}
Models.Document Documents = new Models.Document()
{
Id = documentInfo.Id,
linkTypeId = documentInfo.linkTypeId,
documentsTranslations=documentInfo.documentsTranslations,
docName = UserfileName,
url = documentInfo.url,
Path = path,
IsActive = true,
dateCreated = document.dateCreated,
dateUpdated = DateTime.Now
};
return Documents;
}
catch (Exception ex) {
return new Models.Document();
}
}
public void Deletefile(string path)
{
if (path != "")
{
FileInfo file = new FileInfo(path);
if (file?.Exists??false)//check file exsit or not
{
file.Delete();
}
}
}
public void Movefile(string path)
{
if (path != "")
{
var pathToSave = Path.Combine(Directory.GetCurrentDirectory(), Deletepath);
if (!Directory.Exists(pathToSave)) //Create deirectory if does not exist
Directory.CreateDirectory(pathToSave);
FileInfo file = new FileInfo(path);
if (file?.Exists ?? false)//check file exsit or not
{
string filename = file.Name.Replace(file.Extension, " ") + DateTime.Now.ToShortDateString().Replace("/","_") + file.Extension;
file.MoveTo(pathToSave+"\\"+ filename);
}
}
}
}
}

8
DamageAssesmentApi/DamageAssesment.Api.Documents/appsettings.Development.json Normal file
View File

@ -0,0 +1,8 @@
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
}
}

13
DamageAssesmentApi/DamageAssesment.Api.Documents/appsettings.json Normal file
View File

@ -0,0 +1,13 @@
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"AllowedHosts": "*",
"Fileupload": {
"folderpath": "DASA_Documents/Active",
"Deletepath": "DASA_Documents/Deleted"
}
}

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

@ -1,47 +0,0 @@
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);
// Add services to the container.
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
//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 =>
{
option.UseInMemoryDatabase("Employees");
});
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI(options =>
{
options.SwaggerEndpoint("/swagger/v1/swagger.json", "");
// options.RoutePrefix = ""; // Serve Swagger UI at the root URL
});
}
app.UseAuthorization();
app.MapControllers();
app.Run();

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

@ -1,100 +0,0 @@
using DamageAssesment.Api.Locations.Interfaces;
using Microsoft.AspNetCore.Http;
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;
}
/// <summary>
/// Get all locations.
/// </summary>
[HttpGet("Locations")]
public async Task<ActionResult> GetLocationsAsync()
{
var result = await LocationProvider.GetLocationsAsync();
if (result.IsSuccess)
{
return Ok(result.locations);
}
return NotFound();
}
/// <summary>
/// Get all locations based on locationdId.
/// </summary>
[HttpGet("Locations/{id}")]
public async Task<ActionResult> GetLocationByIdAsync(string id)
{
var result = await LocationProvider.GetLocationByIdAsync(id);
if (result.IsSuccess)
{
return Ok(result.Location);
}
return NotFound();
}
/// <summary>
/// Update a Location.
/// </summary>
[HttpPut("Locations")]
public async Task<IActionResult> UpdateLocation(Models.Location Location)
{
if (Location != null)
{
var result = await this.LocationProvider.UpdateLocationAsync(Location);
if (result.IsSuccess)
{
return Ok(result.ErrorMessage);
}
return NotFound();
}
return NotFound();
}
/// <summary>
/// Save a new location.
/// </summary>
[HttpPost("Locations")]
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 NotFound();
}
return CreatedAtRoute("DefaultApi", new { id = Location.Id }, Location);
}
/// <summary>
/// Delete an existing location.
/// </summary>
[HttpDelete("Locations/{id}")]
public async Task<IActionResult> DeleteLocation(string id)
{
var result = await this.LocationProvider.DeleteLocationAsync(id);
if (result.IsSuccess)
{
return Ok(result.ErrorMessage);
}
return NotFound();
}
}
}

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

@ -1,91 +0,0 @@
using DamageAssesment.Api.Locations.Interfaces;
using Microsoft.AspNetCore.Mvc;
namespace DamageAssesment.Api.Locations.Controllers
{
//[Route("api/[controller]")]
[ApiController]
public class RegionsController : ControllerBase
{
private readonly IRegionsProvider regionProvider;
public RegionsController(IRegionsProvider regionProvider)
{
this.regionProvider = regionProvider;
}
/// <summary>
/// Get all regions.
/// </summary>
[HttpGet]
public async Task<ActionResult> GetRegionsAsync()
{
var result = await regionProvider.GetRegionsAsync();
if (result.IsSuccess)
{
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)
{
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]
public async Task<ActionResult> PostRegionAsync(Models.Region region)
{
var result = await this.regionProvider.PostRegionAsync(region);
if (result.IsSuccess)
{
return Ok(result.Region);
}
return BadRequest(result.ErrorMessage);
}
/// <summary>
/// PUT request for updating an existing region.
/// </summary>
[HttpPut]
public async Task<ActionResult> PutRegionAsync(Models.Region region)
{
var result = await this.regionProvider.PutRegionAsync(region);
if (result.IsSuccess)
{
return Ok(result.Region);
}
if (result.ErrorMessage.Equals("Not Found"))
return NotFound(result.ErrorMessage);
return BadRequest(result.ErrorMessage);
}
/// <summary>
/// DELETE request for deleting a region based on ID.
/// </summary>
[HttpDelete("{Id}")]
public async Task<ActionResult> DeleteRegionAsync(string Id)
{
var result = await this.regionProvider.DeleteRegionAsync(Id);
if (result.IsSuccess)
{
return Ok(result.Region);
}
return NotFound();
}
}
}

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

@ -1,46 +0,0 @@
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);
// Add services to the container.
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
//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
builder.Services.AddDbContext<LocationDbContext>(option =>
{
option.UseInMemoryDatabase("Locations");
});
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI(options =>
{
options.SwaggerEndpoint("/swagger/v1/swagger.json", "");
// options.RoutePrefix = ""; // Serve Swagger UI at the root URL
});
}
app.UseAuthorization();
app.MapControllers();
app.Run();

0
DamageAssesmentApi/DamageAssesment.Api.Surveys/DamageAssesment.Api.Survey.csproj → DamageAssesmentApi/DamageAssesment.Api.Surveys/DamageAssesment.Api.Surveys.csproj
View File

2
DamageAssesmentApi/DamageAssesment.sln
View File

@ -23,7 +23,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DamageAssesment.Api.Attachm
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DamageAssesment.Api.Locations.Test", "DamageAssesment.Api.Locations.Test\DamageAssesment.Api.Locations.Test.csproj", "{DA68AE47-6825-41ED-9107-5151822FB083}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DamageAssesment.Api.Survey", "DamageAssesment.Api.Surveys\DamageAssesment.Api.Survey.csproj", "{55481AED-6801-47DB-A176-A6FA92002081}"
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DamageAssesment.Api.Surveys", "DamageAssesment.Api.Surveys\DamageAssesment.Api.Surveys.csproj", "{55481AED-6801-47DB-A176-A6FA92002081}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DamageAssesment.Api.Answers.Test", "DamageAssesment.Api.Answers.Test\DamageAssesment.Api.Answers.Test.csproj", "{594A47AC-DF50-47E5-903D-A856CADDF573}"
EndProject