Notes

namespace PRO.Application.API.Controllers.v1.Contact;

[ApiVersion("1")]
[Produces("application/json")]
[Route("application-api/v{ver:apiVersion}/contacts")]

public class ContactsController : BaseApiController<ContactsController>
{
public readonly IConfiguration _configuration;
public ContactsController(IConfiguration configuration)
{
_configuration = configuration;
}

#region Contact

/// <summary>
/// Get Contacts
/// </summary>
/// <remarks>Get All Existing Contacts From Database</remarks>
/// <param name="request"> ContactSearchDto Model</param>
/// <returns>Return <see cref="ContactListDto"/> List </returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpGet]
[ProducesResponseType(typeof(WebApiResponse<PagingQuery<CD.Contact, ContactListDto>>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task GetContacts([FromQuery] ContactSearchDto request)
{
await GenericAction<
ContactGetAllAction,
ContactSearchDto,
PagingQuery<CD.Contact, ContactListDto>,
ContactValidation>.Run(HttpContext, request, _configuration);
}

/// <summary>
/// Get Trashed Contacts
/// </summary>
/// <remarks>Get Trash Contacts From Database </remarks>
/// <param name="request">PagingRequest Model</param>
/// <returns>Return Paging <see cref="ContactTrashDto"/></returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpGet("trash")]
[ProducesResponseType(typeof(WebApiResponse<PagingQuery<CD.Contact, ContactTrashDto>>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task GetContactsInTrash([FromQuery] ContactSearchDto request)
{
await GenericAction<
ContactGetTrashAction,
ContactSearchDto,
PagingQuery<CD.Contact, ContactTrashDto>,
ContactTrashValidation>.Run(HttpContext, request, _configuration);
}

/// <summary>
/// Get Duplicated Contacts
/// </summary>
/// <remarks>Get All Dublicated Contacts From Database</remarks>
/// <returns>Return <see cref="ContactDuplicateDto"/> List </returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpGet("duplicate")]
[ProducesResponseType(typeof(WebApiResponse<IEnumerable<ContactDuplicateDto>>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task GetDuplicatedContcts()
{
await GenericAction<
GetDuplicateAction,
IEnumerable<ContactDuplicateDto>>.Run(HttpContext, _configuration);
}

/// <summary>
/// Get Counts (Active Contacts)
/// </summary>
/// <remarks>Get All Active Contact Counts</remarks>
/// <returns>Return <see cref="ContactCountDto"/> List </returns>
/// <response code="200">Returns count list </response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpGet("counts/active")]
[ProducesResponseType(typeof(WebApiResponse<IEnumerable<ContactCountDto>>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task GetActiveContactCount()
{
await GenericAction<
GetContactCountActiveAction,
IEnumerable<ContactCountDto>>.Run(HttpContext, _configuration);
}

/// <summary>
/// Get Counts (Trashed Contacts)
/// </summary>
/// <remarks>Get All Trashed Contact Counts</remarks>
/// <returns>Return <see cref="ContactCountDto"/> List </returns>
/// <response code="200">Returns count list </response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpGet("counts/trash")]
[ProducesResponseType(typeof(WebApiResponse<IEnumerable<ContactCountDto>>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task GetTrashContactCount()
{
await GenericAction<
GetContactCountTrashAction,
IEnumerable<ContactCountDto>>.Run(HttpContext, _configuration);
}



/// <summary>
/// Get Contact
/// </summary>
/// <remarks>Get A Contact </remarks>
/// <param name="request">ContactGetDto Model</param>
/// <returns>Return A <see cref="ContactDto"/></returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpGet("{id:int}")]
[ProducesResponseType(typeof(WebApiResponse<ContactDto>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task GetContact([FromRoute] ContactGetDto request)
{
await GenericAction<
ContactGetAction,
ContactGetDto,
ContactDto,
ContactGetValidation>.Run(HttpContext, request, _configuration);
}



/// <summary>
/// Create Contact
/// </summary>
/// <remarks>Create Contact</remarks>
/// <param name="request">ContactCreateAction Model</param>
/// <returns>Return <see cref="ContactDto"/> When Contact Created</returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpPost]
[ProducesResponseType(typeof(WebApiResponse<ContactDto>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task PostContact(ContactCreateDto request)
{
await GenericAction<
ContactCreateAction,
ContactCreateDto,
ContactDto,
ContactCreateValidation>.Run(HttpContext, request, _configuration);
}

/// <summary>
/// Update Contact
/// </summary>
/// <remarks>Update information of existing contact</remarks>
/// <param name="request">ContactUpdateDto Model</param>
/// <returns>Return <see cref="ContactDto"/> When Updated</returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpPut]
[ProducesResponseType(typeof(WebApiResponse<ContactDto>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task PutContact(ContactUpdateDto request)
{
await GenericAction<
ContactUpdateAction,
ContactUpdateDto,
ContactDto,
ContactUpdateValidation>.Run(HttpContext, request, _configuration);
}

/// <summary>
/// Delete Contact
/// </summary>
/// <remarks>Delete existing contact</remarks>
/// <param name="request">ContactDeleteDto Model</param>
/// <returns>Return <see cref="ContactDto"/> When Deleted</returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpDelete("{id}")]
[ProducesResponseType(typeof(WebApiResponse<ContactDto>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task DeleteContact([FromRoute] ContactDeleteDto request)
{
await GenericAction<
ContactDeleteAction,
ContactDeleteDto,
ContactDto,
ContactDeleteValidation>.Run(HttpContext, request, _configuration);
}

/// <summary>
/// Recover Contact
/// </summary>
/// <remarks>Recover A Deleted Contact </remarks>
/// <param name="request">ContactDeleteDto Model</param>
/// <returns>Return <see cref="ContactDto"/> When Recovered</returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpPut("{id}/recover")]
[ProducesResponseType(typeof(WebApiResponse<ContactDto>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task RecoverContact([FromRoute] ContactDeleteDto request)
{
await GenericAction<
ContactRecoverAction,
ContactDeleteDto,
ContactDto,
ContactDeleteValidation>.Run(HttpContext, request, _configuration);
}

/// <summary>
/// Delete Contact Forever
/// </summary>
/// <remarks>Delete Contact Forever From Database</remarks>
/// <param name="request">ContactForeverDto Model</param>
/// <returns>Return <see cref="ContactDto"/> When Deleted Forever</returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpDelete("{id}/forever")]
[ProducesResponseType(typeof(WebApiResponse<ContactDto>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task DeleteContactForever([FromRoute] ContactForeverDto request)
{
await GenericAction<
ContactForeverAction,
ContactForeverDto,
ContactDto,
ContactForeverValidation>.Run(HttpContext, request, _configuration);
}

/// <summary>
/// Empty Trash
/// </summary>
/// <remarks>Delete all removed contacts forever</remarks>
/// <param name="request">ContactDeleteDto Model</param>
/// <returns>Return ContactDto[] When Deleted</returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">Rejected for a reason</response>
/// <response code="500">Server not responding</response>
[HttpPost("empty-trash")]
[ProducesResponseType(typeof(WebApiResponse<IEnumerable<ContactDto>>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task DeleteAllInTrash()
{
await GenericAction<
ContactEmptyTrashAction,
IEnumerable<ContactDto>>.Run(HttpContext, _configuration);
}

/// <summary>
/// Dismiss Dublicated Contacts
/// </summary>
/// <remarks>Dismiss dublicated contacts from list</remarks>
/// <param name="request">ContactDismissDto Model</param>
/// <returns>Return Bool When Dismissed</returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpPost("duplicate-dismiss")]
[ProducesResponseType(typeof(WebApiResponse<IEnumerable<ContactDto>>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task PostDismissContact([FromBody] ContactDismissDto request)
{
await GenericAction<
ContactDismissAction,
ContactDismissDto,
IEnumerable<ContactDto>,
ContactDismissValidation>.Run(HttpContext, request, _configuration);
}

/// <summary>
/// Merge Contacts
/// </summary>
/// <remarks>Merge dublicate contacts into one contact</remarks>
/// <param name="request">MergeContactDto Model</param>
/// <returns>Return A <see cref="ContactDto"/> Merged Contact</returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpPost("merge")]
[ProducesResponseType(typeof(WebApiResponse<ContactDto>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task PostMergeContact([FromBody] MergeContactDto request)
{
await GenericAction<
ContactMergeAction,
MergeContactDto,
ContactDto,
ContactMergeValidation>.Run(HttpContext, request, _configuration);
}

#endregion

#region BulkContact

/// <summary>
/// Create Multiple Contacts
/// </summary>
/// <remarks>Create multiple contacts from excel</remarks>
/// <param name="request">List ContactCreateDto Model</param>
/// <returns>Return <see cref="ContactDto"/> When Contacts Created</returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpPost("import")]
[ProducesResponseType(typeof(WebApiResponse<List<ContactDto>>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task Post(IEnumerable<ContactCreateDto> request)
{
await GenericAction<
ContactBulkCreateAction,
IEnumerable<ContactCreateDto>,
BulkInsertProgressDto,
ContactCreateBulkInsertValidation>.Run(HttpContext, request, _configuration);
}

/// <summary>
/// Delete Multiple Contacts
/// </summary>
/// <remarks>Delete multiple existing contact</remarks>
/// <param name="request">ContactDeleteDto Model</param>
/// <returns>Return ContactDto[] When Deleted</returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpPost("bulk")]
[ProducesResponseType(typeof(WebApiResponse<IEnumerable<ContactDto>>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task DeleteBulkContact([FromBody] ContactBulkDeleteDto request)
{
await GenericAction<
ContactBulkDeleteAction,
ContactBulkDeleteDto,
IEnumerable<ContactDto>,
ContactBulkDeleteValidation>.Run(HttpContext, request, _configuration);
}

/// <summary>
/// Delete Multiple Contacts Forever
/// </summary>
/// <remarks>Delete multiple existing contacts forever</remarks>
/// <param name="request">ContactDeleteDto Model</param>
/// <returns>Return ContactDto[] When Deleted</returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpPost("bulk/forever")]
[ProducesResponseType(typeof(WebApiResponse<IEnumerable<ContactDto>>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task DeleteBulkContactForever([FromBody] ContactBulkForeverDto request)
{
await GenericAction<
ContactBulkForeverAction,
ContactBulkForeverDto,
IEnumerable<ContactDto>,
ContactBulkForeverValidation>.Run(HttpContext, request, _configuration);
}

/// <summary>
/// Recover Multiple Contacts
/// </summary>
/// <remarks>Recover Multiple Deleted Contacts</remarks>
/// <param name="request">ContactDeleteDto Model</param>
/// <returns>Return ContactDto[] When Recovered</returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpPost("bulk/recover")]
[ProducesResponseType(typeof(WebApiResponse<IEnumerable<ContactDto>>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task RecoverBulkContact([FromBody] ContactBulkRecoverDto request)
{
await GenericAction<
ContactBulkRecoverAction,
ContactBulkRecoverDto,
IEnumerable<ContactDto>,
ContactBulkRecoverValidation>.Run(HttpContext, request, _configuration);
}

/// <summary>
/// Update Contact Type
/// </summary>
/// <remarks>Update existing contact type from database</remarks>
/// <param name="request">ContactCreateDto Model</param>
/// <returns>Return <see cref="ContactDto"/> List </returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpPut("types")]
[ProducesResponseType(typeof(WebApiResponse<List<ContactDto>>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task PutBulkContactType([FromBody] ContactUpdateTypeDto request)
{
await GenericAction<
ContactUpdateTypeAction,
ContactUpdateTypeDto,
IEnumerable<ContactDto>,
ContactUpdateTypeValidation>.Run(HttpContext, request, _configuration);
}

#endregion

#region Visible Columns

/// <summary>
/// Get Contact Visible Columns
/// </summary>
/// <remarks>Get Columns Want To See.</remarks>
/// <returns>Return A <see cref="ContactVisibleColumnDto"/></returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpGet("visible-columns")]
[ProducesResponseType(typeof(WebApiResponse<ContactVisibleColumnDto>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task GetVisibleColumns()
{
await GenericAction<
ContactVisibleColumnAction,
ContactVisibleColumnDto>.Run(HttpContext, _configuration);
}

/// <summary>
/// Update Contact Visible Columns
/// </summary>
/// <remarks>Create Columns Want To See.</remarks>
/// <param name="request">ContactVisibleColumnCreateDto model</param>
/// <returns>Return A <see cref="ContactVisibleColumnDto"/></returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpPost("visible-columns")]
[ProducesResponseType(typeof(WebApiResponse<ContactVisibleColumnDto>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task PostVisibleColumns(ContactVisibleColumnCreateDto request)
{
await GenericAction<
ContactVisibleColumnCreateAction,
ContactVisibleColumnCreateDto,
ContactVisibleColumnDto,
ContactVisibleColumnCreateValidation>.Run(HttpContext, request, _configuration);
}

#endregion

#region Contact Tags

/// <summary>
/// Create Tag
/// </summary>
/// <remarks>Create Relation With Tag And Contact</remarks>
/// <param name="request">ContactTagCreateDto Model</param>
/// <returns>Return <see cref="ContactTagDto"/> When Created</returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpPost("{contactId:int}/tags/{tagId:guid}")]
[ProducesResponseType(typeof(WebApiResponse<ContactTagDto>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task PostContactTag([FromRoute] ContactTagAttachDto request)
{
await GenericAction<
ContactTagAttachAction,
ContactTagAttachDto,
ContactTagDto,
ContactTagAttachValidation>.Run(HttpContext, request, _configuration);
}

/// <summary>
/// Delete Tag
/// </summary>
/// <remarks>Remove Relation With Tag and Contact .</remarks>
/// <param name="request">ContactTagDeleteDto Model</param>
/// <returns>Return <see cref="ContactTagDto"/> When Deleted</returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpDelete("{contactId:int}/tags/{tagId:guid}")]
[ProducesResponseType(typeof(WebApiResponse<ContactTagDto>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task DeleteContactTag([FromRoute] ContactTagDetachDto request)
{
await GenericAction<
ContactTagDetachAction,
ContactTagDetachDto,
ContactTagDto,
ContactTagDetachValidation>.Run(HttpContext, request, _configuration);
}

#endregion

#region Share Contact

/// <summary>
/// Get Shared Contact
/// </summary>
/// <remarks>Get contact by created key to share contact</remarks>
/// <param name="request"> ShortLinkShareDto Model</param>
/// <returns>Return A <see cref="ContactDto" /></returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[AllowAnonymous]
[HttpGet("shared/{key}")]
[ProducesResponseType(typeof(WebApiResponse<ShortLinkDto>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task GetSharedContact([FromRoute] ShortLinkShareDto request)
{
await GenericAction<
ContactShortLinkGetAction,
ShortLinkShareDto,
ContactDto,
ShortLinkShareValidation>.Run(HttpContext, request, _configuration);
}

/// <summary>
/// Share Contact Link
/// </summary>
/// <remarks>Generate short link to share contact (Valid For 1 Year) </remarks>
/// <param name="request"> ContactShareDto Model </param>
/// <returns>Return A <see cref="ContactShareLinkDto"/></returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpPost("share-link")]
[ProducesResponseType(typeof(WebApiResponse<ContactShareLinkDto>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task PostSharedContactLink([FromBody] CreateContactLinkDto request)
{
await GenericAction<
ContactShortLinkCreateAction,
CreateContactLinkDto,
ContactShareLinkDto,
ShortLinkGetValidation>.Run(HttpContext, request, _configuration);
}

/// <summary>
/// Share Contact By Email
/// </summary>
/// <remarks></remarks>
/// <param name="request"></param>
/// <returns></returns>
/// <response code="200">Returns the newly created item</response>
/// <response code="400">If the item is null</response>
/// <response code="500">Server Not Responding</response>
[HttpPost("share-email")]
[ProducesResponseType(typeof(WebApiResponse<SharedByEmailResponseDto>), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(WebApiResponse), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status500InternalServerError)]
public async Task PostSharedContactEmail(ShareByEmailDto request)
{
await GenericAction<
ShareByEmailCreateAction,
ShareByEmailDto,
SharedByEmailResponseDto,
ShareByEmailCreateValidation>.Run(HttpContext, request, _configuration);
}

#endregion
}