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

Compare commits

merge into: santhoshsnair:dev
Branches Tags
santhoshsnair:dev
santhoshsnair:Sql-useraccess-Log
santhoshsnair:sql-useraccess-NT
santhoshsnair:Token-Service-Online-and-Offline
santhoshsnair:user-access-sql
santhoshsnair:user-access-dev
santhoshsnair:docker-sql
santhoshsnair:user-access-docker
santhoshsnair:local-docker-sql
santhoshsnair:local-docker
santhoshsnair:docker-Azure
santhoshsnair:Azure-Integration
santhoshsnair:docker-branch
santhoshsnair:6fbe2197-revert-from-docker-sql
santhoshsnair:azure-pipelines
santhoshsnair:Database-Integration
santhoshsnair:User-Role-and-Authorization
santhoshsnair:Doculinks_changes
santhoshsnair:DocumentsAPI
santhoshsnair:azure-pipelinesTest
santhoshsnair:Language-changes
santhoshsnair:server-branch
santhoshsnair:DbContext_changes
santhoshsnair:oldmaster
santhoshsnair:master
...
pull from: santhoshsnair:Doculinks_changes
Branches Tags
santhoshsnair:Sql-useraccess-Log
santhoshsnair:sql-useraccess-NT
santhoshsnair:Token-Service-Online-and-Offline
santhoshsnair:user-access-sql
santhoshsnair:user-access-dev
santhoshsnair:docker-sql
santhoshsnair:dev
santhoshsnair:user-access-docker
santhoshsnair:local-docker-sql
santhoshsnair:local-docker
santhoshsnair:docker-Azure
santhoshsnair:Azure-Integration
santhoshsnair:docker-branch
santhoshsnair:6fbe2197-revert-from-docker-sql
santhoshsnair:azure-pipelines
santhoshsnair:Database-Integration
santhoshsnair:User-Role-and-Authorization
santhoshsnair:Doculinks_changes
santhoshsnair:DocumentsAPI
santhoshsnair:azure-pipelinesTest
santhoshsnair:Language-changes
santhoshsnair:server-branch
santhoshsnair:DbContext_changes
santhoshsnair:oldmaster
santhoshsnair:master

1 Commits
dev ... Doculinks_

Author SHA1 Message Date
uppuv
91765aba63 doculink changes 2023-09-22 11:52:17 -04:00
50 changed files with 1321 additions and 1080 deletions
Show Stats Expand all files Collapse all files

27
DamageAssesmentApi/DamageAssesment.Api.DocuLinks.Test/DamageAssesment - Backup.Api.DocuLinks.Test.csproj Normal file
View File

@ -0,0 +1,27 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net6.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<IsPackable>false</IsPackable>
<IsTestProject>true</IsTestProject>
</PropertyGroup>
<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">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\DamageAssesment.Api.DocuLinks\DamageAssesment.Api.DocuLinks.csproj" />
</ItemGroup>
</Project>

2
DamageAssesmentApi/DamageAssesment.Api.Documents.Test/DamageAssesment.Api.DocuLinks.Test.csproj → DamageAssesmentApi/DamageAssesment.Api.DocuLinks.Test/DamageAssesment.Api.DocuLinks.Test.csproj
View File

@ -21,7 +21,7 @@
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\DamageAssesment.Api.Documents\DamageAssesment.Api.DocuLinks.csproj" />
<ProjectReference Include="..\DamageAssesment.Api.DocuLinks\DamageAssesment.Api.DocuLinks.csproj" />
</ItemGroup>
</Project>

161
DamageAssesmentApi/DamageAssesment.Api.Documents.Test/DocumentsServiceTest.cs → DamageAssesmentApi/DamageAssesment.Api.DocuLinks.Test/DoculinkServiceTest.cs
View File

@ -1,11 +1,11 @@
using DamageAssesment.Api.Documents.Controllers;
using DamageAssesment.Api.Documents.Interfaces;
using DamageAssesment.Api.Documents.Models;
using DamageAssesment.Api.DocuLinks.Controllers;
using DamageAssesment.Api.DocuLinks.Interfaces;
using DamageAssesment.Api.DocuLinks.Models;
using Microsoft.AspNetCore.Mvc;
using Moq;
using Xunit;
namespace DamageAssesment.Api.Documents.Test
namespace DamageAssesment.Api.DocuLinks.Test
{
public class DocumentServiceTest
@ -14,67 +14,66 @@ namespace DamageAssesment.Api.Documents.Test
[Fact(DisplayName = "Get Documents - NoContent Case")]
public async Task GetDocumentsLanguageAsync_ShouldReturnStatusCode204()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getNoContentResponse();
mockDocumentService.Setup(service => service.GetdocumentsByLinkAsync("forms","en")).ReturnsAsync(mockResponse);
mockDocumentService.Setup(service => service.GetdocumentsByLinkAsync("forms","en",null)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (NoContentResult)await DocumentProvider.GetDocumentsAsync("", "");
var DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (NoContentResult)await DocumentProvider.GetDocumentsAsync("", "", null);
Assert.Equal(204, result.StatusCode);
}
[Fact(DisplayName = "Get Documents - NoContent Case")]
[Fact(DisplayName = "Get active Documents - NoContent Case")]
public async Task GetDocumentsLinkTypeAsync_ShouldReturnStatusCode204()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getNoContentResponse();
mockDocumentService.Setup(service => service.GetdocumentsByLinkAsync("forms","en")).ReturnsAsync(mockResponse);
mockDocumentService.Setup(service => service.GetdocumentsByLinkAsync("forms", "en", true)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (NoContentResult)await DocumentProvider.GetDocumentsAsync("", "");
var DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (NoContentResult)await DocumentProvider.GetDocumentsByActiveAsync("", "");
Assert.Equal(204, result.StatusCode);
}
[Fact(DisplayName = "Get Documents - Ok case")]
public async Task GetDocumentsAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getOkResponse();
mockDocumentService.Setup(service => service.GetdocumentsByLinkAsync("forms","en")).ReturnsAsync(mockResponse);
mockDocumentService.Setup(service => service.GetdocumentsByLinkAsync("forms","en", null)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (OkObjectResult)await DocumentProvider.GetDocumentsAsync("forms","en");
var DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (OkObjectResult)await DocumentProvider.GetDocumentsAsync("forms","en", null);
Assert.Equal(200, result.StatusCode);
}
[Fact(DisplayName = "Get Documents - NoContent Case")]
public async Task GetDocumentsAsync_ShouldReturnStatusCode204()
[Fact(DisplayName = "Get active Documents - Ok case")]
public async Task GetActiveDocumentsAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getNoContentResponse();
mockDocumentService.Setup(service => service.GetdocumentsByLinkAsync("forms", "en")).ReturnsAsync(mockResponse);
var mockResponse = await MockData.getOkResponse();
mockDocumentService.Setup(service => service.GetdocumentsByLinkAsync("forms", "en", true)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (NoContentResult)await DocumentProvider.GetDocumentsAsync("forms","en");
var DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (OkObjectResult)await DocumentProvider.GetDocumentsByActiveAsync("forms", "en");
Assert.Equal(204, result.StatusCode);
Assert.Equal(200, result.StatusCode);
}
[Fact(DisplayName = "Get Document by Id - Ok case")]
public async Task GetDocumentAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getOkResponse(1);
mockDocumentService.Setup(service => service.GetDocumentAsync(1,"forms","en")).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (OkObjectResult)await DocumentProvider.GetDocumentAsync(1, "forms", "en");
Assert.Equal(200, result.StatusCode);
@ -83,24 +82,24 @@ namespace DamageAssesment.Api.Documents.Test
[Fact(DisplayName = "Get Document by Id - NotFound case")]
public async Task GetDocumentAsync_ShouldReturnStatusCode404()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getNotFoundResponse();
mockDocumentService.Setup(service => service.GetDocumentAsync(99, "forms", "en")).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (NotFoundResult)await DocumentProvider.GetDocumentAsync(99, "forms", "en");
Assert.Equal(404, result.StatusCode);
}
[Fact(DisplayName = "Post Document - Ok case")]
public async Task PostDocumentAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getOkResponse(1);
var mockInputDocument = await MockData.getInputDocumentData();
var DocumentResponse = await MockData.GetDocumentsInfo(0);
var DocumentResponse = await MockData.GetDocuLinksInfo(0);
mockDocumentService.Setup(service => service.PostDocumentAsync(mockInputDocument)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (NoContentResult)await DocumentProvider.CreateDocument(DocumentResponse);
Assert.Equal(204, result.StatusCode);
@ -109,13 +108,13 @@ namespace DamageAssesment.Api.Documents.Test
[Fact(DisplayName = "Post Document - BadRequest case")]
public async Task PostDocumentAsync_ShouldReturnStatusCode400()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockInputDocument = await MockData.getInputDocumentData();
var mockResponse = await MockData.getBadRequestResponse();
DocumentInfo documentInfo = null;
ReqDoculink documentInfo = null;
mockDocumentService.Setup(service => service.PostDocumentAsync(mockInputDocument)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (BadRequestObjectResult)await DocumentProvider.CreateDocument(documentInfo);
Assert.Equal(400, result.StatusCode);
@ -124,13 +123,13 @@ namespace DamageAssesment.Api.Documents.Test
[Fact(DisplayName = "Put Document - Ok case")]
public async Task PutDocumentAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getOkResponse(1);
var mockInputDocument = await MockData.getInputDocumentData();
var DocumentResponse = await MockData.GetDocumentsInfo(1);
var DocumentResponse = await MockData.GetDocuLinksInfo(1);
mockDocumentService.Setup(service => service.UpdateDocumentAsync(1,mockInputDocument)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (NotFoundResult)await DocumentProvider.UpdateDocument(1,DocumentResponse);
Assert.Equal(404, result.StatusCode);
@ -139,12 +138,12 @@ namespace DamageAssesment.Api.Documents.Test
[Fact(DisplayName = "Put Document - BadRequest case")]
public async Task PutDocumentAsync_ShouldReturnStatusCode400()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await MockData.getBadRequestResponse();
var mockInputDocument = await MockData.getInputDocumentData();
mockDocumentService.Setup(service => service.UpdateDocumentAsync(99,mockInputDocument)).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (BadRequestObjectResult)await DocumentProvider.UpdateDocument(99,null);
Assert.Equal(400, result.StatusCode);
}
@ -152,11 +151,11 @@ namespace DamageAssesment.Api.Documents.Test
[Fact(DisplayName = "Delete Document - Ok case")]
public async Task DeleteDocumentAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
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 DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (OkObjectResult)await DocumentProvider.DeleteDocument(1);
Assert.Equal(200, result.StatusCode);
@ -164,11 +163,11 @@ namespace DamageAssesment.Api.Documents.Test
[Fact(DisplayName = "Delete Document - NotFound case")]
public async Task DeleteDocumentAsync_ShouldReturnStatusCode404()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
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 DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (NotFoundResult)await DocumentProvider.DeleteDocument(1);
Assert.Equal(404, result.StatusCode);
}
@ -180,12 +179,12 @@ namespace DamageAssesment.Api.Documents.Test
[Fact(DisplayName = "Get Link types - Ok case")]
public async Task GetDocumentCategoriesAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
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();
mockDocumentService.Setup(service => service.GetLinkTypesAsync("en")).ReturnsAsync(mockResponse);
var DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (OkObjectResult)await DocumentProvider.GetLinkTypesAsync("en");
Assert.Equal(200, result.StatusCode);
}
@ -193,13 +192,13 @@ namespace DamageAssesment.Api.Documents.Test
[Fact(DisplayName = "Get Link types - NoContent Case")]
public async Task GetDocumentCategoriesAsync_ShouldReturnStatusCode204()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await LinkTypeMockData.getNoContentResponse();
mockDocumentService.Setup(service => service.GetLinkTypesAsync()).ReturnsAsync(mockResponse);
mockDocumentService.Setup(service => service.GetLinkTypesAsync("en")).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (NoContentResult)await DocumentProvider.GetLinkTypesAsync();
var DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (NoContentResult)await DocumentProvider.GetLinkTypesAsync("en");
Assert.Equal(204, result.StatusCode);
}
@ -207,12 +206,12 @@ namespace DamageAssesment.Api.Documents.Test
[Fact(DisplayName = "Get Link Type by Id - Ok case")]
public async Task GetDocumentcategoryAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
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);
mockDocumentService.Setup(service => service.GetLinkTypeAsync(1,"en")).ReturnsAsync(mockResponse);
var DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (OkObjectResult)await DocumentProvider.GetLinkTypeAsync(1, "en");
Assert.Equal(200, result.StatusCode);
}
@ -220,25 +219,25 @@ namespace DamageAssesment.Api.Documents.Test
[Fact(DisplayName = "Get Link Type by Id - NotFound case")]
public async Task GetDocumentcategoryAsync_ShouldReturnStatusCode404()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
var mockUploadService = new Mock<IUploadService>();
var mockResponse = await LinkTypeMockData.getNotFoundResponse();
mockDocumentService.Setup(service => service.GetLinkTypeAsync(99)).ReturnsAsync(mockResponse);
mockDocumentService.Setup(service => service.GetLinkTypeAsync(99, "en")).ReturnsAsync(mockResponse);
var DocumentProvider = new DocumentsController(mockDocumentService.Object, mockUploadService.Object);
var result = (NotFoundResult)await DocumentProvider.GetLinkTypeAsync(99);
var DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (NotFoundResult)await DocumentProvider.GetLinkTypeAsync(99, "en");
Assert.Equal(404, result.StatusCode);
}
[Fact(DisplayName = "Post Link Type - Ok case")]
public async Task PostDocumentcategoryAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
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 DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (OkObjectResult)await DocumentProvider.CreateLinkType(mockInputDocument);
Assert.Equal(200, result.StatusCode);
@ -247,12 +246,12 @@ namespace DamageAssesment.Api.Documents.Test
[Fact(DisplayName = "Post Link Type - BadRequest case")]
public async Task PostDocumentcategoryAsync_ShouldReturnStatusCode400()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
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 DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (BadRequestObjectResult)await DocumentProvider.CreateLinkType(mockInputDocument);
Assert.Equal(400, result.StatusCode);
@ -261,13 +260,13 @@ namespace DamageAssesment.Api.Documents.Test
[Fact(DisplayName = "Put Document - Ok case")]
public async Task PutDocumentcategoryAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
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);
mockDocumentService.Setup(service => service.UpdateLinkTypeAsync(1,mockInputDocument)).ReturnsAsync(mockResponse);
var DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (OkObjectResult)await DocumentProvider.UpdateLinkType(1,mockInputDocument);
Assert.Equal(200, result.StatusCode);
}
@ -275,13 +274,13 @@ namespace DamageAssesment.Api.Documents.Test
[Fact(DisplayName = "Put Document - NotFound case")]
public async Task PutDocumentcategoryAsync_ShouldReturnStatusCode404()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
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);
mockDocumentService.Setup(service => service.UpdateLinkTypeAsync(99,mockInputDocument)).ReturnsAsync(mockResponse);
var DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (NotFoundObjectResult)await DocumentProvider.UpdateLinkType(99,mockInputDocument);
Assert.Equal(404, result.StatusCode);
}
@ -289,13 +288,13 @@ namespace DamageAssesment.Api.Documents.Test
[Fact(DisplayName = "Put Document - BadRequest case")]
public async Task PutDocumentcategoryAsync_ShouldReturnStatusCode400()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
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);
mockDocumentService.Setup(service => service.UpdateLinkTypeAsync(1,mockInputDocument)).ReturnsAsync(mockResponse);
var DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (BadRequestObjectResult)await DocumentProvider.UpdateLinkType(1, mockInputDocument);
Assert.Equal(400, result.StatusCode);
}
@ -303,12 +302,12 @@ namespace DamageAssesment.Api.Documents.Test
[Fact(DisplayName = "Delete Document - Ok case")]
public async Task DeleteDocumentcategoryAsync_ShouldReturnStatusCode200()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
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 DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (OkObjectResult)await DocumentProvider.DeleteLinkType(1);
Assert.Equal(200, result.StatusCode);
@ -316,12 +315,12 @@ namespace DamageAssesment.Api.Documents.Test
[Fact(DisplayName = "Delete Document - NotFound case")]
public async Task DeleteDocumentcategoryAsync_ShouldReturnStatusCode404()
{
var mockDocumentService = new Mock<IDocumentsProvider>();
var mockDocumentService = new Mock<IDoculinkProvider>();
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 DocumentProvider = new DoculinkController(mockDocumentService.Object, mockUploadService.Object);
var result = (NotFoundResult)await DocumentProvider.DeleteLinkType(99);
Assert.Equal(404, result.StatusCode);

71
DamageAssesmentApi/DamageAssesment.Api.DocuLinks.Test/LinkTypeMockData.cs Normal file
View File

@ -0,0 +1,71 @@
using DamageAssesment.Api.DocuLinks.Db;
using DamageAssesment.Api.DocuLinks.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Mail;
using System.Text;
using System.Threading.Tasks;
namespace DamageAssesment.Api.DocuLinks.Test
{
public class LinkTypeMockData
{
public static async Task<(bool, List<DocuLinks.Models.ResLinkType>, string)> getOkResponse()
{
List<DocuLinks.Models.ResLinkType> list = new List<DocuLinks.Models.ResLinkType>();
Dictionary<string, string> dictdesc = new Dictionary<string, string>();
dictdesc.Add("en", "test"); dictdesc.Add("fr", "tester");
for (int i = 1; i < 4; i++)
{
list.Add(new DocuLinks.Models.ResLinkType()
{
Id = i,
titles= dictdesc,
CustomOrder=i,
IsActive = true
});
}
return (true, list, null);
}
public static async Task<(bool, DocuLinks.Models.ResLinkType, string)> getOkResponse(int Id)
{
var DocuLinks = await getOkResponse();
var Document = DocuLinks.Item2.FirstOrDefault(s => s.Id == Id);
return (true, Document, null);
}
public static async Task<(bool, DocuLinks.Models.ResLinkType, string)> getBadRequestResponse()
{
return (false, null, "Bad Request");
}
public static async Task<(bool, DocuLinks.Models.ResLinkType, string)> getNotFoundResponse()
{
return (false, null, "Not Found");
}
public static async Task<(bool, IEnumerable<DocuLinks.Models.ResLinkType>, string)> getNoContentResponse()
{
IEnumerable<DocuLinks.Models.ResLinkType> list = new List<DocuLinks.Models.ResLinkType>();
return (false, list, null);
}
public static async Task<DocuLinks.Models.LinkType> getInputLinkData(int id)
{
List<Models.LinksTranslation> DocuLinksTranslations = new List<Models.LinksTranslation>();
DocuLinksTranslations.Add(new Models.LinksTranslation()
{
Language = "en",
TypeText = "tel"
});
return new Models.LinkType
{
Id = id,
linksTranslations = DocuLinksTranslations,
CustomOrder=1,
IsActive = true
};
}
}
}

137
DamageAssesmentApi/DamageAssesment.Api.DocuLinks.Test/MockData.cs Normal file
View File

@ -0,0 +1,137 @@
using DamageAssesment.Api.DocuLinks.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Mail;
using System.Text;
using System.Threading.Tasks;
namespace DamageAssesment.Api.DocuLinks.Test
{
public class MockData
{
public static async Task<(bool, List<DocuLinks.Models.ResDoculink>, string)> getOkResponse()
{
List<DocuLinks.Models.ResDoculink> list = new List<DocuLinks.Models.ResDoculink>();
for (int i = 1; i < 4; i++)
{
Dictionary<string, string> dicttitle = new Dictionary<string, string>();
Dictionary<string, string> dictdesc = new Dictionary<string, string>();
dicttitle.Add("en", "test"); dicttitle.Add("fr", "tester");
dictdesc.Add("en", "test"); dictdesc.Add("fr", "tester");
List<DoculinkTranslation> DocuLinksTranslations = new List<DoculinkTranslation>();
DocuLinksTranslations.Add(new DoculinkTranslation()
{
Language = "en",
title = "tel"+i,
description = "Sample"+i
});
List<DoculinkAttachments> doclinksAttachments = new List<DoculinkAttachments>();
doclinksAttachments.Add(new DoculinkAttachments()
{
docName = "",Path="www.google.com",
IsAttachments=false,CustomOrder=1
});
list.Add(new DocuLinks.Models.ResDoculink()
{
Id = i,
linkTypeId = i,
IsActive = true,
titles= dicttitle,
description=dictdesc,
CustomOrder=i,
doclinksAttachments= doclinksAttachments
});
}
return (true, list, null);
}
public static async Task<(bool, DocuLinks.Models.ResDoculink, string)> getOkResponse(int Id)
{
var DocuLinks = await getOkResponse();
var Document = DocuLinks.Item2.FirstOrDefault(s => s.Id == Id);
return (true, Document, null);
}
public static async Task<(bool, DocuLinks.Models.ResDoculink, string)> getBadRequestResponse()
{
return (false, null, "Bad Request");
}
public static async Task<(bool, DocuLinks.Models.ResDoculink, string)> getNotFoundResponse()
{
return (false, null, "Not Found");
}
public static async Task<(bool, IEnumerable<DocuLinks.Models.ResDoculink>, string)> getNoContentResponse()
{
IEnumerable<DocuLinks.Models.ResDoculink> list = new List<DocuLinks.Models.ResDoculink>();
return (false, list, null);
}
public static async Task<DocuLinks.Models.ReqDoculink> GetDocuLinksInfo(int id)
{
List<FileModel> fileModels = new List<FileModel>();
fileModels.Add( new FileModel() { FileName = "Sample", FileContent = "c2FtcGxl", FileExtension = ".txt",IsAttachments=true,CustomOrder=1 });
return new ReqDoculink() { Id=id, linkTypeId = 1, CustomOrder = 1, Files = fileModels };
}
public static async Task<DocuLinks.Models.Doculink> getInputDocumentData()
{
List<DoculinkTranslation> DocuLinksTranslations = new List<DoculinkTranslation>();
DocuLinksTranslations.Add(new DoculinkTranslation()
{
Language = "en",
title = "tel",
description = "Sample"
});
List<DoculinkAttachments> doclinksAttachments = new List<DoculinkAttachments>();
doclinksAttachments.Add(new DoculinkAttachments()
{
docName = "",
Path = "www.google.com",
IsAttachments = false,
CustomOrder = 1
});
return new Models.Doculink
{
Id = 1,
linkTypeId = 1,
IsActive = true,
CustomOrder=1,
documentsTranslations = DocuLinksTranslations,
doclinksAttachments= doclinksAttachments
};
}
public static async Task<List<DocuLinks.Models.Doculink>> getInputDocuLinksData()
{
List<DoculinkTranslation> DocuLinksTranslations = new List<DoculinkTranslation>();
DocuLinksTranslations.Add(new DoculinkTranslation()
{
Language = "en",
title = "tel",
description = "Sample"
});
List<DoculinkAttachments> doclinksAttachments = new List<DoculinkAttachments>();
doclinksAttachments.Add(new DoculinkAttachments()
{
docName = "",
Path = "www.google.com",
IsAttachments = false,
CustomOrder = 1
});
List<DocuLinks.Models.Doculink> DocuLinks = new List<Models.Doculink>();
DocuLinks.Add(new Models.Doculink
{
Id = 1,
linkTypeId = 1,
IsActive = true,
CustomOrder = 1,
documentsTranslations = DocuLinksTranslations,
doclinksAttachments = doclinksAttachments
});
return DocuLinks;
}
}
}

110
DamageAssesmentApi/DamageAssesment.Api.Documents/Controllers/DocumentsController.cs → DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Controllers/DoculinkController.cs
View File

@ -1,19 +1,19 @@
using DamageAssesment.Api.Documents.Db;
using DamageAssesment.Api.Documents.Interfaces;
using DamageAssesment.Api.Documents.Models;
using DamageAssesment.Api.Documents.Providers;
using DamageAssesment.Api.DocuLinks.Db;
using DamageAssesment.Api.DocuLinks.Interfaces;
using DamageAssesment.Api.DocuLinks.Models;
using DamageAssesment.Api.DocuLinks.Providers;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
namespace DamageAssesment.Api.Documents.Controllers
namespace DamageAssesment.Api.DocuLinks.Controllers
{
[ApiController]
public class DocumentsController : ControllerBase
public class DoculinkController : ControllerBase
{
private readonly IDocumentsProvider documentsProvider;
private readonly IDoculinkProvider documentsProvider;
private readonly IUploadService uploadService;
public DocumentsController(IDocumentsProvider documentsProvider,IUploadService uploadService)
public DoculinkController(IDoculinkProvider documentsProvider,IUploadService uploadService)
{
this.documentsProvider = documentsProvider;
@ -21,13 +21,14 @@ namespace DamageAssesment.Api.Documents.Controllers
}
/// <summary>
/// Get all document link type.
/// Get all Doculink type.
/// </summary>
[HttpGet]
[Route("doculinks/types")]
public async Task<IActionResult> GetLinkTypesAsync()
[Route("doculinks/types/{language:alpha}")]
public async Task<IActionResult> GetLinkTypesAsync(string? language)
{
var result = await this.documentsProvider.GetLinkTypesAsync();
var result = await this.documentsProvider.GetLinkTypesAsync(language);
if (result.IsSuccess)
{
return Ok(result.LinkTypes);
@ -35,13 +36,14 @@ namespace DamageAssesment.Api.Documents.Controllers
return NoContent();
}
/// <summary>
/// Get a document link type by id.
/// Get a Doculink type by id.
/// </summary>
[HttpGet]
[Route("doculinks/types/{id}")]
public async Task<IActionResult> GetLinkTypeAsync(int id)
[Route("doculinks/types/{id}/{language:alpha}")]
public async Task<IActionResult> GetLinkTypeAsync(int id,string? language)
{
var result = await this.documentsProvider.GetLinkTypeAsync(id);
var result = await this.documentsProvider.GetLinkTypeAsync(id, language);
if (result.IsSuccess)
{
return Ok(result.LinkType);
@ -49,15 +51,15 @@ namespace DamageAssesment.Api.Documents.Controllers
return NotFound();
}
/// <summary>
/// Update a existing document link type.
/// Update a existing Doculink type.
/// </summary>
[HttpPut]
[Route("doculinks/types")]
public async Task<IActionResult> UpdateLinkType(Models.LinkType linkType)
[Route("doculinks/types/{id}")]
public async Task<IActionResult> UpdateLinkType(int id,Models.LinkType linkType)
{
if (linkType != null)
{
var result = await this.documentsProvider.UpdateLinkTypeAsync(linkType);
var result = await this.documentsProvider.UpdateLinkTypeAsync(id,linkType);
if (result.IsSuccess)
{
return Ok(result.LinkType);
@ -70,7 +72,7 @@ namespace DamageAssesment.Api.Documents.Controllers
return CreatedAtRoute("DefaultApi", new { id = linkType.Id }, linkType);
}
/// <summary>
/// Create a new document link type.
/// Create a new Doculink type.
/// </summary>
[HttpPost]
[Route("doculinks/types")]
@ -88,7 +90,7 @@ namespace DamageAssesment.Api.Documents.Controllers
return CreatedAtRoute("DefaultApi", new { id = linkType.Id }, linkType);
}
/// <summary>
/// Delete a existing document link type by id.
/// Delete a existing Doculink type by id.
/// </summary>
[HttpDelete]
[Route("doculinks/types/{id}")]
@ -101,17 +103,17 @@ namespace DamageAssesment.Api.Documents.Controllers
}
return NotFound();
}
/// <summary>
/// Get all documents.
/// </summary>
///
[Route("doculinks")]
/// <summary>
/// Get all Doculink.
/// </summary>
///
[Route("doculinks")]
[Route("doculinks/{linktype:alpha}")]
[Route("doculinks/{linktype:alpha}/{language:alpha}")]
[HttpGet]
public async Task<IActionResult> GetDocumentsAsync(string? linktype, string? language)
public async Task<IActionResult> GetDocumentsAsync(string? linktype, string? language,bool? isactive)
{
var result = await this.documentsProvider.GetdocumentsByLinkAsync(linktype, language);
var result = await this.documentsProvider.GetdocumentsByLinkAsync(linktype, language, isactive);
if (result.IsSuccess)
{
return Ok(result.documents);
@ -119,24 +121,24 @@ namespace DamageAssesment.Api.Documents.Controllers
return NoContent();
}
/// <summary>
/// Get all documents.
/// Get all active Doculink.
/// </summary>
///
//[Route("doculinks/{language:alpha}")]
//[Route("doculinks")]
//[HttpGet]
//public async Task<IActionResult> GetDocumentsAsync(string? language)
//{
// var result = await this.documentsProvider.GetdocumentsAsync(language);
// if (result.IsSuccess)
// {
// return Ok(result.documents);
// }
// return NoContent();
//}
[Route("doculinks/active")]
[Route("doculinks/active/{linktype:alpha}")]
[Route("doculinks/active/{linktype:alpha}/{language:alpha}")]
[HttpGet]
public async Task<IActionResult> GetDocumentsByActiveAsync(string? linktype, string? language)
{
var result = await this.documentsProvider.GetdocumentsByLinkAsync(linktype, language,true);
if (result.IsSuccess)
{
return Ok(result.documents);
}
return NoContent();
}
/// <summary>
/// Get a document by id.
/// Get a Doculink by id.
/// </summary>
[HttpGet]
[Route("doculinks/{id}")]
@ -152,19 +154,20 @@ namespace DamageAssesment.Api.Documents.Controllers
return NotFound();
}
/// <summary>
/// Upload new document.
/// update existing doclink.
/// </summary>
[HttpPut]
[Route("doculinks/{id}")]
public async Task<IActionResult> UpdateDocument(int id,DocumentInfo documentInfo)
public async Task<IActionResult> UpdateDocument(int id,ReqDoculink documentInfo)
{
if (documentInfo != null)
{
var dbdoc = await this.documentsProvider.GetDocumentByidAsync(id);
if (dbdoc.IsSuccess)
{
Models.Document document = uploadService.UpdateDocuments(dbdoc.Document, documentInfo);
var result = await this.documentsProvider.UpdateDocumentAsync(id,document);
var documents = await this.documentsProvider.GetDocumentCounter();
Models.Doculink DocuLink= uploadService.UpdateDocuments(documents.counter,dbdoc.Document, documentInfo);
var result = await this.documentsProvider.UpdateDocumentAsync(id, DocuLink);
if (result.IsSuccess)
{
return Ok(result.Document);
@ -176,19 +179,19 @@ namespace DamageAssesment.Api.Documents.Controllers
return BadRequest(documentInfo);
}
/// <summary>
/// update existing document.
/// Create new doclink.
/// </summary>
[HttpPost]
[Route("doculinks")]
public async Task<IActionResult> CreateDocument(DocumentInfo documentInfo)
public async Task<IActionResult> CreateDocument(ReqDoculink 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);
Models.Doculink DocuLink= uploadService.UploadDocument(documents.counter, documentInfo);
var result = await this.documentsProvider.PostDocumentAsync(DocuLink);
if (result.IsSuccess)
{
return Ok(result.Document);
@ -203,7 +206,7 @@ namespace DamageAssesment.Api.Documents.Controllers
}
}
/// <summary>
/// Delete document by id.
/// Delete Doculink by id.
/// </summary>
[HttpDelete]
[Route("doculinks/{id}")]
@ -214,7 +217,10 @@ namespace DamageAssesment.Api.Documents.Controllers
if (result.IsSuccess)
{
// deleting file from folder
uploadService.Movefile(result.Document.Path);
foreach (var item in result.Document.doclinksAttachments)
{
uploadService.Movefile(item.Path);
}
return Ok(result.Document);
}
return NotFound();

4
DamageAssesmentApi/DamageAssesment.Api.Documents/DamageAssesment.Api.DocuLinks.csproj → DamageAssesmentApi/DamageAssesment.Api.DocuLinks/DamageAssesment.Api.DocuLinks.csproj
View File

@ -25,8 +25,4 @@
<PackageReference Include="Swashbuckle.AspNetCore" Version="6.2.3" />
</ItemGroup>
<ItemGroup>
<Folder Include="DASA_Documents\" />
</ItemGroup>
</Project>

14
DamageAssesmentApi/DamageAssesment.Api.Documents/Db/Document.cs → DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Db/Doculink.cs
View File

@ -1,23 +1,21 @@
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace DamageAssesment.Api.Documents.Db
namespace DamageAssesment.Api.DocuLinks.Db
{
public class Document
public class Doculink
{
[Key]
public int Id { get; set; }
[ForeignKey("LinkType")]
public int linkTypeId { get; set; }
public LinkType? LinkType { get; set; }
public string docName { get; set; }
public string url { get; set; }
public string Path { get; set; }
public bool IsActive { get; set; }
public bool IsDeleted { get; set; }
public int CustomOrder { get; set; }
//public bool IsAttachments { get; set; }
//public bool IsUrl { get; set; }
public DateTime dateCreated { get; set; }
public DateTime dateUpdated { get; set; }
}
}

18
DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Db/DoculinkAttachments.cs Normal file
View File

@ -0,0 +1,18 @@
using System.ComponentModel.DataAnnotations.Schema;
using System.ComponentModel.DataAnnotations;
namespace DamageAssesment.Api.DocuLinks.Db
{
public class DoculinkAttachments
{
[Key]
public int Id { get; set; }
[ForeignKey("Document")]
public int DocumentId { get; set; }
public string docName { get; set; }
public string Path { get; set; }
public bool IsAttachments { get; set; }
public int CustomOrder { get; set; }
}
}

38
DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Db/DoculinkDbContext.cs Normal file
View File

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

4
DamageAssesmentApi/DamageAssesment.Api.Documents/Db/DocumentsTranslation.cs → DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Db/DoculinkTranslation.cs
View File

@ -1,9 +1,9 @@
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace DamageAssesment.Api.Documents.Db
namespace DamageAssesment.Api.DocuLinks.Db
{
public class DocumentsTranslation
public class DoculinkTranslation
{
[Key]
public int Id { get; set; }

5
DamageAssesmentApi/DamageAssesment.Api.Documents/Db/LinkType.cs → DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Db/LinkType.cs
View File

@ -1,13 +1,12 @@
using System.ComponentModel.DataAnnotations;
namespace DamageAssesment.Api.Documents.Db
namespace DamageAssesment.Api.DocuLinks.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; }
public int CustomOrder { get; set; }
}
}

15
DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Db/LinksTranslation.cs Normal file
View File

@ -0,0 +1,15 @@
using System.ComponentModel.DataAnnotations.Schema;
using System.ComponentModel.DataAnnotations;
namespace DamageAssesment.Api.DocuLinks.Db
{
public class LinksTranslation
{
[Key]
public int Id { get; set; }
[ForeignKey("LinkType")]
public int LinkTypeId { get; set; }
public string TypeText { get; set; }
public string Language { get; set; }
}
}

2
DamageAssesmentApi/DamageAssesment.Api.Documents/Interfaces/IAzureBlobService.cs → DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Interfaces/IAzureBlobService.cs
View File

@ -1,6 +1,6 @@
using Azure.Storage.Blobs.Models;
namespace DamageAssesment.Api.Documents.Interfaces
namespace DamageAssesment.Api.DocuLinks.Interfaces
{
public interface IAzureBlobService
{

18
DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Interfaces/IDoculinkProvider.cs Normal file
View File

@ -0,0 +1,18 @@
using DamageAssesment.Api.DocuLinks.Models;
namespace DamageAssesment.Api.DocuLinks.Interfaces
{
public interface IDoculinkProvider : ILinkTypesProvider
{
Task<(bool IsSuccess, Models.ResDoculink Document, string ErrorMessage)> GetDocumentAsync(int id, string? linktype, string? language);
Task<(bool IsSuccess, Models.Doculink Document, string ErrorMessage)> GetDocumentByidAsync(int id);
// Task<(bool IsSuccess, IEnumerable<Models.ResDoculink> documents, string ErrorMessage)> GetDocumnetsAsync(string? language);
Task<(bool IsSuccess, IEnumerable<Models.ResDoculink> documents, string ErrorMessage)> GetdocumentsByLinkAsync(string? linkType, string? language, bool? isactive);
Task<(bool IsSuccess, Models.ResDoculink Document, string ErrorMessage)> PostDocumentAsync(Models.Doculink Document);
Task<(bool IsSuccess, Models.ResDoculink Document, string ErrorMessage)> UpdateDocumentAsync(int id,Models.Doculink Document);
Task<(bool IsSuccess, Models.ResDoculink Document, string ErrorMessage)> DeleteDocumentAsync(int id);
Task<(bool IsSuccess, int counter, string message)> GetDocumentCounter();
}
}

11
DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Interfaces/ILinkTypeProvider.cs Normal file
View File

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

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

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

10
DamageAssesmentApi/DamageAssesment.Api.Documents/Migrations/20230828165655_InitialDocumentCreate.Designer.cs → DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Migrations/20230828165655_InitialDocumentCreate.Designer.cs generated
View File

@ -1,6 +1,6 @@
// <auto-generated />
using System;
using DamageAssesment.Api.Documents.Db;
using DamageAssesment.Api.DocuLinks.Db;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
@ -9,9 +9,9 @@ using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
#nullable disable
namespace DamageAssesment.Api.Documents.Migrations
namespace DamageAssesment.Api.DocuLinks.Migrations
{
[DbContext(typeof(DocumentDbContext))]
[DbContext(typeof(DoculinkDbContext))]
[Migration("20230828165655_InitialDocumentCreate")]
partial class InitialDocumentCreate
{
@ -25,7 +25,7 @@ namespace DamageAssesment.Api.Documents.Migrations
SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
modelBuilder.Entity("DamageAssesment.Api.Documents.Db.Document", b =>
modelBuilder.Entity("DamageAssesment.Api.DocuLinks.Db.Document", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
@ -70,7 +70,7 @@ namespace DamageAssesment.Api.Documents.Migrations
b.ToTable("Documents");
});
modelBuilder.Entity("DamageAssesment.Api.Documents.Db.LinkType", b =>
modelBuilder.Entity("DamageAssesment.Api.DocuLinks.Db.LinkType", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()

2
DamageAssesmentApi/DamageAssesment.Api.Documents/Migrations/20230828165655_InitialDocumentCreate.cs → DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Migrations/20230828165655_InitialDocumentCreate.cs
View File

@ -3,7 +3,7 @@ using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace DamageAssesment.Api.Documents.Migrations
namespace DamageAssesment.Api.DocuLinks.Migrations
{
/// <inheritdoc />
public partial class InitialDocumentCreate : Migration

12
DamageAssesmentApi/DamageAssesment.Api.Documents/Migrations/20230830200432_DocumentTranslation.Designer.cs → DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Migrations/20230830200432_DocumentTranslation.Designer.cs generated
View File

@ -1,6 +1,6 @@
// <auto-generated />
using System;
using DamageAssesment.Api.Documents.Db;
using DamageAssesment.Api.DocuLinks.Db;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
@ -9,9 +9,9 @@ using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
#nullable disable
namespace DamageAssesment.Api.Documents.Migrations
namespace DamageAssesment.Api.DocuLinks.Migrations
{
[DbContext(typeof(DocumentDbContext))]
[DbContext(typeof(DoculinkDbContext))]
[Migration("20230830200432_DocumentTranslation")]
partial class DocumentTranslation
{
@ -25,7 +25,7 @@ namespace DamageAssesment.Api.Documents.Migrations
SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
modelBuilder.Entity("DamageAssesment.Api.Documents.Db.Document", b =>
modelBuilder.Entity("DamageAssesment.Api.DocuLinks.Db.Document", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
@ -62,7 +62,7 @@ namespace DamageAssesment.Api.Documents.Migrations
b.ToTable("Documents");
});
modelBuilder.Entity("DamageAssesment.Api.Documents.Db.DocumentsTranslation", b =>
modelBuilder.Entity("DamageAssesment.Api.DocuLinks.Db.DocumentsTranslation", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
@ -90,7 +90,7 @@ namespace DamageAssesment.Api.Documents.Migrations
b.ToTable("DocumentsTranslations");
});
modelBuilder.Entity("DamageAssesment.Api.Documents.Db.LinkType", b =>
modelBuilder.Entity("DamageAssesment.Api.DocuLinks.Db.LinkType", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()

2
DamageAssesmentApi/DamageAssesment.Api.Documents/Migrations/20230830200432_DocumentTranslation.cs → DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Migrations/20230830200432_DocumentTranslation.cs
View File

@ -2,7 +2,7 @@
#nullable disable
namespace DamageAssesment.Api.Documents.Migrations
namespace DamageAssesment.Api.DocuLinks.Migrations
{
/// <inheritdoc />
public partial class DocumentTranslation : Migration

12
DamageAssesmentApi/DamageAssesment.Api.Documents/Migrations/DocumentDbContextModelSnapshot.cs → DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Migrations/DocumentDbContextModelSnapshot.cs
View File

@ -1,6 +1,6 @@
// <auto-generated />
using System;
using DamageAssesment.Api.Documents.Db;
using DamageAssesment.Api.DocuLinks.Db;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
@ -8,9 +8,9 @@ using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
#nullable disable
namespace DamageAssesment.Api.Documents.Migrations
namespace DamageAssesment.Api.DocuLinks.Migrations
{
[DbContext(typeof(DocumentDbContext))]
[DbContext(typeof(DoculinkDbContext))]
partial class DocumentDbContextModelSnapshot : ModelSnapshot
{
protected override void BuildModel(ModelBuilder modelBuilder)
@ -22,7 +22,7 @@ namespace DamageAssesment.Api.Documents.Migrations
SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
modelBuilder.Entity("DamageAssesment.Api.Documents.Db.Document", b =>
modelBuilder.Entity("DamageAssesment.Api.DocuLinks.Db.Document", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
@ -59,7 +59,7 @@ namespace DamageAssesment.Api.Documents.Migrations
b.ToTable("Documents");
});
modelBuilder.Entity("DamageAssesment.Api.Documents.Db.DocumentsTranslation", b =>
modelBuilder.Entity("DamageAssesment.Api.DocuLinks.Db.DocumentsTranslation", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
@ -87,7 +87,7 @@ namespace DamageAssesment.Api.Documents.Migrations
b.ToTable("DocumentsTranslations");
});
modelBuilder.Entity("DamageAssesment.Api.Documents.Db.LinkType", b =>
modelBuilder.Entity("DamageAssesment.Api.DocuLinks.Db.LinkType", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()

25
DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Models/Doculink.cs Normal file
View File

@ -0,0 +1,25 @@
using DamageAssesment.Api.DocuLinks.Models;
using System.ComponentModel.DataAnnotations;
namespace DamageAssesment.Api.DocuLinks.Models
{
public class Doculink : BaseDoculink
{
public List<DoculinkTranslation> documentsTranslations { get; set; }
}
public class ResDoculink:BaseDoculink
{
public object titles { get; set; }
public object description { get; set; }
public object linktypes { get; set; }
}
public class BaseDoculink
{
public int Id { get; set; }
public int linkTypeId { get; set; }
public bool IsActive { get; set; }
public bool IsDeleted { get; set; }
public List<DoculinkAttachments> doclinksAttachments { get; set; }
public int CustomOrder { get; set; }
}
}

13
DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Models/DoculinkAttachments.cs Normal file
View File

@ -0,0 +1,13 @@
using System.ComponentModel.DataAnnotations.Schema;
using System.ComponentModel.DataAnnotations;
namespace DamageAssesment.Api.DocuLinks.Models
{
public class DoculinkAttachments
{
public string docName { get; set; }
public string Path { get; set; }
public bool IsAttachments { get; set; }
public int CustomOrder { get; set; }
}
}

4
DamageAssesmentApi/DamageAssesment.Api.Documents/Models/DocumentsTranslation.cs → DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Models/DoculinkTranslation.cs
View File

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

20
DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Models/LinkType.cs Normal file
View File

@ -0,0 +1,20 @@
using System.ComponentModel.DataAnnotations;
namespace DamageAssesment.Api.DocuLinks.Models
{
public class LinkType : BaseLinkType
{
public List<LinksTranslation> linksTranslations { get; set; }
}
public class BaseLinkType
{
public int Id { get; set; }
public bool IsActive { get; set; }
public int CustomOrder { get; set; }
}
public class ResLinkType : BaseLinkType
{
public object titles { get; set; }
}
}

11
DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Models/LinksTranslation.cs Normal file
View File

@ -0,0 +1,11 @@
using System.ComponentModel.DataAnnotations.Schema;
using System.ComponentModel.DataAnnotations;
namespace DamageAssesment.Api.DocuLinks.Models
{
public class LinksTranslation
{
public string TypeText { get; set; }
public string Language { get; set; }
}
}

22
DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Models/ReqDoculink.cs Normal file
View File

@ -0,0 +1,22 @@
using System.ComponentModel.DataAnnotations.Schema;
namespace DamageAssesment.Api.DocuLinks.Models
{
public class ReqDoculink
{
public int Id { get; set; }
public int linkTypeId { get; set; }
public List<DoculinkTranslation> documentsTranslations { get; set; }
public int CustomOrder { get; set; }
public List<FileModel>? Files { get; set; }
}
public class FileModel
{
public string? FileName { get; set; }
public string? FileContent { get; set; }
public string? FileExtension { get; set; }
public int CustomOrder { get; set; }
public string url { get;set; }
public bool IsAttachments { get; set; }
}
}

22
DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Profiles/DoculinkProfile.cs Normal file
View File

@ -0,0 +1,22 @@
using AutoMapper;
namespace DamageAssesment.Api.DocuLinks.Profiles
{
public class DoculinkProfile : AutoMapper.Profile
{
public DoculinkProfile()
{
CreateMap<Db.Doculink, Models.ResDoculink>() ;
CreateMap<Db.Doculink, Models.Doculink>();
CreateMap<Models.Doculink, Db.Doculink>();
CreateMap<Db.LinkType, Models.ResLinkType>();
CreateMap<Models.LinkType, Db.LinkType>();
CreateMap<Db.DoculinkTranslation, Models.DoculinkTranslation>();
CreateMap<Models.DoculinkTranslation, Db.DoculinkTranslation>();
CreateMap<Db.LinksTranslation, Models.LinksTranslation>();
CreateMap<Models.LinksTranslation, Db.LinksTranslation>();
CreateMap<Db.DoculinkAttachments, Models.DoculinkAttachments>();
CreateMap<Models.DoculinkAttachments, Db.DoculinkAttachments>();
}
}
}

10
DamageAssesmentApi/DamageAssesment.Api.Documents/Program.cs → DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Program.cs
View File

@ -1,6 +1,6 @@
using DamageAssesment.Api.Documents.Db;
using DamageAssesment.Api.Documents.Interfaces;
using DamageAssesment.Api.Documents.Providers;
using DamageAssesment.Api.DocuLinks.Db;
using DamageAssesment.Api.DocuLinks.Interfaces;
using DamageAssesment.Api.DocuLinks.Providers;
using Microsoft.EntityFrameworkCore;
using System.Reflection;
@ -19,11 +19,11 @@ builder.Services.AddSwaggerGen(c =>
// 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<IDoculinkProvider, DoculinkProvider>();
builder.Services.AddScoped<IUploadService, UploadService>();
builder.Services.AddScoped<IAzureBlobService, AzureBlobService>();
builder.Services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies()); //4/30
builder.Services.AddDbContext<DocumentDbContext>(option =>
builder.Services.AddDbContext<DoculinkDbContext>(option =>
{
option.UseInMemoryDatabase("DocumentConnection");
});

0
DamageAssesmentApi/DamageAssesment.Api.Documents/Properties/launchSettings.json → DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Properties/launchSettings.json
View File

4
DamageAssesmentApi/DamageAssesment.Api.Documents/Providers/AzureBlobService.cs → DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Providers/AzureBlobService.cs
View File

@ -2,9 +2,9 @@
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;
using Azure.Storage.Blobs.Specialized;
using DamageAssesment.Api.Documents.Interfaces;
using DamageAssesment.Api.DocuLinks.Interfaces;
namespace DamageAssesment.Api.Documents.Providers
namespace DamageAssesment.Api.DocuLinks.Providers
{
public class AzureBlobService: IAzureBlobService
{

531
DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Providers/DoculinkProvider.cs Normal file
View File

@ -0,0 +1,531 @@
using AutoMapper;
using DamageAssesment.Api.DocuLinks.Db;
using DamageAssesment.Api.DocuLinks.Interfaces;
using DamageAssesment.Api.DocuLinks.Models;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using System;
using System.Diagnostics.Eventing.Reader;
using System.Reflection.Metadata;
using System.Xml.Linq;
namespace DamageAssesment.Api.DocuLinks.Providers
{
public class DoculinkProvider : IDoculinkProvider
{
private DoculinkDbContext DocumentDbContext;
private ILogger<DoculinkProvider> logger;
private IUploadService uploadservice;
private IMapper mapper;
public DoculinkProvider(DoculinkDbContext DocumentDbContext, ILogger<DoculinkProvider> 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() { IsActive = true, CustomOrder = 1 });
DocumentDbContext.LinkTypes.Add(new Db.LinkType() { IsActive = true, CustomOrder = 2 });
DocumentDbContext.LinkTypes.Add(new Db.LinkType() { IsActive = true, CustomOrder = 3 });
DocumentDbContext.LinkTypes.Add(new Db.LinkType() { IsActive = true, CustomOrder = 4 });
DocumentDbContext.SaveChanges();
}
if (!DocumentDbContext.LinksTranslations.Any())
{
DocumentDbContext.LinksTranslations.Add(new Db.LinksTranslation() { TypeText = "Forms", Language = "en", LinkTypeId = 1 });
DocumentDbContext.LinksTranslations.Add(new Db.LinksTranslation() { TypeText = "Communiques", Language = "en", LinkTypeId = 2 });
DocumentDbContext.LinksTranslations.Add(new Db.LinksTranslation() { TypeText = "Memos", Language = "en", LinkTypeId = 3 });
DocumentDbContext.LinksTranslations.Add(new Db.LinksTranslation() { TypeText = "Trainings", Language = "en", LinkTypeId = 4 });
DocumentDbContext.LinksTranslations.Add(new Db.LinksTranslation() { TypeText = "Formularios", Language = "es", LinkTypeId = 1 });
DocumentDbContext.LinksTranslations.Add(new Db.LinksTranslation() { TypeText = "Comunicados", Language = "es", LinkTypeId = 2 });
DocumentDbContext.LinksTranslations.Add(new Db.LinksTranslation() { TypeText = "notas", Language = "es", LinkTypeId = 3 });
DocumentDbContext.LinksTranslations.Add(new Db.LinksTranslation() { TypeText = "Entrenamientos", Language = "es", LinkTypeId = 4 });
DocumentDbContext.LinksTranslations.Add(new Db.LinksTranslation() { TypeText = "Formes", Language = "fr", LinkTypeId = 1 });
DocumentDbContext.LinksTranslations.Add(new Db.LinksTranslation() { TypeText = "Communiqués", Language = "fr", LinkTypeId = 2 });
DocumentDbContext.LinksTranslations.Add(new Db.LinksTranslation() { TypeText = "Mémos", Language = "fr", LinkTypeId = 3 });
DocumentDbContext.LinksTranslations.Add(new Db.LinksTranslation() { TypeText = "Formations", Language = "fr", LinkTypeId = 4 });
DocumentDbContext.SaveChanges();
}
if (!DocumentDbContext.Documents.Any())
{
int counter = 0;
for (int i = 1; i <= 4; i++)
{
FileModel fileModel = new FileModel() { url = "www.google"+i+".com", IsAttachments = false, CustomOrder = 1 };
ReqDoculink documentInfo = new ReqDoculink() { linkTypeId = i,CustomOrder=i, Files = new List<FileModel>() { fileModel } };
Db.DoculinkTranslation documents = new Db.DoculinkTranslation { DocumentId = i, title = "Test"+i, description = "ss"+i, Language = "en" };
Models.Doculink document = uploadservice.UploadDocument(counter, documentInfo);
DocumentDbContext.Documents.Add(mapper.Map<Models.Doculink, Db.Doculink>(document));
DocumentDbContext.SaveChanges();
DocumentDbContext.DocumentsTranslations.AddRange(documents);
var dbattachments = mapper.Map<List<Models.DoculinkAttachments>, List<Db.DoculinkAttachments>>(document.doclinksAttachments);
dbattachments.ForEach(a => a.DocumentId = i);
DocumentDbContext.DoclinksAttachments.AddRange(dbattachments);
DocumentDbContext.SaveChanges();
counter++;
}
}
}
public List<Models.DoculinkTranslation> GetDocumentTranslations(int id, string? language)
{
List<Models.DoculinkTranslation> QuestionTranslations;
if (string.IsNullOrEmpty(language))
{
QuestionTranslations = mapper.Map<List<Db.DoculinkTranslation>, List<Models.DoculinkTranslation>>(
DocumentDbContext.DocumentsTranslations.AsNoTracking().Where(a => a.DocumentId == id).ToList());
}
else
{
QuestionTranslations = mapper.Map<List<Db.DoculinkTranslation>, List<Models.DoculinkTranslation>>(
DocumentDbContext.DocumentsTranslations.AsNoTracking().Where(a => a.DocumentId == id && a.Language == language).ToList());
}
return QuestionTranslations;
}
public ResDoculink CreateMultiLanguageObject(List<Models.DoculinkTranslation> questions)
{
ResDoculink MultiLanguage = new ResDoculink();
Dictionary<string, string> dicttitle = new Dictionary<string, string>();
Dictionary<string, string> dictdesc = new Dictionary<string, string>();
foreach (Models.DoculinkTranslation item in questions)
{
dicttitle.Add(item.Language, item.title);
dictdesc.Add(item.Language, item.description);
}
MultiLanguage.titles = dicttitle;
MultiLanguage.description = dictdesc;
return MultiLanguage;
}
public List<Models.LinksTranslation> GetLinkTypeTranslations(int id, string? language)
{
List<Models.LinksTranslation> linksTranslations;
if (string.IsNullOrEmpty(language))
{
linksTranslations = mapper.Map<List<Db.LinksTranslation>, List<Models.LinksTranslation>>(
DocumentDbContext.LinksTranslations.AsNoTracking().Where(a => a.LinkTypeId == id).ToList());
}
else
{
linksTranslations = mapper.Map<List<Db.LinksTranslation>, List<Models.LinksTranslation>>(
DocumentDbContext.LinksTranslations.AsNoTracking().Where(a => a.LinkTypeId == id && a.Language == language).ToList());
}
return linksTranslations;
}
public object CreateMultiLanguageLinkTypeObject(List<Models.LinksTranslation> links)
{
object MultiLanguage = new object();
Dictionary<string, string> dicttitle = new Dictionary<string, string>();
foreach (Models.LinksTranslation item in links)
{
dicttitle.Add(item.Language, item.TypeText);
}
MultiLanguage = dicttitle;
return MultiLanguage;
}
public async Task<(bool IsSuccess, IEnumerable<Models.ResDoculink> documents, string ErrorMessage)> GetdocumentsByLinkAsync(string? linkType, string? language, bool? isactive)
{
try
{
logger?.LogInformation("Query Question");
var documents = new List<Db.Doculink>();
if (String.IsNullOrEmpty(linkType))
documents = await DocumentDbContext.Documents.AsNoTracking().Where(q => (isactive == null || q.IsActive == isactive.Value)).ToListAsync();
else
documents = await DocumentDbContext.Documents.AsNoTracking().Where(q => (isactive == null || q.IsActive == isactive.Value) &&
q.linkTypeId == (DocumentDbContext.LinksTranslations.AsNoTracking().Where(a => a.TypeText.ToLower() == linkType.ToLower()).Select(a => a.Id).FirstOrDefault())).ToListAsync();
if (documents != null)
{
var result = mapper.Map<List<Db.Doculink>, List<Models.ResDoculink>>(documents);
foreach (var item in result)
{
var multilan = CreateMultiLanguageObject(GetDocumentTranslations(item.Id, language));
item.titles = multilan.titles;
item.description = multilan.description;
item.linktypes = CreateMultiLanguageLinkTypeObject(GetLinkTypeTranslations(item.linkTypeId, language));
item.doclinksAttachments = mapper.Map<List<Db.DoculinkAttachments>, List<Models.DoculinkAttachments>>(
DocumentDbContext.DoclinksAttachments.AsNoTracking().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.ResDoculink> documents, string ErrorMessage)> GetDocumnetsAsync(string? language)
//{
// try
// {
// logger?.LogInformation("Query Question");
// var documents = await DocumentDbContext.Documents.Include(a => a.LinkType).AsNoTracking().Where(q => q.IsActive).ToListAsync();
// if (documents != null)
// {
// logger?.LogInformation($"{documents.Count} Document(s) found");
// var result = mapper.Map<List<Db.Document>, List<Models.ResDoculink>>(documents);
// foreach (var item in result)
// {
// var multilan = CreateMultiLanguageObject(GetDocumentTranslations(item.Id, language));
// item.titles = multilan.titles;
// item.description = multilan.description;
// }
// 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.Doculink Document, string ErrorMessage)> GetDocumentByidAsync(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.Doculink, Models.Doculink>(Document);
result.documentsTranslations = mapper.Map<List<Db.DoculinkTranslation>, List<Models.DoculinkTranslation>>(
DocumentDbContext.DocumentsTranslations.Where(a => a.DocumentId == result.Id).ToList());
result.doclinksAttachments = mapper.Map<List<Db.DoculinkAttachments>, List<Models.DoculinkAttachments>>(
DocumentDbContext.DoclinksAttachments.AsNoTracking().Where(a => a.DocumentId == id).ToList());
return (true, result, null);
}
return (false, null, "Not found");
}
catch (Exception ex)
{
logger?.LogError(ex.ToString());
return (false, null, ex.Message);
}
}
//added linktype filter
public async Task<(bool IsSuccess, Models.ResDoculink Document, string ErrorMessage)> GetDocumentAsync(int id, string? linkType, string? language)
{
try
{
logger?.LogInformation("Query LinkType");
//var Document = await DocumentDbContext.Documents.Include(a => a.LinkType).AsNoTracking().FirstOrDefaultAsync(q => q.Id == id && q.IsActive);
var Document = new Db.Doculink();
if (String.IsNullOrEmpty(linkType))
Document = await DocumentDbContext.Documents.AsNoTracking().Where(q => q.IsActive && q.Id == id).FirstOrDefaultAsync();
else
Document = await DocumentDbContext.Documents.AsNoTracking().Where(q => q.IsActive && q.Id == id &&
q.linkTypeId == (DocumentDbContext.LinksTranslations.AsNoTracking().Where(a => a.TypeText.ToLower() == linkType.ToLower()).Select(a => a.Id).FirstOrDefault())).FirstOrDefaultAsync();
if (Document != null)
{
logger?.LogInformation($"{Document} customer(s) found");
var result = mapper.Map<Db.Doculink, Models.ResDoculink>(Document);
var multilan = CreateMultiLanguageObject(GetDocumentTranslations(result.Id, language));
result.linktypes = CreateMultiLanguageLinkTypeObject(GetLinkTypeTranslations(result.linkTypeId, language));
result.titles = multilan.titles;
result.description = multilan.description;
result.doclinksAttachments = mapper.Map<List<Db.DoculinkAttachments>, List<Models.DoculinkAttachments>>(
DocumentDbContext.DoclinksAttachments.AsNoTracking().Where(a => a.DocumentId == 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.ResDoculink Document, string ErrorMessage)> PostDocumentAsync(Models.Doculink Document)
{
try
{
var document = mapper.Map<Models.Doculink, Db.Doculink>(Document);
document.dateCreated = DateTime.Now; document.dateUpdated = DateTime.Now;
DocumentDbContext.Documents.Add(document);
DocumentDbContext.SaveChanges();
var dbtranslation = mapper.Map<List<Models.DoculinkTranslation>, List<Db.DoculinkTranslation>>(Document.documentsTranslations);
dbtranslation.ForEach(i => i.DocumentId = document.Id);
DocumentDbContext.DocumentsTranslations.AddRange(dbtranslation);
var dbattachments = mapper.Map<List<Models.DoculinkAttachments>, List<Db.DoculinkAttachments>>(Document.doclinksAttachments);
dbattachments.ForEach(i => i.DocumentId = document.Id);
DocumentDbContext.DoclinksAttachments.AddRange(dbattachments);
DocumentDbContext.SaveChanges();
var result = mapper.Map<Db.Doculink, Models.ResDoculink>(document);
var multilan = CreateMultiLanguageObject(GetDocumentTranslations(document.Id, ""));
result.linktypes = CreateMultiLanguageLinkTypeObject(GetLinkTypeTranslations(Document.linkTypeId, ""));
result.titles = multilan.titles;
result.description = multilan.description;
result.doclinksAttachments = Document.doclinksAttachments;
return (true, result, null);
}
catch (Exception ex)
{
logger?.LogError(ex.ToString());
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.ResDoculink Document, string ErrorMessage)> UpdateDocumentAsync(int id, Models.Doculink Document)
{
try
{
if (Document != null)
{
var existing = DocumentDbContext.Documents.AsNoTracking().FirstOrDefault(x => x.Id == id);
if (existing != null)
{
Document.Id = existing.Id;
var document = mapper.Map<Models.Doculink, Db.Doculink>(Document);
document.dateUpdated = DateTime.Now;
DocumentDbContext.Documents.Update(document);
DocumentDbContext.SaveChanges();
var oldtranslations = DocumentDbContext.DocumentsTranslations.Where(a => a.DocumentId == id).ToList();
if (oldtranslations != null)
DocumentDbContext.DocumentsTranslations.RemoveRange(oldtranslations);
var oldattachments = DocumentDbContext.DoclinksAttachments.Where(a => a.DocumentId == id).ToList();
if (oldattachments != null)
DocumentDbContext.DoclinksAttachments.RemoveRange(oldattachments);
var dbtranslation = mapper.Map<List<Models.DoculinkTranslation>, List<Db.DoculinkTranslation>>(Document.documentsTranslations);
dbtranslation.ForEach(i => i.DocumentId = Document.Id);
DocumentDbContext.DocumentsTranslations.AddRange(dbtranslation);
var dbattachments = mapper.Map<List<Models.DoculinkAttachments>, List<Db.DoculinkAttachments>>(Document.doclinksAttachments);
dbattachments.ForEach(i => i.DocumentId = document.Id);
DocumentDbContext.DoclinksAttachments.AddRange(dbattachments);
DocumentDbContext.SaveChanges();
var result = mapper.Map<Db.Doculink, Models.ResDoculink>(document);
var multilan = CreateMultiLanguageObject(GetDocumentTranslations(document.Id, ""));
result.linktypes = CreateMultiLanguageLinkTypeObject(GetLinkTypeTranslations(document.linkTypeId, ""));
result.titles = multilan.titles;
result.description = multilan.description;
result.doclinksAttachments = Document.doclinksAttachments;
return (true, result, "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.ResDoculink Document, string ErrorMessage)> DeleteDocumentAsync(int id)
{
try
{
Db.Doculink Document = DocumentDbContext.Documents.AsNoTracking().Where(a => a.Id == id).FirstOrDefault();
if (Document == null)
{
return (false, null, "Not Found");
}
var result = mapper.Map<Db.Doculink, Models.ResDoculink>(Document);
var multilan = CreateMultiLanguageObject(GetDocumentTranslations(Document.Id, ""));
result.titles = multilan.titles;
result.description = multilan.description;
result.linktypes = CreateMultiLanguageLinkTypeObject(GetLinkTypeTranslations(result.linkTypeId, ""));
result.doclinksAttachments = mapper.Map<List<Db.DoculinkAttachments>, List<Models.DoculinkAttachments>>(
DocumentDbContext.DoclinksAttachments.AsNoTracking().Where(a => a.DocumentId == id).ToList());
Document.IsActive = false;
DocumentDbContext.Documents.Update(Document);
DocumentDbContext.SaveChanges();
return (true, result, $"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.DoclinksAttachments.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.ResLinkType> LinkTypes, string ErrorMessage)> GetLinkTypesAsync(string? language)
{
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.ResLinkType>>(LinkType);
foreach (var item in result)
{
item.titles = CreateMultiLanguageLinkTypeObject(GetLinkTypeTranslations(item.Id, language));
}
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.ResLinkType LinkType, string ErrorMessage)> GetLinkTypeAsync(int Id, string? language)
{
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.ResLinkType>(LinkType);
result.titles = CreateMultiLanguageLinkTypeObject(GetLinkTypeTranslations(result.Id, language));
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.ResLinkType 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 dbtranslation = mapper.Map<List<Models.LinksTranslation>, List<Db.LinksTranslation>>(LinkType.linksTranslations);
dbtranslation.ForEach(i => i.LinkTypeId = dbLink.Id);
DocumentDbContext.LinksTranslations.AddRange(dbtranslation);
DocumentDbContext.SaveChanges();
var result = mapper.Map<Db.LinkType, Models.ResLinkType>(dbLink);
result.titles = CreateMultiLanguageLinkTypeObject(GetLinkTypeTranslations(result.Id, ""));
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.ResLinkType LinkType, string ErrorMessage)> UpdateLinkTypeAsync(int id, Models.LinkType LinkType)
{
try
{
if (LinkType != null)
{
var existing = DocumentDbContext.LinkTypes.AsNoTracking().FirstOrDefault(x => x.Id == id);
if (existing != null)
{
var dbLink = mapper.Map<Models.LinkType, Db.LinkType>(LinkType);
DocumentDbContext.LinkTypes.Update(dbLink);
DocumentDbContext.SaveChanges();
var oldtranslations = DocumentDbContext.LinksTranslations.Where(a => a.LinkTypeId == id).ToList();
if (oldtranslations != null)
DocumentDbContext.LinksTranslations.RemoveRange(oldtranslations);
var dbtranslation = mapper.Map<List<Models.LinksTranslation>, List<Db.LinksTranslation>>(LinkType.linksTranslations);
dbtranslation.ForEach(i => i.LinkTypeId = dbLink.Id);
DocumentDbContext.LinksTranslations.AddRange(dbtranslation);
DocumentDbContext.SaveChanges();
var result = mapper.Map<Db.LinkType, Models.ResLinkType>(dbLink);
result.titles = CreateMultiLanguageLinkTypeObject(GetLinkTypeTranslations(result.Id, ""));
return (true, result, "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.ResLinkType 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;
var result = mapper.Map<Db.LinkType, Models.ResLinkType>(LinkType);
result.titles = CreateMultiLanguageLinkTypeObject(GetLinkTypeTranslations(result.Id, ""));
DocumentDbContext.LinkTypes.Update(LinkType);
DocumentDbContext.SaveChanges();
return (true, result, $"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;
}
}
}

142
DamageAssesmentApi/DamageAssesment.Api.DocuLinks/Providers/UploadService.cs Normal file
View File

@ -0,0 +1,142 @@
using AutoMapper;
using Azure;
using DamageAssesment.Api.DocuLinks.Db;
using DamageAssesment.Api.DocuLinks.Interfaces;
using DamageAssesment.Api.DocuLinks.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.DocuLinks.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.Doculink UploadDocument(int counter, ReqDoculink documentInfo)
{
Models.Doculink Documents = new Models.Doculink();
List<Models.DoculinkAttachments> attachments = new List<Models.DoculinkAttachments>();
try
{
string path = "", UserfileName="";
var fullDirectoryPath = Path.Combine(Directory.GetCurrentDirectory(), uploadpath);
if (!Directory.Exists(fullDirectoryPath)) //Create deirectory if does not exist
Directory.CreateDirectory(fullDirectoryPath);
if (documentInfo.Files != null)
{
foreach (var item in documentInfo.Files)
{
counter++;
if (item.IsAttachments)
{
UserfileName = Path.GetFileName(item.FileName);
var fileName = String.Format("Document_{0}{1}", counter, item.FileExtension);
path = Path.Combine(fullDirectoryPath, fileName);
File.WriteAllBytes(path, Convert.FromBase64String(item.FileContent));
}
else
path = item.url;
attachments.Add(new Models.DoculinkAttachments { docName=UserfileName,Path=path,IsAttachments=item.IsAttachments,CustomOrder=item.CustomOrder });
}
}
Documents=new Models.Doculink (){ linkTypeId = documentInfo.linkTypeId,
documentsTranslations = documentInfo.documentsTranslations,doclinksAttachments=attachments,
IsDeleted=false,CustomOrder=documentInfo.CustomOrder, IsActive =true};
return Documents;
}
catch (Exception ex) {
return new Models.Doculink();
}
}
public Models.Doculink UpdateDocuments(int counter, Models.Doculink document, ReqDoculink documentInfo)
{
try
{
foreach (var item in document.doclinksAttachments)
{
Movefile(item.Path);
}
var fullDirectoryPath = Path.Combine(Directory.GetCurrentDirectory(), uploadpath);
if (!Directory.Exists(fullDirectoryPath)) //Create deirectory if does not exist
Directory.CreateDirectory(fullDirectoryPath);
string path = "", UserfileName = "";
List<Models.DoculinkAttachments> attachments = new List<Models.DoculinkAttachments>();
foreach (var item in documentInfo.Files)
{
counter++;
if (item.IsAttachments)
{
UserfileName = Path.GetFileName(item.FileName);
var fileName = String.Format("Document_{0}{1}", counter, item.FileExtension);
path = Path.Combine(fullDirectoryPath, fileName);
File.WriteAllBytes(path, Convert.FromBase64String(item.FileContent));
}
else
path = item.url;
attachments.Add(new Models.DoculinkAttachments { docName = UserfileName, Path = path,IsAttachments=item.IsAttachments,CustomOrder=item.CustomOrder });
}
Models.Doculink Documents = new Models.Doculink()
{
Id = documentInfo.Id,
linkTypeId = documentInfo.linkTypeId,
documentsTranslations=documentInfo.documentsTranslations,
IsActive = true,
IsDeleted=false,
CustomOrder = documentInfo.CustomOrder,
doclinksAttachments = attachments
};
return Documents;
}
catch (Exception ex) {
return new Models.Doculink();
}
}
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);
}
}
}
}
}

0
DamageAssesmentApi/DamageAssesment.Api.Documents/appsettings.Development.json → DamageAssesmentApi/DamageAssesment.Api.DocuLinks/appsettings.Development.json
View File

0
DamageAssesmentApi/DamageAssesment.Api.Documents/appsettings.json → DamageAssesmentApi/DamageAssesment.Api.DocuLinks/appsettings.json
View File

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

@ -1,61 +0,0 @@
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
};
}
}
}

122
DamageAssesmentApi/DamageAssesment.Api.Documents.Test/MockData.cs
View File

@ -1,122 +0,0 @@
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.MultiLanDocument>, string)> getOkResponse()
{
List<Documents.Models.MultiLanDocument> list = new List<Documents.Models.MultiLanDocument>();
for (int i = 1; i < 4; i++)
{
Dictionary<string, string> dicttitle = new Dictionary<string, string>();
Dictionary<string, string> dictdesc = new Dictionary<string, string>();
dicttitle.Add("en", "test"); dicttitle.Add("fr", "tester");
dictdesc.Add("en", "test"); dictdesc.Add("fr", "tester");
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.MultiLanDocument()
{
Id = i,
linkTypeId = i,
docName = "sample"+i,
url = "testurl" + i,
Path = "testpath" + i,
IsActive = true,
titles= dicttitle,
description=dictdesc,
dateCreated = DateTime.Now,
dateUpdated = DateTime.Now
});
}
return (true, list, null);
}
public static async Task<(bool, Documents.Models.MultiLanDocument, 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.MultiLanDocument, string)> getBadRequestResponse()
{
return (false, null, "Bad Request");
}
public static async Task<(bool, Documents.Models.MultiLanDocument, string)> getNotFoundResponse()
{
return (false, null, "Not Found");
}
public static async Task<(bool, IEnumerable<Documents.Models.MultiLanDocument>, string)> getNoContentResponse()
{
IEnumerable<Documents.Models.MultiLanDocument> list = new List<Documents.Models.MultiLanDocument>();
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;
}
}
}

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

@ -1 +0,0 @@
sample

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

@ -1,30 +0,0 @@
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();
}
}
}

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

@ -1,11 +0,0 @@
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);
}
}

18
DamageAssesmentApi/DamageAssesment.Api.Documents/Interfaces/IDocumentsProvider.cs
View File

@ -1,18 +0,0 @@
using DamageAssesment.Api.Documents.Models;
namespace DamageAssesment.Api.Documents.Interfaces
{
public interface IDocumentsProvider : ILinkTypesProvider
{
Task<(bool IsSuccess, Models.MultiLanDocument Document, string ErrorMessage)> GetDocumentAsync(int id, string? linktype, string? language);
Task<(bool IsSuccess, Models.Document Document, string ErrorMessage)> GetDocumentByidAsync(int id);
// Task<(bool IsSuccess, IEnumerable<Models.MultiLanDocument> documents, string ErrorMessage)> GetDocumnetsAsync(string? language);
Task<(bool IsSuccess, IEnumerable<Models.MultiLanDocument> documents, string ErrorMessage)> GetdocumentsByLinkAsync(string? linkType, string? language);
Task<(bool IsSuccess, Models.MultiLanDocument Document, string ErrorMessage)> PostDocumentAsync(Models.Document Document);
Task<(bool IsSuccess, Models.MultiLanDocument Document, string ErrorMessage)> UpdateDocumentAsync(int id,Models.Document Document);
Task<(bool IsSuccess, Models.MultiLanDocument Document, string ErrorMessage)> DeleteDocumentAsync(int id);
Task<(bool IsSuccess, int counter, string message)> GetDocumentCounter();
}
}

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

@ -1,12 +0,0 @@
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);
}
}

28
DamageAssesmentApi/DamageAssesment.Api.Documents/Models/Document.cs
View File

@ -1,28 +0,0 @@
using System.ComponentModel.DataAnnotations;
namespace DamageAssesment.Api.Documents.Models
{
public class Document : BaseDocument
{
public List<DocumentsTranslation> documentsTranslations { get; set; }
}
public class MultiLanDocument:BaseDocument
{
public object titles { get; set; }
public object description { get; set; }
public string LinkType { get; set; }
}
public class BaseDocument
{
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; }
}
}

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

@ -1,19 +0,0 @@
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/LinkType.cs
View File

@ -1,12 +0,0 @@
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; }
}
}

19
DamageAssesmentApi/DamageAssesment.Api.Documents/Profiles/DocumentProfile.cs
View File

@ -1,19 +0,0 @@
using AutoMapper;
namespace DamageAssesment.Api.Documents.Profiles
{
public class DocumentProfile : AutoMapper.Profile
{
public DocumentProfile()
{
CreateMap<Db.Document, Models.MultiLanDocument>().ForMember(dest => dest.LinkType,
opt => opt.MapFrom(src => src.LinkType.TypeText)); ;
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>();
}
}
}

434
DamageAssesmentApi/DamageAssesment.Api.Documents/Providers/DocumentsProvider.cs
View File

@ -1,434 +0,0 @@
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;
using System.Reflection.Metadata;
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 List<Models.DocumentsTranslation> GetDocumentTranslations(int id, string? language)
{
List<Models.DocumentsTranslation> QuestionTranslations;
if (string.IsNullOrEmpty(language))
{
QuestionTranslations = mapper.Map<List<Db.DocumentsTranslation>, List<Models.DocumentsTranslation>>(
DocumentDbContext.DocumentsTranslations.AsNoTracking().Where(a => a.DocumentId == id).ToList());
}
else
{
QuestionTranslations = mapper.Map<List<Db.DocumentsTranslation>, List<Models.DocumentsTranslation>>(
DocumentDbContext.DocumentsTranslations.AsNoTracking().Where(a => a.DocumentId == id && a.Language == language).ToList());
}
return QuestionTranslations;
}
public MultiLanDocument CreateMultiLanguageObject(List<Models.DocumentsTranslation> questions)
{
MultiLanDocument MultiLanguage = new MultiLanDocument();
Dictionary<string, string> dicttitle = new Dictionary<string, string>();
Dictionary<string, string> dictdesc = new Dictionary<string, string>();
foreach (Models.DocumentsTranslation item in questions)
{
dicttitle.Add(item.Language, item.title);
dictdesc.Add(item.Language, item.description);
}
MultiLanguage.titles = dicttitle;
MultiLanguage.description = dictdesc;
return MultiLanguage;
}
public async Task<(bool IsSuccess, IEnumerable<Models.MultiLanDocument> documents, string ErrorMessage)> GetdocumentsByLinkAsync(string? linkType, string? language)
{
try
{
logger?.LogInformation("Query Question");
var documents=new List<Db.Document>();
if(String.IsNullOrEmpty(linkType))
documents = await DocumentDbContext.Documents.Include(a=>a.LinkType).AsNoTracking().Where(q => q.IsActive).ToListAsync();
else
documents = await DocumentDbContext.Documents.Include(a => a.LinkType).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<List<Db.Document>, List<Models.MultiLanDocument>>(documents);
foreach (var item in result)
{
var multilan = CreateMultiLanguageObject(GetDocumentTranslations(item.Id, language));
item.titles = multilan.titles;
item.description = multilan.description;
}
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.MultiLanDocument> documents, string ErrorMessage)> GetDocumnetsAsync(string? language)
//{
// try
// {
// logger?.LogInformation("Query Question");
// var documents = await DocumentDbContext.Documents.Include(a => a.LinkType).AsNoTracking().Where(q => q.IsActive).ToListAsync();
// if (documents != null)
// {
// logger?.LogInformation($"{documents.Count} Document(s) found");
// var result = mapper.Map<List<Db.Document>, List<Models.MultiLanDocument>>(documents);
// foreach (var item in result)
// {
// var multilan = CreateMultiLanguageObject(GetDocumentTranslations(item.Id, language));
// item.titles = multilan.titles;
// item.description = multilan.description;
// }
// 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)> GetDocumentByidAsync(int id)
{
try
{
logger?.LogInformation("Query LinkType");
var Document = await DocumentDbContext.Documents.Include(a => a.LinkType).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);
}
}
//added linktype filter
public async Task<(bool IsSuccess, Models.MultiLanDocument Document, string ErrorMessage)> GetDocumentAsync(int id, string? linkType, string? language)
{
try
{
logger?.LogInformation("Query LinkType");
//var Document = await DocumentDbContext.Documents.Include(a => a.LinkType).AsNoTracking().FirstOrDefaultAsync(q => q.Id == id && q.IsActive);
var Document = new Db.Document();
if (String.IsNullOrEmpty(linkType))
Document = await DocumentDbContext.Documents.Include(a => a.LinkType).AsNoTracking().Where(q => q.IsActive&&q.Id==id).FirstOrDefaultAsync();
else
Document = await DocumentDbContext.Documents.Include(a => a.LinkType).AsNoTracking().Where(q => q.IsActive && q.Id == id &&
q.linkTypeId == (DocumentDbContext.LinkTypes.AsNoTracking().Where(a => a.TypeText.ToLower() == linkType.ToLower()).Select(a => a.Id).FirstOrDefault())).FirstOrDefaultAsync();
if (Document != null)
{
logger?.LogInformation($"{Document} customer(s) found");
var result = mapper.Map<Db.Document, Models.MultiLanDocument>(Document);
var multilan = CreateMultiLanguageObject(GetDocumentTranslations(result.Id, language));
result.titles = multilan.titles;
result.description = multilan.description;
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.MultiLanDocument 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();
var result = mapper.Map<Db.Document, Models.MultiLanDocument>(document);
var multilan = CreateMultiLanguageObject(GetDocumentTranslations(document.Id, ""));
result.titles = multilan.titles;
result.description = multilan.description;
return (true, result, null);
}
catch (Exception ex)
{
logger?.LogError(ex.ToString());
return (false, null, ex.Message);
}
}
public async Task<(bool IsSuccess, Models.MultiLanDocument Document, string ErrorMessage)> UpdateDocumentAsync(int id,Models.Document Document)
{
try
{
if (Document != null)
{
var existing = DocumentDbContext.Documents.AsNoTracking().FirstOrDefault(x => x.Id == id);
if (existing != null)
{
Document.Id = existing.Id;
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);
DocumentDbContext.DocumentsTranslations.AddRange(dbtranslation);
DocumentDbContext.SaveChanges();
var result = mapper.Map<Db.Document, Models.MultiLanDocument>(document);
var multilan = CreateMultiLanguageObject(GetDocumentTranslations(document.Id, ""));
result.titles = multilan.titles;
result.description = multilan.description;
return (true, result, "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.MultiLanDocument Document, string ErrorMessage)> DeleteDocumentAsync(int id)
{
try
{
Db.Document Document = DocumentDbContext.Documents.Include(a => a.LinkType).AsNoTracking().Where(a => a.Id == id).FirstOrDefault();
if (Document == null)
{
return (false, null, "Not Found");
}
var result = mapper.Map<Db.Document, Models.MultiLanDocument>(Document);
var multilan = CreateMultiLanguageObject(GetDocumentTranslations(Document.Id, ""));
result.titles = multilan.titles;
result.description = multilan.description;
Document.IsActive = false;
DocumentDbContext.Documents.Update(Document);
DocumentDbContext.SaveChanges();
return (true, result, $"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
View File

@ -1,123 +0,0 @@
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);
}
}
}
}
}

20
DamageAssesmentApi/DamageAssesment.sln
View File

@ -37,9 +37,9 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DamageAssesment.Api.Employe
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DamageAssesment.Api.Employees.Test", "DamageAssesment.Api.Employees.Test\DamageAssesment.Api.Employees.Test.csproj", "{D6BF9AE9-72FA-4726-A326-35A35D27FFB8}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DamageAssesment.Api.DocuLinks", "DamageAssesment.Api.Documents\DamageAssesment.Api.DocuLinks.csproj", "{977C1053-9D63-4153-B61B-C3D2F1010F9F}"
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DamageAssesment.Api.DocuLinks", "DamageAssesment.Api.DocuLinks\DamageAssesment.Api.DocuLinks.csproj", "{D356A3C9-B275-4B1A-9B1B-F48600E85E4F}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DamageAssesment.Api.DocuLinks.Test", "DamageAssesment.Api.Documents.Test\DamageAssesment.Api.DocuLinks.Test.csproj", "{884BA4AC-9170-49B1-BD6B-850B350C95C0}"
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DamageAssesment.Api.DocuLinks.Test", "DamageAssesment.Api.DocuLinks.Test\DamageAssesment.Api.DocuLinks.Test.csproj", "{A7F17ED7-71D2-4FD0-87E5-D83415078FC0}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
@ -103,14 +103,14 @@ Global
{D6BF9AE9-72FA-4726-A326-35A35D27FFB8}.Debug|Any CPU.Build.0 = Debug|Any CPU
{D6BF9AE9-72FA-4726-A326-35A35D27FFB8}.Release|Any CPU.ActiveCfg = Release|Any CPU
{D6BF9AE9-72FA-4726-A326-35A35D27FFB8}.Release|Any CPU.Build.0 = Release|Any CPU
{977C1053-9D63-4153-B61B-C3D2F1010F9F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{977C1053-9D63-4153-B61B-C3D2F1010F9F}.Debug|Any CPU.Build.0 = Debug|Any CPU
{977C1053-9D63-4153-B61B-C3D2F1010F9F}.Release|Any CPU.ActiveCfg = Release|Any CPU
{977C1053-9D63-4153-B61B-C3D2F1010F9F}.Release|Any CPU.Build.0 = Release|Any CPU
{884BA4AC-9170-49B1-BD6B-850B350C95C0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{884BA4AC-9170-49B1-BD6B-850B350C95C0}.Debug|Any CPU.Build.0 = Debug|Any CPU
{884BA4AC-9170-49B1-BD6B-850B350C95C0}.Release|Any CPU.ActiveCfg = Release|Any CPU
{884BA4AC-9170-49B1-BD6B-850B350C95C0}.Release|Any CPU.Build.0 = Release|Any CPU
{D356A3C9-B275-4B1A-9B1B-F48600E85E4F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{D356A3C9-B275-4B1A-9B1B-F48600E85E4F}.Debug|Any CPU.Build.0 = Debug|Any CPU
{D356A3C9-B275-4B1A-9B1B-F48600E85E4F}.Release|Any CPU.ActiveCfg = Release|Any CPU
{D356A3C9-B275-4B1A-9B1B-F48600E85E4F}.Release|Any CPU.Build.0 = Release|Any CPU
{A7F17ED7-71D2-4FD0-87E5-D83415078FC0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{A7F17ED7-71D2-4FD0-87E5-D83415078FC0}.Debug|Any CPU.Build.0 = Debug|Any CPU
{A7F17ED7-71D2-4FD0-87E5-D83415078FC0}.Release|Any CPU.ActiveCfg = Release|Any CPU
{A7F17ED7-71D2-4FD0-87E5-D83415078FC0}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE