public async Task <ActionResult> PickNow(string activeTransactionQueueKey, int actorKey, PickNow pickNow)
{
try
{
if (string.IsNullOrEmpty(activeTransactionQueueKey) || !Regex.IsMatch(activeTransactionQueueKey, @"^[0-9a-fA-F]{24}$"))
{
BusinessResponse objBadRequest = new BusinessResponse()
{
IsSuccess = false, Message = "ActiveTransactionQueueKey is not valid.", StatusCode = 400
};
_logger.LogError(objBadRequest.Message);
return(BadRequest(objBadRequest));
}
var headers = Request.Headers.ToDictionary <KeyValuePair <string, StringValues>, string, string>(item => item.Key, item => item.Value);
BusinessResponse objBusinessResponse = await _transactionQueueBussiness.PickNow(activeTransactionQueueKey, actorKey, pickNow, headers);
if (!objBusinessResponse.IsSuccess && objBusinessResponse.StatusCode == 400)
{
return(BadRequest(new ErrorResponse(objBusinessResponse.Message, objBusinessResponse.StatusCode, ResponsePayloadType.BusinessException)));
}
else if (!objBusinessResponse.IsSuccess && objBusinessResponse.StatusCode == 404)
{
return(NotFound(new ErrorResponse(objBusinessResponse.Message, objBusinessResponse.StatusCode, ResponsePayloadType.BusinessException)));
}
return(Ok(pickNow.TransactionQueueKeyToActivate));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(StatusCode(500));
}
}
/// <summary>
/// to delete routing rule from database..
/// </summary>
/// <param name="ruleId"></param>
/// <param name="facilityID"></param>
/// <param name="headers"></param>
/// <returns></returns>
public BusinessResponse DeleteRoutingRule(Guid ruleId, Dictionary <string, string> headers)
{
try
{
var facilityID = Utility.ParseStringToGuid(_executionContextAccessor.Current.Facility.FacilityKey);
var rule = _routingRulesRepository.GetRoutingRule(ruleId, facilityID).GetAwaiter().GetResult();
if (rule == null)
{
var exception = new BusinessResponse()
{
IsSuccess = false, Message = "RountingRuleKey doesn't exist in system"
};
return(exception);
}
_routingRulesRepository.DeleteRoutingRule(rule);
_unitOfWork.CommitChanges();
SendEvent(GetByID(ruleId), "Delete", headers);
var result = new BusinessResponse()
{
IsSuccess = true, Message = "Routing Rule Deleted Successfully"
};
return(result);
}
catch (Exception ex)
{
var exception = new BusinessResponse()
{
IsSuccess = false, Message = ex.Message
};
return(exception);
}
}
public async Task <IActionResult> Delete()
{
try
{
string ruleId = RouteData.Values["rountingRuleKey"].ToString();
List <string> str = new List <string>()
{
ruleId
};
bool res = Utility.ValidateGUID(str);
if (res == false)
{
_logger.LogInformation("Please provide valid RoutingRuleKey");
return(BadRequest(new ErrorResponse("Please provide valid RoutingRuleKey", (int)HttpStatusCode.BadRequest, ResponsePayloadType.BusinessException)));
}
var headers = Request.Headers.ToDictionary <KeyValuePair <string, StringValues>, string, string>(item => item.Key, item => item.Value);
BusinessResponse response = _manager.DeleteRoutingRule(Utility.ParseStringToGuid(ruleId), headers);
if (response.IsSuccess == false)
{
_logger.LogInformation(response.Message);
return(BadRequest(new ErrorResponse(response.Message, (int)HttpStatusCode.BadRequest, ResponsePayloadType.BusinessException)));
}
_logger.LogInformation(response.Message);
return(Ok(response.Message));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(StatusCode(500));
}
}
private static void Main(string[] args)
{
WindsorContainerWrapper installerWrapper =
new WindsorContainerWrapper(new WindsorContainer(), new Registration(), new BackendServices());
installerWrapper.RegistrationLogger = new ConsoleLogger();
installerWrapper.Install();
IWindsorContainer container = installerWrapper.WindsorContainer;
IServiceProvider <string, BusinessResponse> serviceProvider =
container.Resolve <IServiceProvider <string, BusinessResponse> >();
string serviceData = @"{ ""datafield"" : ""Some data""}";
BusinessResponse response = serviceProvider.PerformService(serviceData);
Console.WriteLine($"{response.Success}");
foreach (string responseMessage in response.Messages)
{
Console.WriteLine($"{responseMessage}");
}
Console.Write("Implementation: ");
Implementation = Console.ReadLine();
serviceProvider = container.Resolve <IServiceProvider <string, BusinessResponse> >();
response = serviceProvider.PerformService(serviceData);
Console.WriteLine($"{response.Success}");
foreach (string responseMessage in response.Messages)
{
Console.WriteLine($"{responseMessage}");
}
Console.ReadKey();
}
private static void InsertGoogleHunterDataToDB(BusinessResponse business, GoogleStoreModel googleStore, List <EmailDetails> emails, string status, Database db)
{
foreach (var email in emails)
{
AddRecordToDb(new yelp.Details
{
YelpUrl = null,
Domain = googleStore.Website,
Email = email.Email,
FirstName = email.FirstName,
LastName = email.LastName,
Position = email.Position,
LinkedIn = googleStore.Linkedin,
Twitter = googleStore.Twitter,
Seniority = email.Seniority,
City = business.Location.City,
State = business.Location.State,
Category = string.Join(", ", business.Categories.Select(c => c.Title).ToList <string>()),
StoreName = googleStore.Name,
Phone = googleStore.Phone,
Facebook = googleStore.Facebook,
Rating = -1,
Reviewers = -1,
Instagram = googleStore.Instagram,
Departmnt = email.Departmnt,
RetailsType = (emails?.Count ?? 0) >= _numOfEmailsForChain ? StringConstants.CATEGORY_CHAIN : StringConstants.CATEGORY_STORE,
Address1 = business.Location.Address1,
Address2 = business.Location.Address2,
ZipCode = business.Location.ZipCode,
InfoQuality = status
}, db);
}
}
/// <summary>
/// Business layer for updating facility extension on db
/// </summary>
/// <param name="facilityLogisticsConfigurationExtension"></param>
/// <returns></returns>
public async Task <BusinessResponse> UpdateFacilityExtensionAsync(FacilityLogisticsConfigurationExtension facilityLogisticsConfigurationExtension)
{
if (facilityLogisticsConfigurationExtension == null || facilityLogisticsConfigurationExtension.FacilityKey == Guid.Empty)
{
var message = new BusinessResponse()
{
IsSuccess = false, Message = BusinessError.InvalidInput
};
return(message);
}
var facilityData = await GetFacilityConfigurationAsync(facilityLogisticsConfigurationExtension.FacilityKey);
if (facilityData != null)
{
_mapper.Map(facilityLogisticsConfigurationExtension, facilityData, typeof(FacilityLogisticsConfigurationExtension), typeof(FacilityLogisticsConfig));
_repository.Update(facilityData);
await _unitOfWork.CommitChangesAsync();
var result = new BusinessResponse()
{
IsSuccess = true, Message = BusinessResponseMessages.LogisticsConfigurationUpdated
};
return(result);
}
else
{
var message = new BusinessResponse()
{
IsSuccess = false, Message = BusinessError.RecordNotFound
};
return(message);
}
}
private static void InsertYelpAndGoogleDataToDB(string domain, string fb, string instagram, string linkedin, string twitter,
BusinessResponse business, string category, string status, string phone, Database db)
{
AddRecordToDb(new yelp.Details
{
Domain = domain,
Email = null,
FirstName = null,
LastName = null,
Position = null,
LinkedIn = linkedin,
Twitter = twitter,
Seniority = null,
City = business.Location.City,
State = business.Location.State,
Category = string.Join(", ", business.Categories.Select(c => c.Title).ToList <string>()),
StoreName = business.Name,
Phone = phone,
Facebook = fb,
Rating = business.Rating,
Reviewers = business.ReviewCount,
Instagram = instagram,
Departmnt = null,
RetailsType = category,
Address1 = business.Location.Address1,
Address2 = business.Location.Address2,
ZipCode = business.Location.ZipCode,
InfoQuality = status,
YelpUrl = business.Url
}, db);
}
private static void InsertYelpGoogleAndHunterDataToDB(BusinessResponse business, GoogleStoreModel googleStore,
List <EmailDetails> emails, string category, string status, Database db)
{
foreach (var email in emails)
{
AddRecordToDb(new yelp.Details
{
YelpUrl = business.Url,
Domain = googleStore.Website,
Email = email.Email,
FirstName = email.FirstName,
LastName = email.LastName,
Position = email.Position,
LinkedIn = googleStore.Linkedin,
Twitter = googleStore.Twitter,
Seniority = email.Seniority,
City = business.Location.City,
State = business.Location.State,
Category = string.Join(", ", business.Categories.Select(c => c.Title).ToList <string>()),
StoreName = business.Name,
Phone = business.Phone,
Facebook = googleStore.Facebook,
Rating = business.Rating,
Reviewers = business.ReviewCount,
Instagram = googleStore.Instagram,
Departmnt = email.Departmnt,
RetailsType = category,
Address1 = business.Location.Address1,
Address2 = business.Location.Address2,
ZipCode = business.Location.ZipCode,
InfoQuality = status
}, db);
}
}
/// <summary>
/// To get all M3Users
/// </summary>
/// <returns></returns>
public List <AllUsersViewModel> GetAllM3Users()
{
BusinessResponse businessResponse = new BusinessResponse();
try
{
List <AllUsers> users = _clientUserRepository.GetAllM3Users();
List <AllUsersViewModel> allUsers = new List <AllUsersViewModel>();
if (users != null && users.Count > 0)
{
foreach (AllUsers user in users)
{
allUsers.Add(BusinessMapper.AllUsersBusinessToAllUsesrViewModel(user));
}
}
return(allUsers);
}
catch (Exception ex)
{
_logger.Log(ex, LogLevel.Error, ex.Message);
businessResponse.IsSuccess = false;
businessResponse.IsExceptionOccured = true;
businessResponse.Messages.Add(new MessageDTO()
{
Message = BusinessConstants.M3USERS_GET_FAIL, MessageType = Infrastructure.Enums.MessageType.Error
});
return(null);
}
}
/// <summary>
/// Converts BusinessResponse to ValidationViewModel
/// </summary>
/// <param name="response"></param>
/// <returns></returns>
public static ValidationViewModel ToValidationViewModel(this BusinessResponse response)
{
ValidationViewModel validationViewModel = new ValidationViewModel();
if (response != null)
{
validationViewModel.Success = response.IsSuccess;
validationViewModel.IsExceptionOccured = response.IsExceptionOccured;
validationViewModel.AdditionalInfo = response.AdditionalInfo;
if (response.BusinessRules != null && response.BusinessRules.Any())
{
foreach (BusinessRuleDTO DTO in response.BusinessRules)
{
if (DTO.Messages != null && DTO.Messages.Any())
{
validationViewModel = MapMessages(validationViewModel, DTO.Messages);
}
}
}
if (response.Messages != null && response.Messages.Any())
{
validationViewModel = MapMessages(validationViewModel, response.Messages);
}
}
return(validationViewModel);
}
/// <summary>
/// Create a collection child element for the Couchbase document.
/// </summary>
/// <typeparam name="TChild"></typeparam>
/// <param name="key"></param>
/// <param name="childName"></param>
/// <param name="data"></param>
/// <returns></returns>
public async virtual Task <BusinessResponse <T> > UpdateChildAsync <TChild>(string key, string childName, List <TChild> data) where TChild : EntityBase
{
childName = childName.ToCamelCase();
var result = await _bucket.UpsertChildAsync <T, TChild>(key, childName, data);
var response = new BusinessResponse <T>();
if (result.Success && result.OpStatus(0) == ResponseStatus.Success)
{
response.Status = BusinessStatus.Updated;
response.Message = result.Message;
}
else
{
response.Status = BusinessStatus.Error;
response.Errors = new List <ErrorInfo> {
new ErrorInfo {
ErrorMessage = result.Message
}
};
}
return(response);
}
/// <summary>
/// Create a child element for a Couchbasae document. If the child element is CollectionType,
/// then, insert the value as an element of collection property, else, insert a standalone child element.
/// </summary>
/// <typeparam name="TChild">Type of the child document</typeparam>
/// <param name="key">The Couchbase document key</param>
/// <param name="childName">The child property name</param>
/// <param name="data">The child element to be inserted</param>
/// <param name="isCollection">Indicates if the child is a single element or a collection</param>
/// <returns>BusinessResponse with Status as Created if the element is inserted correctly, otherwise,
/// Error if the insert failed or the child element already exists.</returns>
public async virtual Task <BusinessResponse <T> > InsertChildAsync <TChild>(string key, string childName, TChild data, bool isCollection = false) where TChild : EntityBase
{
childName = childName.ToCamelCase();
var result = isCollection
? await _bucket.InsertArrayChildAsync <T, TChild>(key, childName, data)
: await _bucket.InsertChildAsync <T, TChild>(key, childName, data);
var response = new BusinessResponse <T>();
if (result.Success && result.OpStatus(0) == ResponseStatus.Success)
{
response.Status = BusinessStatus.Created;
response.Message = result.Message;
}
else
{
response.Status = BusinessStatus.Error;
response.Errors = new List <ErrorInfo> {
new ErrorInfo {
ErrorMessage = result.Message
}
};
}
return(response);
}
/// <summary>
/// Get the value of a child property from a Couchbase document.
/// </summary>
/// <typeparam name="TChild">Type of the child document</typeparam>
/// <param name="key">The Couchbase document key</param>
/// <param name="childName">The child property name</param>
/// <param name="isCollection">Indicates if the child is a single element or a collection</param>
/// <returns>BusinessResonse with the Data or DataList property populated, depending on the type of the child element</returns>
public async virtual Task <BusinessResponse <TChild> > GetChildAsync <TChild>(string key, string childName, bool isCollection = false) where TChild : EntityBase
{
childName = childName.ToCamelCase();
var result = await _bucket.GetChildAsync <T>(key, childName);
var response = new BusinessResponse <TChild>();
if (result.Success && result.OpStatus(childName) == ResponseStatus.Success)
{
response.Status = BusinessStatus.Ok;
if (isCollection)
{
response.DataList = result.Content <List <TChild> >(childName);
}
else
{
response.Data = result.Content <TChild>(childName);
}
}
else
{
response.Status = BusinessStatus.Error;
response.Errors = new List <ErrorInfo> {
new ErrorInfo {
ErrorMessage = result.Message
}
};
}
return(response);
}
/// <summary>
/// Soft Delete the record by setting the IsActive property to false
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public async virtual Task <BusinessResponse <T> > SoftRemoveAsync(string key)
{
var result = await _bucket.GetAsync <T>(key);
result.Value.IsActive = "FALSE";
result = await _bucket.UpsertAsync <T>(key, result.Value);
var response = new BusinessResponse <T>();
if (result.Success)
{
response.Status = BusinessStatus.Deleted;
}
else
{
response.Status = BusinessStatus.Error;
response.Errors = new List <ErrorInfo> {
new ErrorInfo {
ErrorMessage = result.Message
}
};
}
return(response);
}
private static void InsertYelpDataToDB(BusinessResponse business, string status, Database db)
{
AddRecordToDb(new yelp.Details
{
Domain = null,
Email = null,
FirstName = null,
LastName = null,
Position = null,
LinkedIn = null,
Twitter = null,
Seniority = null,
City = business.Location.City,
State = business.Location.State,
Category = string.Join(", ", business.Categories.Select(c => c.Title).ToList <string>()),
StoreName = business.Name,
Phone = business.Phone,
Facebook = null,
Rating = business.Rating,
Reviewers = business.ReviewCount,
Instagram = null,
Departmnt = null,
RetailsType = StringConstants.CATEGORY_STORE,
Address1 = business.Location.Address1,
Address2 = business.Location.Address2,
ZipCode = business.Location.ZipCode,
InfoQuality = status,
YelpUrl = business.Url
}, db);
}
public async Task <IActionResult> PutTransactionPriority(string tranPriorityKey, TransactionPriorityPut transactionPriorityPut)
{
Models.TransactionPriority objTransactionPriority = new Models.TransactionPriority();
try
{
var facilityKey = RouteData.Values["facilitykey"].ToString();
var headers = Request.Headers.ToDictionary <KeyValuePair <string, StringValues>, string, string>(item => item.Key, item => item.Value);
BusinessResponse objBusinessResponse = await _manager.UpdateTransactionPriorityAsync(tranPriorityKey, transactionPriorityPut, Utility.ParseStringToGuid(facilityKey), headers);
if (objBusinessResponse.IsSuccesss)
{
_logger.LogInformation(objBusinessResponse.Message);
return(Ok(objBusinessResponse.Message));
}
else
{
_logger.LogInformation(objBusinessResponse.Message);
return(BadRequest(new ErrorResponse(objBusinessResponse.Message, (int)HttpStatusCode.BadRequest, ResponsePayloadType.BusinessException)));
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(StatusCode(500));
}
}
public BusinessResponse VerifyUser(string verificationLink)
{
var businessResp = new BusinessResponse
{
ResponseCode = ResponseCode.Fail
};
var userNameAndPassword = StringCipher.Decrypt(verificationLink, MoneyMarketConstant.EncyrptingPassword);
if (userNameAndPassword == null)
{
businessResp.ResponseMessage = ErrorMessage.WrongVerificationLink;
return(businessResp);
}
var userName = userNameAndPassword.Split(':')[0];
var email = userNameAndPassword.Split(':')[1];
var dataAccess = new UserDataAccess();
dataAccess.ConfirmEmail(userName, email);
businessResp.ResponseCode = ResponseCode.Success;
return(businessResp);
}
/// <summary>
/// Business layer for create request of Facility Extension
/// </summary>
/// <param name="facilityLogisticsConfigurationExtension"></param>
/// <returns></returns>
public async Task <BusinessResponse> CreateFacilityExtensionAsync(FacilityLogisticsConfigurationExtension facilityLogisticsConfigurationExtension)
{
if (facilityLogisticsConfigurationExtension == null || facilityLogisticsConfigurationExtension.FacilityKey == Guid.Empty)
{
var message = new BusinessResponse()
{
IsSuccess = false, Message = BusinessError.InvalidInput
};
return(message);
}
var model = _mapper.Map <FacilityLogisticsConfig>(facilityLogisticsConfigurationExtension);
PopulateAuditData(model);
_repository.Add(model);
await _unitOfWork.CommitChangesAsync();
var result = new BusinessResponse()
{
IsSuccess = true, Message = BusinessResponseMessages.LogisticsConfigurationCreated
};
return(result);
}
public async Task PickNow_TransactionToActivateIsOnHold_Test()
{
//Arranage
PickNow objPickNow = new PickNow()
{
};
Dictionary <string, string> headers = new Dictionary <string, string>();
List <int?> activeIsas = new List <int?>()
{
1
};
_transactionQueueRepository.Setup(x => x.GetActiveISA(It.IsAny <int>())).ReturnsAsync(activeIsas);
List <ManageQueues.Business.Models.TransactionQueue> listTransactionQueue = new List <ManageQueues.Business.Models.TransactionQueue>()
{
new ManageQueues.Business.Models.TransactionQueue()
{
Status = "Hold"
}
};
_transactionQueueRepository.Setup(x => x.GetPendingTransactions(It.IsAny <List <int?> >())).ReturnsAsync(listTransactionQueue);
//Act
BusinessResponse objBusinessResponse = await _transactionQueueBussiness.PickNow("transactionKeyToActivate", 1, objPickNow, headers);
//Assert
Assert.Equal(false, objBusinessResponse.IsSuccess);
}
async public void PopulatePage(User userObject)
{
BusinessResponse res = await _service.RetreiveBusinesses(userObject);
Debug.WriteLine($"BusinessResponse received: {res.Message}");
List <Business> listOfBusinesses = res.Result;
businessListView.ItemsSource = listOfBusinesses;
}
public ParkReview(BusinessResponse results)
{
if (results != null)
{
this.TotalReviews = results.ReviewCount;
this.AvgReview = results.Rating;
this.YelpUrl = results.Url;
}
}
protected BusinessResponse <int> ValidateParameters(IEnumerable <CommandParameter> commandParameters, int parameterCount)
{
var resp = new BusinessResponse <int>
{
ResponseCode = ResponseCode.Fail
};
if (Parameters == null || !Parameters.Any())
{
resp.ResponseData = 0; // parameter not found.
return(resp);
}
if (Parameters.Length != parameterCount)
{
resp.ResponseData = 1; // parameter length mismatch.
return(resp);
}
if (commandParameters != null)
{
foreach (var item in commandParameters)
{
if (item.IsNumber)
{
if (item.ParameterValue.Contains(','))
{
// parameter value is not valid for decimal or integer type
//post depth=3 message => Balance amount is invalid. Use only . (dot) and numbers for balances.
resp.ResponseData = item.Depth;
return(resp);
}
decimal d;
if (!decimal.TryParse(item.ParameterValue, out d))
{
//post depth=3 message => Balance amount is invalid. Use only . (dot) and numbers for balances.
resp.ResponseData = item.Depth;
return(resp);
}
//no validation error
continue;
}
if (!item.ParameterSet.Contains(item.ParameterValue))
{
// parameter not found in parameter set
resp.ResponseData = item.Depth;
return(resp);
}
}
}
resp.ResponseCode = ResponseCode.Success;
return(resp);
}
public BusinessResponse(BusinessResponse <T> response)
{
if (response != null)
{
Message = response?.Message;
IsSuccessful = response.IsSuccessful;
ResponseObject = response.ResponseObject;
}
}
public static void WriteAs(this BusinessResponse response, LogTypes logType, string functionName = null)
{
new Log().SetCategory("BusinessHandler").SetOutput(response)
.SetServiceName(response.GetType().Name.Replace("Response", "") + "Handler")
.SetFunctionName(functionName)
.SetMessage(response.Result.Messages?.FirstOrDefault()?.MessageText)
.SetMessageCode(response.Result?.Messages?.FirstOrDefault()?.MessageCode)
.SetException(response.Result.GetException())
.SetLogType(logType)
.Write();
}
public List <ParkReview> GetParksReview(List <string> parkKeys)
{
List <ParkReview> parkReviews = new List <ParkReview>();
foreach (var parkKey in parkKeys)
{
BusinessResponse results = YelpClient.GetBusinessAsync(parkKey).Result;
parkReviews.Add(new ParkReview(results));
}
return(parkReviews);
}
public void GetDistanceTo_StateUnderTest_ExpectedBehavior()
{
// Arrange
var businessResponse = new BusinessResponse();
Coordinates?loc = null;
// Act
var result = businessResponse.GetDistanceTo(loc);
// Assert
Assert.IsNotNull(businessResponse);
}
public BusinessResponse <long> Insert(MaterialApiModel model)
{
var result = _validator.Validate(model, options => options.IncludeRuleSets(string.Join(",", Enum.GetName(typeof(MaterialRuleSet), MaterialRuleSet.Create))));
if (!result.IsValid || result.Errors.Any())
{
return(BusinessResponse <long> .GenerateError(result));
}
return(BusinessResponse <long>
.GenerateOk(_materialDataAccess.Insert(_mapper.Map <Material>(model))));
}
public BusinessResponse <bool> Update(UnitApiModel model)
{
var result = _validator.Validate(model, options => options.IncludeRuleSets(string.Join(",", Enum.GetName(typeof(UnitRuleSet), UnitRuleSet.Update))));
if (!result.IsValid || result.Errors.Any())
{
return(BusinessResponse <bool> .GenerateError(result));
}
return(BusinessResponse <bool>
.GenerateOk(_unitDataAccess.Update(_mapper.Map <Unit>(model))));
}
public void SetDistanceAway_StateUnderTest_ExpectedBehavior()
{
// Arrange
var businessResponse = new BusinessResponse();
Coordinates?loc = null;
// Act
businessResponse.SetDistanceAway(loc);
// Assert
Assert.IsNotNull(businessResponse);
}
public async Task <IActionResult> Put([FromBody] RoutingRuleRequest routingRule)
{
try
{
var ruleId = RouteData.Values["rountingRuleKey"].ToString();
List <string> str = new List <string>()
{
ruleId
};
bool res = Utility.ValidateGUID(str);
if (res == false)
{
_logger.LogInformation("Please provide valid RoutingRuleKey");
return(BadRequest(new ErrorResponse("Please provide valid RoutingRuleKey", (int)HttpStatusCode.BadRequest, ResponsePayloadType.BusinessException)));
}
if (ModelState.IsValid)
{
if (routingRule.RoutingRuleDestinations.Count == 0 &&
routingRule.RoutingRuleTranPriority.Count == 0 &&
routingRule.RoutingRuleSchedules.Count == 0)
{
_logger.LogInformation("Any one of them is mandatory, Destination,Shedule,Transaction Priority");
return(BadRequest(new ErrorResponse("Any one of them is mandatory, Destination,Shedule,Transaction Priority", (int)HttpStatusCode.BadRequest, ResponsePayloadType.BusinessException)));
}
var headers = Request.Headers.ToDictionary <KeyValuePair <string, StringValues>, string, string>(item => item.Key, item => item.Value);
BusinessResponse response = _manager.UpdateRoutingRule(routingRule, Utility.ParseStringToGuid(ruleId), headers);
if (response.IsSuccess == false)
{
_logger.LogInformation(response.Message);
return(BadRequest(new ErrorResponse(response.Message, (int)HttpStatusCode.BadRequest, ResponsePayloadType.BusinessException)));
}
else
{
_logger.LogInformation(response.Message);
return(Ok(response.Message));
}
}
else
{
_logger.LogInformation("Model is not Valid");
return(BadRequest(new ErrorResponse(new ModelStateRequestValidationAdaptor(ModelState).ToString(), (int)HttpStatusCode.BadRequest, ResponsePayloadType.BusinessException)));
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(StatusCode(500));
}
}