admin/marco.pms.api
1
0
Fork 0
Code Issues Pull Requests 3 Actions Packages Projects Releases Wiki Activity

added an API to get list of contacts by bucket id and added project- contact mapping table

Browse Source
This commit is contained in:
ashutosh.nehete 2025-05-17 11:52:45 +05:30
parent 56e444f87f
commit 4eeeec5dbe
7 changed files with 3141 additions and 390 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Marco.Pms.DataAccess/Data/ApplicationDbContext.cs
View File

@ -78,6 +78,7 @@ namespace Marco.Pms.DataAccess.Data
public DbSet<ContactTagMapping> ContactTagMappings { get; set; }
public DbSet<EmployeeBucketMapping> EmployeeBucketMappings { get; set; }
public DbSet<ContactBucketMapping> ContactBucketMappings { get; set; }
public DbSet<ContactProjectMapping> ContactProjectMappings { get; set; }
public DbSet<DirectoryUpdateLog> DirectoryUpdateLogs { get; set; }
public DbSet<ContactProjectMapping> ContactProjectMappings { get; set; }

3040
Marco.Pms.DataAccess/Migrations/20250517050718_Added_ContactProjectMapping_Table.Designer.cs generated Normal file
View File

File diff suppressed because it is too large Load Diff

81
Marco.Pms.DataAccess/Migrations/20250517050718_Added_ContactProjectMapping_Table.cs Normal file
View File

@ -0,0 +1,81 @@
using System;
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace Marco.Pms.DataAccess.Migrations
{
/// <inheritdoc />
public partial class Added_ContactProjectMapping_Table : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropColumn(
name: "ProjectId",
table: "Contacts");
migrationBuilder.CreateTable(
name: "ContactProjectMappings",
columns: table => new
{
Id = table.Column<Guid>(type: "char(36)", nullable: false, collation: "ascii_general_ci"),
ProjectId = table.Column<Guid>(type: "char(36)", nullable: false, collation: "ascii_general_ci"),
ContactId = table.Column<Guid>(type: "char(36)", nullable: false, collation: "ascii_general_ci"),
TenantId = table.Column<Guid>(type: "char(36)", nullable: false, collation: "ascii_general_ci")
},
constraints: table =>
{
table.PrimaryKey("PK_ContactProjectMappings", x => x.Id);
table.ForeignKey(
name: "FK_ContactProjectMappings_Contacts_ContactId",
column: x => x.ContactId,
principalTable: "Contacts",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
table.ForeignKey(
name: "FK_ContactProjectMappings_Projects_ProjectId",
column: x => x.ProjectId,
principalTable: "Projects",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
table.ForeignKey(
name: "FK_ContactProjectMappings_Tenants_TenantId",
column: x => x.TenantId,
principalTable: "Tenants",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
})
.Annotation("MySql:CharSet", "utf8mb4");
migrationBuilder.CreateIndex(
name: "IX_ContactProjectMappings_ContactId",
table: "ContactProjectMappings",
column: "ContactId");
migrationBuilder.CreateIndex(
name: "IX_ContactProjectMappings_ProjectId",
table: "ContactProjectMappings",
column: "ProjectId");
migrationBuilder.CreateIndex(
name: "IX_ContactProjectMappings_TenantId",
table: "ContactProjectMappings",
column: "TenantId");
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropTable(
name: "ContactProjectMappings");
migrationBuilder.AddColumn<Guid>(
name: "ProjectId",
table: "Contacts",
type: "char(36)",
nullable: true,
collation: "ascii_general_ci");
}
}
}

2
Marco.Pms.Model/Directory/ContactProjectMapping.cs
View File

@ -17,4 +17,4 @@ namespace Marco.Pms.Model.Directory
[ForeignKey("ContactId")]
public Contact? Contact { get; set; }
}
}
}

1
Marco.Pms.Model/Mapper/DirectoryMapper.cs
View File

@ -29,7 +29,6 @@ namespace Marco.Pms.Model.Mapper
return new Contact
{
Id = updateContactDto.Id,
ProjectId = updateContactDto.ProjectId,
Name = updateContactDto.Name ?? string.Empty,
ContactCategoryId = updateContactDto.ContactCategoryId,
CreatedAt = contact.CreatedAt,

18
Marco.Pms.Services/Controllers/DirectoryController.cs
View File

@ -58,6 +58,24 @@ namespace Marco.Pms.Services.Controllers
}
}
[HttpGet("contact-bucket/{bucketId}")]
public async Task<IActionResult> GetContactsListByBucketId(Guid bucketId)
{
var response = await _directoryHelper.GetContactsListByBucketId(bucketId);
if (response.StatusCode == 200)
{
return Ok(response);
}
else if (response.StatusCode == 401)
{
return Unauthorized(response);
}
else
{
return BadRequest(response);
}
}
[HttpPost]
public async Task<IActionResult> CreateContact([FromBody] CreateContactDto createContact)
{

388
Marco.Pms.Services/Helpers/DirectoryHelper.cs
View File

@ -787,393 +787,5 @@ namespace Marco.Pms.Services.Helpers
return ApiResponse<object>.ErrorResponse("User Send empty Payload", "User Send empty Payload", 400);
}
public async Task<ApiResponse<object>> CreateContact(CreateContactDto createContact)
{
Guid tenantId = _userHelper.GetTenantId();
var LoggedInEmployee = await _userHelper.GetCurrentEmployeeAsync();
if (createContact != null)
{
List<ContactPhone> phones = new List<ContactPhone>();
List<ContactEmail> emails = new List<ContactEmail>();
List<ContactBucketMapping> contactBucketMappings = new List<ContactBucketMapping>();
List<ContactTagMapping> contactTagMappings = new List<ContactTagMapping>();
Contact? contact = createContact.ToContactFromCreateContactDto(tenantId, LoggedInEmployee.Id);
_context.Contacts.Add(contact);
await _context.SaveChangesAsync();
_logger.LogInfo("Contact with ID {ContactId} created by Employee with ID {LoggedInEmployeeId}", contact.Id, LoggedInEmployee.Id);
var tags = await _context.ContactTagMasters.Where(t => t.TenantId == tenantId).ToListAsync();
var buckets = await _context.Buckets.Where(b => b.TenantId == tenantId).Select(b => b.Id).ToListAsync();
if (createContact.ContactPhones != null)
{
foreach (var contactPhone in createContact.ContactPhones)
{
ContactPhone phone = contactPhone.ToContactPhoneFromCreateContactPhoneDto(tenantId, contact.Id);
phones.Add(phone);
}
_context.ContactsPhones.AddRange(phones);
_logger.LogInfo("{count} phone number are saved in contact with ID {ContactId} by employee with ID {LoggedEmployeeId}", phones.Count, contact.Id, LoggedInEmployee.Id);
}
if (createContact.ContactEmails != null)
{
foreach (var contactEmail in createContact.ContactEmails)
{
ContactEmail email = contactEmail.ToContactEmailFromCreateContactEmailDto(tenantId, contact.Id);
emails.Add(email);
}
_context.ContactsEmails.AddRange(emails);
_logger.LogInfo("{count} email addresses are saved in contact with ID {ContactId} by employee with ID {LoggedEmployeeId}", emails.Count, contact.Id, LoggedInEmployee.Id);
}
if (createContact.BucketIds != null)
{
foreach (var bucket in createContact.BucketIds)
{
if (buckets.Contains(bucket))
{
ContactBucketMapping bucketMapping = new ContactBucketMapping
{
BucketId = bucket,
ContactId = contact.Id
};
contactBucketMappings.Add(bucketMapping);
}
}
_context.ContactBucketMappings.AddRange(contactBucketMappings);
_logger.LogInfo("Contact with ID {ContactId} added to {count} number of buckets by employee with ID {LoggedEmployeeId}", contact.Id, LoggedInEmployee.Id);
}
if (createContact.Tags != null)
{
foreach (var tag in createContact.Tags)
{
if (tag.Id != null && tags.Where(t => t.Id == tag.Id) != null)
{
ContactTagMapping tagMapping = new ContactTagMapping
{
ContactTagtId = tag.Id != null ? tag.Id.Value : Guid.Empty,
ContactId = contact.Id
};
contactTagMappings.Add(tagMapping);
}
else if (tag.Id == null || tags.Where(t => t.Name == tag.Name) == null)
{
var newtag = new ContactTagMaster
{
Name = tag.Name
};
_context.ContactTagMasters.Add(newtag);
ContactTagMapping tagMapping = new ContactTagMapping
{
ContactTagtId = newtag.Id,
ContactId = contact.Id
};
contactTagMappings.Add(tagMapping);
}
}
_context.ContactTagMappings.AddRange(contactTagMappings);
}
await _context.SaveChangesAsync();
ContactVM contactVM = new ContactVM();
List<ContactPhoneVM> phoneVMs = new List<ContactPhoneVM>();
foreach (var phone in phones)
{
ContactPhoneVM phoneVM = phone.ToContactPhoneVMFromContactPhone();
phoneVMs.Add(phoneVM);
}
List<ContactEmailVM> emailVMs = new List<ContactEmailVM>();
foreach (var email in emails)
{
ContactEmailVM emailVM = email.ToContactEmailVMFromContactEmail();
emailVMs.Add(emailVM);
}
List<ContactTagVM> tagVMs = new List<ContactTagVM>();
foreach (var contactTagMapping in contactTagMappings)
{
ContactTagVM tagVM = new ContactTagVM();
var tag = tags.Find(t => t.Id == contactTagMapping.ContactTagtId);
tagVM = tag != null ? tag.ToContactTagVMFromContactTagMaster() : new ContactTagVM();
tagVMs.Add(tagVM);
}
contactVM = contact.ToContactVMFromContact();
contactVM.ContactPhones = phoneVMs;
contactVM.ContactEmails = emailVMs;
contactVM.Tags = tagVMs;
return ApiResponse<object>.SuccessResponse(contactVM, "Contact Created Successfully", 200);
}
_logger.LogWarning("Employee with ID {LoggedInEmployeeId} sended empty payload", LoggedInEmployee.Id);
return ApiResponse<object>.ErrorResponse("User Send empty Payload", "User Send empty Payload", 400);
}
public async Task<ApiResponse<object>> UpdateContact(Guid id, UpdateContactDto updateContact)
{
Guid tenantId = _userHelper.GetTenantId();
var LoggedInEmployee = await _userHelper.GetCurrentEmployeeAsync();
if (updateContact != null)
{
if (updateContact.Id != id)
{
_logger.LogWarning("Employee with ID {LoggedInEmployeeId} sended different ID in payload and path parameter", LoggedInEmployee.Id);
return ApiResponse<object>.ErrorResponse("Invalid data", "Invalid data", 400);
}
Contact? contact = await _context.Contacts.FirstOrDefaultAsync(c => c.Id == id && c.TenantId == tenantId);
if (contact == null)
{
_logger.LogWarning("Employee with ID {LoggedInEmployeeId} tries to update contact with ID {ContactId} is not found in database", LoggedInEmployee.Id);
return ApiResponse<object>.ErrorResponse("Contact not found", "Contact not found", 404);
}
var newContact = updateContact.ToContactFromUpdateContactDto(tenantId);
List<ContactPhone> phones = await _context.ContactsPhones.AsNoTracking().Where(p => p.ContactId == contact.Id).ToListAsync();
var phoneIds = phones.Select(p => p.Id).ToList();
List<ContactEmail> emails = await _context.ContactsEmails.AsNoTracking().Where(p => p.ContactId == contact.Id).ToListAsync();
var emailIds = emails.Select(p => p.Id).ToList();
List<ContactBucketMapping> contactBuckets = await _context.ContactBucketMappings.AsNoTracking().Where(m => m.ContactId == contact.Id).ToListAsync();
var bucketIds = contactBuckets.Select(b => b.BucketId).Distinct().ToList();
List<ContactTagMapping> contactTags = await _context.ContactTagMappings.AsNoTracking().Where(m => m.ContactId == contact.Id).ToListAsync();
var tagIds = contactTags.Select(t => t.ContactTagtId).Distinct().ToList();
List<ContactTagMaster> tags = await _context.ContactTagMasters.Where(t => tagIds.Contains(t.Id)).ToListAsync();
if (updateContact.ContactPhones != null)
{
var updatedPhoneIds = updateContact.ContactPhones.Select(p => p.Id).Distinct().ToList();
foreach (var phoneDto in updateContact.ContactPhones)
{
var phone = phoneDto.ToContactPhoneFromUpdateContactPhoneDto(tenantId, contact.Id);
if (phoneDto.Id != null && phoneDto.Id != Guid.Empty && phoneIds.Contains(phone.Id))
{
_context.ContactsPhones.Update(phone);
}
else
{
_context.ContactsPhones.Add(phone);
}
}
foreach (var phone in phones)
{
if (!updatedPhoneIds.Contains(phone.Id))
{
_context.ContactsPhones.Remove(phone);
}
}
}
else if (phones != null)
{
_context.ContactsPhones.RemoveRange(phones);
}
if (updateContact.ContactEmails != null)
{
var updateEmailIds = updateContact.ContactEmails.Select(p => p.Id).Distinct().ToList();
foreach (var emailDto in updateContact.ContactEmails)
{
var email = emailDto.ToContactEmailFromUpdateContactEmailDto(tenantId, contact.Id);
if (emailDto.Id != null && emailDto.Id != Guid.Empty && emailIds.Contains(email.Id))
{
_context.ContactsEmails.Update(email);
}
else
{
_context.ContactsEmails.Add(email);
}
}
foreach (var email in emails)
{
if (!updateEmailIds.Contains(email.Id))
{
_context.ContactsEmails.Remove(email);
}
}
}
else if (emails != null)
{
_context.ContactsEmails.RemoveRange(emails);
}
if (updateContact.BucketIds != null)
{
foreach (var bucketId in updateContact.BucketIds)
{
if (!bucketIds.Contains(bucketId))
{
_context.ContactBucketMappings.Add(new ContactBucketMapping
{
BucketId = bucketId,
ContactId = contact.Id
});
}
}
foreach (var bucketMapping in contactBuckets)
{
if (!updateContact.BucketIds.Contains(bucketMapping.BucketId))
{
_context.ContactBucketMappings.Remove(bucketMapping);
}
}
}
else if (contactBuckets != null)
{
_context.ContactBucketMappings.RemoveRange(contactBuckets);
}
if (updateContact.Tags != null)
{
var updatedTagIds = updateContact.Tags.Select(t => t.Id).Distinct().ToList();
foreach (var tag in updateContact.Tags)
{
if (tag.Id != null && !tagIds.Contains(tag.Id.Value))
{
_context.ContactTagMappings.Add(new ContactTagMapping
{
ContactId = contact.Id,
ContactTagtId = tag.Id.Value
});
}
else if (tag.Id == null || tag.Id == Guid.Empty)
{
ContactTagMaster contactTag = new ContactTagMaster
{
Name = tag.Name,
Description = ""
};
_context.ContactTagMasters.Add(contactTag);
_context.ContactTagMappings.Add(new ContactTagMapping
{
ContactId = contact.Id,
ContactTagtId = contactTag.Id
});
}
}
foreach (var contactTag in contactTags)
{
if (!updatedTagIds.Contains(contactTag.ContactTagtId))
{
_context.ContactTagMappings.Remove(contactTag);
}
}
}
else if (contactTags != null)
{
_context.ContactTagMappings.RemoveRange(contactTags);
}
_context.DirectoryUpdateLogs.Add(new DirectoryUpdateLog
{
RefereanceId = contact.Id,
UpdatedById = LoggedInEmployee.Id,
UpdateAt = DateTime.UtcNow
});
await _context.SaveChangesAsync();
phones = await _context.ContactsPhones.AsNoTracking().Where(p => p.ContactId == contact.Id).ToListAsync();
emails = await _context.ContactsEmails.AsNoTracking().Where(p => p.ContactId == contact.Id).ToListAsync();
contactTags = await _context.ContactTagMappings.AsNoTracking().Where(m => m.ContactId == contact.Id).ToListAsync();
ContactVM contactVM = new ContactVM();
List<ContactPhoneVM> phoneVMs = new List<ContactPhoneVM>();
foreach (var phone in phones)
{
ContactPhoneVM phoneVM = phone.ToContactPhoneVMFromContactPhone();
phoneVMs.Add(phoneVM);
}
List<ContactEmailVM> emailVMs = new List<ContactEmailVM>();
foreach (var email in emails)
{
ContactEmailVM emailVM = email.ToContactEmailVMFromContactEmail();
emailVMs.Add(emailVM);
}
List<ContactTagVM> tagVMs = new List<ContactTagVM>();
foreach (var contactTagMapping in contactTags)
{
ContactTagVM tagVM = new ContactTagVM();
var tag = tags.Find(t => t.Id == contactTagMapping.ContactTagtId);
tagVM = tag != null ? tag.ToContactTagVMFromContactTagMaster() : new ContactTagVM();
tagVMs.Add(tagVM);
}
contactVM = contact.ToContactVMFromContact();
contactVM.ContactPhones = phoneVMs;
contactVM.ContactEmails = emailVMs;
contactVM.Tags = tagVMs;
_logger.LogInfo("Conatct {ContactId} has been updated by employee {EmployeeId}", contact.Id, LoggedInEmployee.Id);
return ApiResponse<object>.SuccessResponse(contactVM, "Contact Updated Successfully", 200);
}
_logger.LogWarning("Employee with ID {LoggedInEmployeeId} sended empty payload", LoggedInEmployee.Id);
return ApiResponse<object>.ErrorResponse("User Send empty Payload", "User Send empty Payload", 400);
}
// -------------------------------- Bucket --------------------------------
public async Task<ApiResponse<object>> GetBucketList()
{
Guid tenantId = _userHelper.GetTenantId();
var LoggedInEmployee = await _userHelper.GetCurrentEmployeeAsync();
List<EmployeeBucketMapping> employeeBuckets = await _context.EmployeeBucketMappings.Where(b => b.EmployeeId == LoggedInEmployee.Id).ToListAsync();
var bucketIds = employeeBuckets.Select(b => b.BucketId).ToList();
List<Bucket> bucketList = await _context.Buckets.Where(b => bucketIds.Contains(b.Id)).ToListAsync();
List<BucketVM> bucketVMs = new List<BucketVM>();
foreach (var bucket in bucketList)
{
BucketVM bucketVM = bucket.ToBucketVMFromBucket();
bucketVMs.Add(bucketVM);
}
_logger.LogInfo("{count} Buckets are fetched by Employee with ID {LoggedInEmployeeId}", bucketVMs.Count, LoggedInEmployee.Id);
return ApiResponse<object>.SuccessResponse(bucketVMs, System.String.Format("{0} buckets fetched successfully", bucketVMs.Count), 200);
}
public async Task<ApiResponse<object>> CreateBucket(CreateBucketDto bucketDto)
{
Guid tenantId = _userHelper.GetTenantId();
var LoggedInEmployee = await _userHelper.GetCurrentEmployeeAsync();
if (bucketDto != null)
{
var existingBucket = await _context.Buckets.FirstOrDefaultAsync(b => b.Name == bucketDto.Name);
if (existingBucket != null)
{
_logger.LogWarning("Employee ID {LoggedInEmployeeId} attempted to create an existing bucket.", LoggedInEmployee.Id);
return ApiResponse<object>.ErrorResponse("Bucket already existed", "Bucket already existed", 409);
}
Bucket bucket = new Bucket
{
Name = bucketDto.Name,
Description = bucketDto.Description,
TenantId = tenantId
};
_context.Buckets.Add(bucket);
EmployeeBucketMapping employeeBucket = new EmployeeBucketMapping
{
EmployeeId = LoggedInEmployee.Id,
BucketId = bucket.Id
};
_context.EmployeeBucketMappings.Add(employeeBucket);
await _context.SaveChangesAsync();
BucketVM bucketVM = bucket.ToBucketVMFromBucket();
_logger.LogInfo("Employee Id {LoggedInEmployeeId} creayted new bucket {BucketId}", LoggedInEmployee.Id, bucket.Id);
return ApiResponse<object>.SuccessResponse(bucketVM, "Bucket Created SuccessFully", 200);
}
_logger.LogWarning("Employee with ID {LoggedInEmployeeId} sended empty payload", LoggedInEmployee.Id);
return ApiResponse<object>.ErrorResponse("User Send empty Payload", "User Send empty Payload", 400);
}
}
}