private StatusResponseModel SetPedidoReprovado(StatusRequestModel model, PedidoEntity entity)
{
var statusResponseModel = new StatusResponseModel();
statusResponseModel.Status.Add(EnumStatusResponse.REPROVADO.ToString());
return(statusResponseModel);
}
public IActionResult KeepAlive([FromRoute][Required] int id)
{
try
{
/// <summary>
/// Método para guardar request en logs
/// </summary>
//_securityService.RequestLog("api/auth/KeepAlive: " + JsonConvert.SerializeObject(id));
StatusResponseModel responseModel = _authService.KeepAlive(id);
switch (responseModel.Status)
{
case ResultStatus.SUCCESS:
return(Ok());
case ResultStatus.NOT_FOUND:
return(StatusCode(StatusCodes.Status404NotFound, responseModel.Message));
case ResultStatus.ACCESS_DENIED:
return(StatusCode(StatusCodes.Status401Unauthorized));
default:
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, e));
}
}
private StatusResponseModel SetPedidoNaoLocalizado(StatusRequestModel model)
{
var statusResponseModel = new StatusResponseModel();
statusResponseModel.Status.Add(EnumStatusResponse.CODIGO_PEDIDO_INVALIDO.ToString());
return(statusResponseModel);
}
public StatusResponseModel ChangeStatus(StatusRequestModel model)
{
StatusResponseModel responseModel = null;
var entity = _context.Pedidos.Include("Itens").FirstOrDefault(x => x.NumPedido.Equals(model.Pedido));
var enumStatus = this.StatusRequestValido(model);
if (entity != null)
{
switch (enumStatus)
{
case EnumStatusRequest.APROVADO:
responseModel = this.ValidarPedidoAprovado(model, entity);
break;
case EnumStatusRequest.REPROVADO:
responseModel = this.SetPedidoReprovado(model, entity);
break;
}
}
else
{
responseModel = this.SetPedidoNaoLocalizado(model);
}
return(responseModel);
}
public IActionResult PatchCallRedirect([FromBody][Required] PatchRedirectCallRequestDto dataIn)
{
StatusResponseDto responseDto;
try
{
/// <summary>
/// Método para guardar request en logs
/// </summary>
_securityService.RequestLog("api/bo/calls/PatchCallRedirect: " + JsonConvert.SerializeObject(dataIn));
if (dataIn == null || dataIn.SessionId == "")
{
return(BadRequest());
}
// Se busca la llamada asociada al comercial segun el sessionId del mismo.
GetCallIdBySessionIdResponseModel responseCallModel = _boCallsService.GetCallIdBySessionId(dataIn.SessionId, false);
switch (responseCallModel.Status)
{
case ResultStatus.SUCCESS:
StatusResponseModel responseCallRedirect = _boCallsService.CallRedirect(responseCallModel.OrigChannel, responseCallModel.RedirectChannel, dataIn.Peer);
switch (responseCallRedirect.Status)
{
case ResultStatus.SUCCESS:
responseDto = _mapper.Map <StatusResponseDto>(responseCallRedirect);
return(StatusCode(StatusCodes.Status200OK, responseDto));
case ResultStatus.NOT_FOUND:
responseDto = _mapper.Map <StatusResponseDto>(responseCallRedirect);
return(StatusCode(StatusCodes.Status404NotFound, responseDto));
case ResultStatus.CANNOT_CONNECT_TO_PBX:
case ResultStatus.EXTERNAL_SERVICE_ERROR:
responseDto = _mapper.Map <StatusResponseDto>(responseCallRedirect);
return(StatusCode(StatusCodes.Status503ServiceUnavailable, responseDto));
default:
responseDto = _mapper.Map <StatusResponseDto>(responseCallRedirect);
return(StatusCode(StatusCodes.Status500InternalServerError, responseDto));
}
case ResultStatus.NOT_FOUND:
responseDto = _mapper.Map <StatusResponseDto>(responseCallModel);
return(StatusCode(StatusCodes.Status404NotFound, responseDto));
default:
responseDto = _mapper.Map <StatusResponseDto>(responseCallModel);
return(StatusCode(StatusCodes.Status500InternalServerError, responseDto));
}
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, e));
}
}
public async Task <IActionResult> AddReportAsync([FromBody] SpeakerRequestModel speakerRequest)
{
var res = await _speakersService.CreateSpeakerAsync(speakerRequest);
var responseStatus = new StatusResponseModel
{
Status = true,
Message = "Speaker added successfully",
ID = res
};
return(Ok(responseStatus));
}
public IActionResult PatchUpdateSupervisor([FromRoute][Required] int id, [FromBody][Required] PatchBOSupervisorsRequestDto data)
{
try
{
/// <summary>
/// Método para guardar request en logs
/// </summary>
_securityService.RequestLog("api/bo/supervisors/PatchUpdateSupervisor: {id: " + JsonConvert.SerializeObject(id) + ", data: " + JsonConvert.SerializeObject(data) + "}");
if (!ModelState.IsValid || id != data.Id)
{
return(BadRequest("The payload is invalid or check the supervisor id on route and payload"));
}
PatchBOSupervisorsRequestModel request = _mapper.Map <PatchBOSupervisorsRequestModel>(data);
StatusResponseModel businessResponse = _boSupervisorService.ApproveSupervisor(request);
switch (businessResponse.Status)
{
case ResultStatus.SUCCESS:
_notifier.Notify(new EmailData(EmailType.SupervisorState, request));
return(Ok());
case ResultStatus.BAD_REQUEST:
return(BadRequest());
case ResultStatus.ACCESS_DENIED:
return(StatusCode(StatusCodes.Status401Unauthorized));
case ResultStatus.NOT_AUTHORIZED:
return(StatusCode(StatusCodes.Status403Forbidden));
case ResultStatus.NOT_FOUND:
return(StatusCode(StatusCodes.Status404NotFound));
default:
return(StatusCode(StatusCodes.Status500InternalServerError, businessResponse.Message));
}
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, e));
}
}
private StatusResponseModel ValidarPedidoAprovado(StatusRequestModel model, PedidoEntity entity)
{
var statusResponseModel = new StatusResponseModel();
statusResponseModel.Pedido = entity.NumPedido;
var valorTotalPedido = this.GetValorTotalPedido(entity);
var quantidadeItensPedido = this.GetQuantidadeTotalItensPedido(entity);
var isQtdItenAprovadosCorreto = model.ItensAprovados == quantidadeItensPedido;
var isValorAprovadoExato = model.ValorAprovado == valorTotalPedido;
if (isQtdItenAprovadosCorreto && isValorAprovadoExato)
{
statusResponseModel.Status.Add(EnumStatusResponse.APROVADO.ToString());
}
else
{
if (model.ValorAprovado < valorTotalPedido)
{
statusResponseModel.Status.Add(EnumStatusResponse.APROVADO_VALOR_A_MENOR.ToString());
}
if (model.ValorAprovado > valorTotalPedido)
{
statusResponseModel.Status.Add(EnumStatusResponse.APROVADO_VALOR_A_MAIOR.ToString());
}
if (model.ItensAprovados < quantidadeItensPedido)
{
statusResponseModel.Status.Add(EnumStatusResponse.APROVADO_QTD_A_MENOR.ToString());
}
if (model.ItensAprovados > quantidadeItensPedido)
{
statusResponseModel.Status.Add(EnumStatusResponse.APROVADO_QTD_A_MAIOR.ToString());
}
}
return(statusResponseModel);
}
public IActionResult DeleteSupervisor([FromRoute][Required] int id)
{
try
{
/// <summary>
/// Método para guardar request en logs
/// </summary>
_securityService.RequestLog("api/bo/supervisors/DeleteSupervisor: " + JsonConvert.SerializeObject(id));
StatusResponseModel responseModel = _boSupervisorService.DeleteSupervisor(id);
switch (responseModel.Status)
{
case ResultStatus.SUCCESS:
return(Ok());
case ResultStatus.BAD_REQUEST:
return(BadRequest());
case ResultStatus.ACCESS_DENIED:
return(StatusCode(StatusCodes.Status401Unauthorized));
case ResultStatus.NOT_AUTHORIZED:
return(StatusCode(StatusCodes.Status403Forbidden));
case ResultStatus.CONFLICT:
StatusResponseDto responseDto = _mapper.Map <StatusResponseDto>(responseModel);
return(StatusCode(StatusCodes.Status409Conflict, responseDto));
case ResultStatus.NOT_FOUND:
return(NotFound());
default:
return(StatusCode(StatusCodes.Status500InternalServerError, responseModel.Message));
}
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, e));
}
}
public IActionResult DeleteCommercial([FromRoute][Required] int id)
{
try
{
/// <summary>
/// Metodo para guardar request en logs
/// </summary>
_securityService.RequestLog("api/bo/commercials/DeleteCommercial: " + JsonConvert.SerializeObject(id));
StatusResponseModel deleteCommercialResponse = _boCommercialService.DeleteCommercial(id);
switch (deleteCommercialResponse.Status)
{
case ResultStatus.SUCCESS:
return(Ok());
case ResultStatus.BAD_REQUEST:
return(BadRequest());
case ResultStatus.ACCESS_DENIED:
return(StatusCode(StatusCodes.Status401Unauthorized));
case ResultStatus.NOT_AUTHORIZED:
return(StatusCode(StatusCodes.Status403Forbidden));
case ResultStatus.NOT_FOUND:
return(NotFound());
default:
return(StatusCode(StatusCodes.Status500InternalServerError, deleteCommercialResponse.Message));
}
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, e));
}
}
public async Task <IActionResult> EndCall([FromQuery][Required] string callId)
{
try
{
/// <summary>
/// Método para guardar request en logs
/// </summary>
_securityService.RequestLog("api/ipbxcalls/EndCall: {callId: " + callId + "}");
if (string.IsNullOrWhiteSpace(callId) || !int.TryParse(callId, out int pCallId))
{
return(Ok(new StatusResponseDto
{
Status = "BadRequest",
Message = "Datos de entrada incorrectos."
}));
}
string endPoint = _config.GetValue <string>("ExternalServicesHosts:Siebel:EndPointEndCall");
StatusResponseModel resUpdTable = await _boCallsService.EndCallUpdateDBState(pCallId, endPoint);
switch (resUpdTable.Status)
{
case ResultStatus.SUCCESS:
return(Ok(new StatusResponseDto()
{
Status = "Ok",
Message = "Success"
}));
case ResultStatus.NOT_FOUND:
return(Ok(new StatusResponseDto()
{
Status = "NotFound",
Message = resUpdTable.Message
}));
case ResultStatus.ERROR:
return(Ok(new StatusResponseDto()
{
Status = "Error",
Message = resUpdTable.Message
}));
case ResultStatus.EXTERNAL_SERVICE_ERROR:
return(Ok(new StatusResponseDto()
{
Status = "Error",
Message = resUpdTable.Message
}));
default:
return(Ok(new StatusResponseDto()
{
Status = "Error",
Message = "Error en el servicio."
}));
}
}
catch (FormatException e)
{
return(Ok(new StatusResponseDto()
{
Status = "BadRequest",
Message = "Formato de datos de entrada incorrecto."
}));
}
catch (Exception e)
{
return(Ok(new StatusResponseDto()
{
Status = "Error",
Message = e.Message
}));
}
}
public IActionResult UploadCallPartFile([FromForm][Required] RequestUploadCallPartFileDto dataIn)
{
try
{
/// <summary>
/// Método para guardar request en logs
/// </summary>
_securityService.RequestLog("api/ipbxcalls/UploadCallPartFile: " + JsonConvert.SerializeObject(dataIn));
if (!ModelState.IsValid || dataIn == null || dataIn.FileContent == null ||
string.IsNullOrWhiteSpace(dataIn.CallId) || string.IsNullOrWhiteSpace(dataIn.CallPartNumber))
{
return(Ok(new StatusResponseDto
{
Status = "BadRequest",
Message = "Datos de entrada incorrectos."
}));
}
string uploadDir = _config.GetValue <string>("FileServer:Dir").Trim();
if (string.IsNullOrEmpty(uploadDir))
{
return(Ok(new StatusResponseDto()
{
Status = "Error",
Message = "En archivo appsettings no existe variable 'FileServer:Dir' o la misma es vacía."
}));
}
PostCallsUploadCallPartFileRequestModel request = new PostCallsUploadCallPartFileRequestModel()
{
CallId = dataIn.CallId,
CallPartNumber = dataIn.CallPartNumber,
PathToUpload = string.Format("{0}", uploadDir),
FileContent = dataIn.FileContent
};
// subida de archivo
List <string> allowExtentions = _config.GetValue <string>("FileServer:FileType").Split(',').Select(s => s.Trim()).ToList();
allowExtentions.Remove("");
StatusResponseModel resUpdFile = _boCallsService.UploadCallPartFile_UploadFile(request, allowExtentions);
switch (resUpdFile.Status)
{
case ResultStatus.SUCCESS:
// continuo con la actualizacion de la bd
break;
case ResultStatus.BAD_REQUEST:
case ResultStatus.ERROR:
default:
StatusResponseDto responseDto = _mapper.Map <StatusResponseDto>(resUpdFile);
return(Ok(responseDto));
}
// actualizo tabla CallParts
StatusResponseModel resUpdTable = _boCallsService.UploadCallPartFile_UpdateTable(request);
switch (resUpdTable.Status)
{
case ResultStatus.SUCCESS:
return(Ok(new StatusResponseDto()
{
Status = "Ok",
Message = "Success"
}));
case ResultStatus.BAD_REQUEST:
case ResultStatus.ERROR:
case ResultStatus.NOT_FOUND:
default:
StatusResponseDto responseDto = _mapper.Map <StatusResponseDto>(resUpdTable);
return(Ok(responseDto));
}
}
catch (Exception e)
{
return(Ok(new StatusResponseDto()
{
Status = "Error",
Message = e.Message
}));
}
}
/// <summary>
/// <para>
/// Elimina el comercial cuyo campo 'Id' coincide con el id indicado por el parametro <paramref id="intId"/>.
/// </para>
/// </summary>
/// <param name="id">Identificador del comercial.</param>
/// <returns>
/// Modelo <see cref="DeleteBOCommercialsResponseModel"/> con los datos de la respuesta.
/// </returns>
public StatusResponseModel DeleteCommercial(int id)
{
StatusResponseModel result = new StatusResponseModel
{
Status = ResultStatus.ERROR
};
IDbContextTransaction dbTransaction = null;
try
{
var context = _commercialRepository.GetContext();
using (dbTransaction = context.Database.BeginTransaction())
{
// Issue ICCB-735
Sessions session = _sessionRepository.SingleOrDefault(s => s.CommercialId == id);
if (session != null)
{
_sessionRepository.Delete(session);
_sessionRepository.Save();
}
Commercials toDelete = _commercialRepository.SingleOrDefault(c => c.Id == id);
if (toDelete == null)
{
result.Status = ResultStatus.NOT_FOUND;
result.Message = string.Format("No records found for the commercial (id:{0}).", id);
return(result);
}
RemoveThisComercialAsAlternative(id);
RemoveAlternativesOfThisComercial(id);
_commercialRepository.Delete(toDelete);
_commercialRepository.Save();
// Conexión a PBX
PbxConnection pbxConnection = null;
if (_pbxConnect)
{
pbxConnection = new PbxConnection(_pbxServer, _pbxUser, _pbxPwd, out string pbxMsg);
// validacion instancia PBX
if (pbxConnection == null)
{
dbTransaction.Rollback();
result.Status = ResultStatus.EXTERNAL_SERVICE_ERROR;
result.Message = "[BOCommercialsService-UpdateCommercial] Could not instantiate PBX";
return(result);
}
// validacion PBX inicializada
if (!pbxConnection.IsInitialized())
{
dbTransaction.Rollback();
result.Status = ResultStatus.CANNOT_CONNECT_TO_PBX;
result.Message = pbxMsg;
return(result);
}
// petición Delete a la PBX
pbxConnection.Delete(toDelete.Peer, () => { });
}
dbTransaction.Commit();
result.Status = ResultStatus.SUCCESS;
return(result);
}
}
catch (AmiException amiEx)
{
if (dbTransaction != null)
{
dbTransaction.Rollback();
}
result.Status = ResultStatus.EXTERNAL_SERVICE_ERROR;
result.Message = "[BOCommercialsService-DeleteCommercial-AmiException] " + amiEx.Message;
return(result);
}
catch (Exception e)
{
if (dbTransaction != null)
{
dbTransaction.Rollback();
}
result.Status = ResultStatus.ERROR;
result.Message = "[BOCommercialsService-DeleteCommercial-Exception] " + e.Message;
return(result);
}
}
public async Task <IActionResult> PostCallSetCustomerOutbound([FromBody][Required] PostCallsSetCustomerRequestDto data)
{
StatusResponseDto responseDto;
try
{
/// <summary>
/// Método para guardar request en logs
/// </summary>
_securityService.RequestLog("api/bo/calls/PostCallSetCustomerOutbound: " + JsonConvert.SerializeObject(data));
#region Validacion datos entrada
bool error = false;
responseDto = new StatusResponseDto();
if (!error && string.IsNullOrWhiteSpace(data.CustomerId))
{
responseDto.Status = "CUSTOMER_ID_NULL_OR_WHITESPACE";
responseDto.Message = string.Format("The '{0}' field is required.", "customer_id");
error = true;
}
if (!error && string.IsNullOrWhiteSpace(data.CustomerName))
{
responseDto.Status = "CUSTOMER_NAME_NULL_OR_WHITESPACE";
responseDto.Message = string.Format("The '{0}' field is required.", "customer_name");
error = true;
}
if (error)
{
return(StatusCode(StatusCodes.Status400BadRequest, responseDto));
}
#endregion
var callSetCustomerModel = _mapper.Map <PostCallsSetCustomerRequestModel>(data);
string endPoint = _config.GetValue <string>("ExternalServicesHosts:Siebel:EndPointEndCall");
StatusResponseModel businessResult = await _boCallsService.SetCustomer(callSetCustomerModel, CallDirection.Outbound, endPoint);
switch (businessResult.Status)
{
case ResultStatus.SUCCESS:
responseDto = _mapper.Map <StatusResponseDto>(businessResult);
return(StatusCode(StatusCodes.Status200OK, responseDto));
case ResultStatus.BAD_REQUEST:
return(BadRequest());
case ResultStatus.ACCESS_DENIED:
return(StatusCode(StatusCodes.Status401Unauthorized));
case ResultStatus.NOT_AUTHORIZED:
return(StatusCode(StatusCodes.Status403Forbidden));
case ResultStatus.NOT_FOUND:
return(NotFound());
default:
return(StatusCode(StatusCodes.Status500InternalServerError, businessResult.Message));
}
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, e));
}
}
public IActionResult RecordCall([FromBody][Required] PatchRecordCallRequestDto dataDtoIn)
{
try
{
/// <summary>
/// Método para guardar request en logs
/// </summary>
if (dataDtoIn == null || dataDtoIn.SessionId == "")
{
return(BadRequest());
}
StatusResponseModel businessResponse;
//Verificamos que el comercial tenga una llamada con ese sessionID
GetCallIdBySessionIdResponseModel callModel = _boCallsService.GetCallIdBySessionId(dataDtoIn.SessionId, dataDtoIn.Record, true);
_securityService.RequestLog("api/bo/calls/RecordCall: " + JsonConvert.SerializeObject(dataDtoIn) + " || response: " + JsonConvert.SerializeObject(callModel));
switch (callModel.Status)
{
case ResultStatus.SUCCESS:
businessResponse = _boCallsService.RecordCall(callModel.OrigChannel, dataDtoIn.Record);
break;
case ResultStatus.NOT_FOUND:
businessResponse = new StatusResponseModel
{
Message = callModel.Message,
Status = ResultStatus.NOT_FOUND
};
break;
default:
businessResponse = new StatusResponseModel
{
Message = callModel.Message,
Status = ResultStatus.ERROR
};
break;
}
StatusResponseDto responseDto;
switch (businessResponse.Status)
{
case ResultStatus.SUCCESS:
responseDto = _mapper.Map <StatusResponseDto>(businessResponse);
return(StatusCode(StatusCodes.Status200OK, responseDto));
case ResultStatus.BAD_REQUEST:
return(StatusCode(StatusCodes.Status400BadRequest));
case ResultStatus.ACCESS_DENIED:
return(StatusCode(StatusCodes.Status401Unauthorized));
case ResultStatus.NOT_AUTHORIZED:
return(StatusCode(StatusCodes.Status403Forbidden));
case ResultStatus.NOT_FOUND:
responseDto = _mapper.Map <StatusResponseDto>(businessResponse);
return(StatusCode(StatusCodes.Status404NotFound, responseDto));
case ResultStatus.CANNOT_CONNECT_TO_PBX:
case ResultStatus.EXTERNAL_SERVICE_ERROR:
responseDto = _mapper.Map <StatusResponseDto>(businessResponse);
return(StatusCode(StatusCodes.Status503ServiceUnavailable, responseDto));
default:
responseDto = _mapper.Map <StatusResponseDto>(businessResponse);
return(StatusCode(StatusCodes.Status500InternalServerError, responseDto));
}
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, e));
}
}
public IActionResult PutUpdateCommercial([FromRoute][Required] int id, [FromBody][Required] PutCommercialRequestDto data)
{
StatusResponseDto responseDto;
try
{
/// <summary>
/// Metodo para guardar request en logs
/// </summary>
_securityService.RequestLog("api/bo/commercials/PutUpdateCommercial: {id: " + JsonConvert.SerializeObject(id) + ", data: " + JsonConvert.SerializeObject(data) + "}");
#region Validacion datos entrada
bool error = false;
responseDto = new StatusResponseDto();
if (!error && (!ModelState.IsValid || id != data.CommercialId))
{
responseDto.Status = "PAYLOAD_INVALID";
responseDto.Message = "The payload is invalid or check the commercial id on route and payload.";
error = true;
}
if (!error && string.IsNullOrWhiteSpace(data.SiebelId))
{
responseDto.Status = "SIEBEL_ID_NULL_OR_WHITESPACE";
responseDto.Message = string.Format("The '{0}' field is required.", "SiebelId");
error = true;
}
if (!error && string.IsNullOrWhiteSpace(data.PBXPhoneNumber))
{
responseDto.Status = "PBX_NUMBER_NULL_OR_WHITESPACE";
responseDto.Message = string.Format("The '{0}' field is required.", "PBX Number");
error = true;
}
if (!error && string.IsNullOrWhiteSpace(data.MobilePhoneNumber))
{
responseDto.Status = "MOBILE_NUMBER_NULL_OR_WHITESPACE";
responseDto.Message = string.Format("The '{0}' field is required.", "Mobile Number");
error = true;
}
if (!error && string.IsNullOrWhiteSpace(data.CommercialName))
{
responseDto.Status = "NAME_NULL_OR_WHITESPACE";
responseDto.Message = string.Format("The '{0}' field is required.", "Name");
error = true;
}
if (!error && string.IsNullOrWhiteSpace(data.CommercialEmail))
{
responseDto.Status = "EMAIL_NULL_OR_WHITESPACE";
responseDto.Message = string.Format("The '{0}' field is required.", "Email");
error = true;
}
if (!error && data.CommercialEmail.Length > Constants.Commercials_Email_MaxLen)
{
responseDto.Status = "EMAIL_MAX_LEN";
responseDto.Message = string.Format("The maximum length of the field '{0}' is {1}.", "Email", Constants.Commercials_Email_MaxLen);
error = true;
}
if (!error && data.CommercialName.Length > Constants.Commercials_Name_MaxLen)
{
responseDto.Status = "NAME_MAX_LEN";
responseDto.Message = string.Format("The maximum length of the field '{0}' is {1}.", "Name", Constants.Commercials_Name_MaxLen);
error = true;
}
if (!error && data.SiebelId.Length > Constants.Commercials_SiebelId_MaxLen)
{
responseDto.Status = "SIEBEL_ID_MAX_LEN";
responseDto.Message = string.Format("The maximum length of the field '{0}' is {1}.", "Siebel Id", Constants.Commercials_SiebelId_MaxLen);
error = true;
}
if (!error && data.PBXPhoneNumber.Length > Constants.Commercials_PBXNumber_MaxLen)
{
responseDto.Status = "PBX_NUMBER_MAX_LEN";
responseDto.Message = string.Format("The maximum length of the field '{0}' is {1}.", "PBX Number", Constants.Commercials_PBXNumber_MaxLen);
error = true;
}
if (!error && data.MobilePhoneNumber.Length > Constants.Commercials_MobilePhoneNumber_MaxLen)
{
responseDto.Status = "MOBILE_NUMBER_MAX_LEN";
responseDto.Message = string.Format("The maximum length of the field '{0}' is {1}.", "Mobile Number", Constants.Commercials_MobilePhoneNumber_MaxLen);
error = true;
}
if (error)
{
return(StatusCode(StatusCodes.Status400BadRequest, responseDto));
}
#endregion
var commercialModel = _mapper.Map <PutCommercialRequestModel>(data);
StatusResponseModel businessResult = _boCommercialService.UpdateCommercial(id, commercialModel);
responseDto = _mapper.Map <StatusResponseDto>(businessResult);
switch (businessResult.Status)
{
case ResultStatus.SUCCESS:
return(StatusCode(StatusCodes.Status200OK, responseDto));
case ResultStatus.CANNOT_CONNECT_TO_PBX:
case ResultStatus.EXTERNAL_SERVICE_ERROR:
return(StatusCode(StatusCodes.Status503ServiceUnavailable, responseDto));
case ResultStatus.BAD_REQUEST:
return(StatusCode(StatusCodes.Status400BadRequest, responseDto));
case ResultStatus.COMMERCIAL_ROW_DUPLICATE_EMAIL:
case ResultStatus.COMMERCIAL_ROW_DUPLICATE_PEER:
case ResultStatus.COMMERCIAL_ROW_DUPLICATE_PBX:
case ResultStatus.COMMERCIAL_ROW_DUPLICATE_MOBILE:
case ResultStatus.COMMERCIAL_ROW_DUPLICATE_SIEBELID:
return(StatusCode(StatusCodes.Status409Conflict, responseDto));
case ResultStatus.NOT_FOUND:
return(StatusCode(StatusCodes.Status404NotFound, responseDto));
default:
return(StatusCode(StatusCodes.Status500InternalServerError, responseDto));
}
}
catch (Exception e)
{
responseDto = new StatusResponseDto
{
Status = "ERROR",
Message = "[BOCommercialsController-PutUpdateCommercial-Exception: " + e.Message
};
return(StatusCode(StatusCodes.Status500InternalServerError, responseDto));
}
}
public async Task <IActionResult> StartCallPart([FromQuery][Required] string CallId, [FromQuery][Required] string CallPartNumber,
[FromQuery][Required] string Peer, [FromQuery][Required] string OrigChannel, [FromQuery][Required] string RedirectChannel)
{
try
{
/// <summary>
/// Método para guardar request en logs
/// </summary>
_securityService.RequestLog("api/ipbxcalls/StartCallPart: {CallId: " + CallId + ", CallPartNumber: " + CallPartNumber + ", Peer: " + Peer + ", OrigChannel: " + OrigChannel + ", RedirectChannel: " + RedirectChannel + "}");
if (string.IsNullOrWhiteSpace(CallId) ||
string.IsNullOrWhiteSpace(Peer) ||
string.IsNullOrWhiteSpace(CallPartNumber) ||
string.IsNullOrWhiteSpace(OrigChannel) ||
string.IsNullOrWhiteSpace(RedirectChannel))
{
return(Ok(new StatusResponseDto
{
Status = "BadRequest",
Message = "Datos de entrada incorrectos."
}));
}
else
{
var getCommercialByPeerResult = _boCommercialService.GetCommercialByPeer(int.Parse(Peer));
if (getCommercialByPeerResult.status == ResultStatus.NOT_FOUND)
{
return(Ok(new StatusResponseDto()
{
Status = "NotFound",
Message = "No se encuentra Comercial con Peer " + Peer + "."
}));
}
if (getCommercialByPeerResult.status == ResultStatus.ERROR)
{
return(Ok(new StatusResponseDto()
{
Status = "Error",
Message = "Error en el servicio 'GetCommercialByPeer'."
}));
}
string endPoint = _config.GetValue <string>("ExternalServicesHosts:FCM:EndPointSend");
StatusResponseModel serviceResult = await _boCallsService.StartCallPart(endPoint, new PostCallsStartCallPartRequestModel()
{
CallId = int.Parse(CallId),
CallPartNumber = CallPartNumber,
Peer = int.Parse(Peer),
CommercialId = getCommercialByPeerResult.Commercial.CommercialId,
CommercialName = getCommercialByPeerResult.Commercial.CommercialName,
OrigChannel = OrigChannel,
RedirectChannel = RedirectChannel,
StartDate = DateTimeOffset.UtcNow
});
switch (serviceResult.Status)
{
case ResultStatus.SUCCESS:
return(Ok(new StatusResponseDto
{
Status = "Ok",
Message = "Success"
}));
case ResultStatus.BAD_REQUEST:
return(Ok(new StatusResponseDto
{
Status = "BadRequest",
Message = "Datos de entrada incorrectos."
}));
default:
return(Ok(new StatusResponseDto()
{
Status = "Error",
Message = serviceResult.Message
}));
}
}
}
catch (FormatException e)
{
return(Ok(new StatusResponseDto()
{
Status = "BadRequest",
Message = "Formato de datos de entrada incorrecto."
}));
}
catch (Exception e)
{
return(Ok(new StatusResponseDto()
{
Status = "Error",
Message = e.Message
}));
}
}
