public async Task <ActionResult <CashOrderResponseCreate> > Create(CashOrder cashOrder)
{
try
{
CashOrderHelper.Validate(cashOrder, logger, ModelState);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
CashOrderHelper.AddClientIp(cashOrder, HttpContext.Connection.RemoteIpAddress.ToString());
CashOrderHelper.SetStatusInProgress(cashOrder);
if (RequestMode.IsCreate(cashOrder))
{
List <CashOrder> cashOrders = SendMessage(cashOrder);
if (cashOrders.Count > 0)
{
return(Ok(CashOrderHelper.ConvertToResponseCreate(cashOrders)));
}
else
{
return(BadRequest());
}
}
}
catch (Exception ex)
{
logger.LogError(ex.Message + "\n" + ex.StackTrace);
return(BadRequest());
}
return(BadRequest());
}
public static bool IsGetById(CashOrder order)
{
return(order.Id != 0 && order.Amount == 0 &&
string.IsNullOrWhiteSpace(order.UserId) &&
string.IsNullOrWhiteSpace(order.OfficeAddress) &&
string.IsNullOrWhiteSpace(order.Currency));
}
public static bool IsCreate(CashOrder order)
{
return(order.Id == 0 && order.Amount != 0 &&
!string.IsNullOrWhiteSpace(order.UserId) &&
!string.IsNullOrWhiteSpace(order.OfficeAddress) &&
!string.IsNullOrWhiteSpace(order.Currency));
}
public async Task <CashOrder> CashOrderCreate(CashOrder cashOrder)
{
try
{
using (IDbConnection db = new SqlConnection(connectionString))
{
db.Open();
DynamicParameters param = new DynamicParameters();
param.Add("@UserId", cashOrder.UserId);
param.Add("@OfficeAddress", cashOrder.OfficeAddress);
param.Add("@Amount", cashOrder.Amount);
param.Add("@Currency", cashOrder.Currency);
param.Add("@IpAddress", cashOrder.IpAddress);
param.Add("@Status", cashOrder.Status);
var result = await db.QueryAsync("CashOrderCreate", param, commandType : CommandType.StoredProcedure);
//it needs for async return Id
var firstRecord = result.FirstOrDefault() as IDictionary <string, object>;
cashOrder.Id = Convert.ToInt32(firstRecord["Id"]);
return(cashOrder);
}
}
catch (Exception ex)
{
throw;
}
}
private void RegisterOrder(Remittance remittance)
{
var remittanceSetting = _remittanceSettingRepository.Find(new { remittance.SendBranchId, remittance.ReceiveBranchId });
if (remittanceSetting == null)
{
throw new PawnshopApplicationException("Не найдены настройки переводов для выбранной пары филиалов");
}
var sendBranch = _memberRepository.FindBranch(remittance.SendUserId, remittance.SendBranchId);
var cashOutNumberCode = sendBranch?.Configuration?.CashOrderSettings?.CashOutNumberCode ?? _branchContext.Configuration.CashOrderSettings.CashOutNumberCode;
var outOrder = new CashOrder
{
OrderType = OrderType.CashOut,
UserId = remittanceSetting.CashOutUserId,
DebitAccountId = remittanceSetting.CashOutDebitId,
CreditAccountId = remittanceSetting.CashOutCreditId,
OrderCost = remittance.SendCost,
OrderDate = remittance.SendDate,
ExpenseTypeId = remittanceSetting.ExpenseTypeId,
Reason = $"Снятие денег для передачи в филиал {remittance.ReceiveBranch?.DisplayName}",
Note = remittance.Note,
RegDate = DateTime.Now,
OwnerId = remittance.SendBranchId,
BranchId = remittance.SendBranchId,
AuthorId = remittance.SendUserId,
OrderNumber = _cashCounterRepository.Next(OrderType.CashOut, remittance.SendDate.Year, remittance.SendBranchId, cashOutNumberCode)
};
_orderRepository.Insert(outOrder);
_eventLog.Log(EventCode.CashOrderSaved, EventStatus.Success, EntityType.CashOrder, outOrder.Id, JsonConvert.SerializeObject(remittance), JsonConvert.SerializeObject(outOrder));
remittance.SendOrderId = outOrder.Id;
var inOrder = new CashOrder
{
OrderType = OrderType.CashIn,
UserId = remittanceSetting.CashInUserId,
DebitAccountId = remittanceSetting.CashInDebitId,
CreditAccountId = remittanceSetting.CashInCreditId,
OrderCost = remittance.SendCost,
OrderDate = remittance.ReceiveDate.Value,
Reason = $"Получение денег из филиала {remittance.SendBranch?.DisplayName}",
Note = remittance.Note,
RegDate = DateTime.Now,
OwnerId = remittance.ReceiveBranchId,
BranchId = remittance.ReceiveBranchId,
AuthorId = remittance.ReceiveUserId.Value,
OrderNumber = _cashCounterRepository.Next(OrderType.CashIn, remittance.ReceiveDate.Value.Year, remittance.ReceiveBranchId, _branchContext.Configuration.CashOrderSettings.CashInNumberCode)
};
_orderRepository.Insert(inOrder);
_eventLog.Log(EventCode.CashOrderSaved, EventStatus.Success, EntityType.CashOrder, inOrder.Id, JsonConvert.SerializeObject(remittance), JsonConvert.SerializeObject(inOrder));
remittance.ReceiveOrderId = inOrder.Id;
}
/// <summary>
/// CashOrder validation
/// </summary>
public static void Validate(CashOrder cashOrder, ILogger logger, ModelStateDictionary modelState)
{
string message = "";
if (cashOrder == null)
{
message = "cashOrder is null";
logger.LogWarning(message);
modelState.AddModelError("Other", message);
}
//Another validation
}
public CashOrder Save([FromBody] CashOrder cashOrder)
{
if (cashOrder.Id == 0)
{
cashOrder.RegDate = DateTime.Now;
cashOrder.OwnerId = _branchContext.Branch.Id;
cashOrder.BranchId = _branchContext.Branch.Id;
cashOrder.AuthorId = _sessionContext.UserId;
cashOrder.ApproveStatus = 0;
}
ModelState.Clear();
TryValidateModel(cashOrder);
ModelState.Validate();
if (cashOrder.OrderDate.Date < DateTime.Now.Date && !_sessionContext.ForSupport)
{
throw new PawnshopApplicationException("Поле дата кассового ордера не может быть меньше текущей даты");
}
using (var transaction = _repository.BeginTransaction())
{
if (cashOrder.Id > 0)
{
_repository.Update(cashOrder);
}
else
{
string code;
switch (cashOrder.OrderType)
{
case OrderType.CashIn:
code = _branchContext.Configuration.CashOrderSettings.CashInNumberCode;
break;
case OrderType.CashOut:
code = _branchContext.Configuration.CashOrderSettings.CashOutNumberCode;
break;
default:
throw new ArgumentOutOfRangeException(nameof(cashOrder.OrderType), cashOrder.OrderType, null);
}
cashOrder.OrderNumber = _counterRepository.Next(
cashOrder.OrderType, cashOrder.OrderDate.Year,
_branchContext.Branch.Id, code);
_repository.Insert(cashOrder);
}
transaction.Commit();
}
return(cashOrder);
}
public IActionResult Sign([FromBody] int id)
{
if (id <= 0)
{
throw new ArgumentOutOfRangeException(nameof(id));
}
var model = _investementRepository.Get(id);
if (model == null)
{
throw new InvalidOperationException();
}
if (model.Status > InvestmentStatus.Draft)
{
throw new PawnshopApplicationException("Договор уже подписан");
}
using (var transaction = _investementRepository.BeginTransaction())
{
var order = new CashOrder
{
OrderType = OrderType.CashIn,
ClientId = model.ClientId,
DebitAccountId = 0, //TODO: В настройках добавить дебет и кредит для инвестиций
CreditAccountId = 0,
OrderCost = model.InvestmentCost,
OrderDate = model.InvestmentBeginDate,
RegDate = DateTime.Now,
OwnerId = _branchContext.Branch.Id,
BranchId = _branchContext.Branch.Id,
AuthorId = _sessionContext.UserId,
OrderNumber = _counterRepository.Next(
OrderType.CashIn,
model.InvestmentBeginDate.Year,
_branchContext.Branch.Id,
_branchContext.Configuration.CashOrderSettings.CashInNumberCode)
};
_orderRepository.Insert(order);
model.OrderId = order.Id;
model.Status = InvestmentStatus.Signed;
_investementRepository.Update(model);
transaction.Commit();
}
return(Ok());
}
private void CreateOrder(Insurance insurance, InsuranceAction action, OrderType orderType, int debitAccountId, int creditAccountId)
{
string code;
switch (orderType)
{
case OrderType.CashIn:
code = _branchContext.Configuration.CashOrderSettings.CashInNumberCode;
break;
case OrderType.CashOut:
code = _branchContext.Configuration.CashOrderSettings.CashOutNumberCode;
break;
default:
throw new ArgumentOutOfRangeException(nameof(orderType), orderType, null);
}
var order = new CashOrder
{
OrderType = orderType,
ClientId = insurance.Contract.ClientId,
DebitAccountId = debitAccountId,
CreditAccountId = creditAccountId,
OrderCost = insurance.InsuranceCost,
OrderDate = action.ActionDate,
Reason = GetReason(action.ActionType),
RegDate = DateTime.Now,
OwnerId = _branchContext.Branch.Id,
BranchId = _branchContext.Branch.Id,
AuthorId = _sessionContext.UserId,
OrderNumber = _cashCounterRepository.Next(orderType, action.ActionDate.Year, _branchContext.Branch.Id, code)
};
if (order.DebitAccountId == 0 || order.CreditAccountId == 0)
{
throw new PawnshopApplicationException("Настройте счета дебет и кредит для страхового договора");
}
_orderRepository.Insert(order);
_eventLog.Log(EventCode.CashOrderSaved, EventStatus.Success, EntityType.CashOrder, order.Id, null, null);
action.OrderId = order.Id;
}
public IActionResult ApproveCashOrder(ApproveIdRequest request)
{
if (ModelState.IsValid)
{
var response = new SingleResponse <ActionResult>();
CashOrder order = _cacheHelper.GetApprovalOrder <CashOrder>(request.Id);
ActionResult Result = _xbService.ApproveCashOrder(order);
response.ResultCode = ResultCodeFormatter.FromPersonalAccountSecurityService(Result.ResultCode);
response.ResultCode = ResultCodes.normal;
response.Description = utils.GetActionResultErrors(Result.Errors);
return(ResponseExtensions.ToHttpResponse(response));
}
else
{
return(ValidationError.GetValidationErrorResponse(ModelState));
}
}
public async Task <ActionResult <IEnumerable <CashOrderResponseGet> > > Get(CashOrder cashOrder)
{
try
{
List <CashOrder> cashOrders = new List <CashOrder>();
if (RequestMode.IsGetById(cashOrder) || RequestMode.IsGetByUserIdAndOfficeAddress(cashOrder))
{
cashOrders = SendMessage(cashOrder);
return(Ok(CashOrderHelper.ConvertToResponseGet(cashOrders)));
}
}
catch (Exception ex)
{
logger.LogError(ex.Message);
return(BadRequest());
}
return(BadRequest());
}
/// <summary>
/// Send message to message queue
/// </summary>
private List <CashOrder> SendMessage(CashOrder cashOrder)
{
List <CashOrder> ordersList = new List <CashOrder>();
ordersList.Add(cashOrder);
string json = CashOrdersSerializer.Serialize(ordersList);
try
{
sender = new Sender(configuration);
var response = sender.Call(json);
ordersList = CashOrdersSerializer.Deserialize(response);
return(ordersList);
}
catch (Exception ex)
{
throw;
}
finally
{
sender.Close();
}
}
public static void SetStatusInProgress(CashOrder cashOrder)
{
cashOrder.Status = OrderStatus.InProgress.ToString();
}
public static void AddClientIp(CashOrder cashOrder, string ipAddress)
{
cashOrder.IpAddress = ipAddress;
}
public override void OnActionExecuting(ActionExecutingContext context)
{
ApproveIdRequest request = null;
ProductIdApproveRequest productIdRequest = null;
ApproveLoanProductOrderRequest approveLoan = null;
ListDocIdRequest listRequest = null;
Dictionary <long, ApprovalOrderType> Types = new Dictionary <long, ApprovalOrderType>();
string sessionId = "";
string otp = "";
byte language = 0;
bool isSigned = false;
string ipAddress = "";
Dictionary <string, string> signData = null;
SourceType sourceType = SourceType.NotSpecified;
// հայտի մուտքագրման աղբյուրի ստացում Header-ից
if (!string.IsNullOrEmpty(context.HttpContext.Request.Headers["SourceType"]))
{
Enum.TryParse(context.HttpContext.Request.Headers["SourceType"], out sourceType);
}
// Սեսիայի ստացում Header-ից
if (!string.IsNullOrEmpty(context.HttpContext.Request.Headers["SessionId"]))
{
sessionId = context.HttpContext.Request.Headers["SessionId"];
}
// Լեզվի ստացում Header-ից
if (!string.IsNullOrEmpty(context.HttpContext.Request.Headers["language"]))
{
byte.TryParse(context.HttpContext.Request.Headers["language"], out language);
}
// IP հասցեի ստացում
if (!string.IsNullOrEmpty(context.HttpContext.Request.Headers["LocalIPAddress"]))
{
ipAddress = context.HttpContext.Request.Headers["LocalIPAddress"];
}
// Փոխանցված պարամետրի ստացում
var argument = context.ActionArguments.Values.First();
//Approve մեթոդների համար
if (argument is ApproveIdRequest)
{
request = argument as ApproveIdRequest;
Types.Add(request.Id, _type);
otp = request.OTP;
}
//ApproveOrders մեթոդի համար
else if (argument is ListDocIdRequest)
{
listRequest = argument as ListDocIdRequest;
foreach (var item in listRequest.ListDocId)
{
Types.Add(item, GetOrderType(_xbService.GetDocumentType(item)));
}
otp = listRequest.OTP;
}
else if (argument is ProductIdApproveRequest)
{
productIdRequest = argument as ProductIdApproveRequest;
Types.Add((long)productIdRequest.ProductId, _type);
otp = productIdRequest.OTP;
}
else if (argument is ApproveLoanProductOrderRequest)
{
approveLoan = argument as ApproveLoanProductOrderRequest;
Types.Add(approveLoan.Id, _type);
otp = approveLoan.OTP;
}
//Հայտի ստեղծում, քեշավորում, և Sign լինող պարամետրերի փոխանցում
foreach (var x in Types)
{
switch (x.Value)
{
case ApprovalOrderType.PaymentOrder:
{
PaymentOrder order = (PaymentOrder)_cacheHelper.SetApprovalOrder(_xbService.GetPaymentOrder(x.Key));
CollectParameters(order.Id.ToString(), order.DebitAccount.AccountNumber.ToString(), order.ReceiverAccount.AccountNumber.ToString(),
Math.Truncate(order.Amount).ToString(), ipAddress);
}
break;
case ApprovalOrderType.PlasticCardOrder:
{
PlasticCardOrder order = (PlasticCardOrder)_cacheHelper.SetApprovalOrder(_xbService.GetPlasticCardOrder(x.Key));
CollectParameters(order.Id.ToString(), "0", "0", order.PlasticCard.Currency, ipAddress);
}
break;
case ApprovalOrderType.UtilityPaymentOrder:
{
UtilityPaymentOrder order = (UtilityPaymentOrder)_cacheHelper.SetApprovalOrder(_xbService.GetUtilityPaymentOrder(x.Key));
CollectParameters(order.Id.ToString(), order.DebitAccount.AccountNumber.ToString(), "0", Math.Truncate(order.Amount).ToString(), ipAddress);
}
break;
case ApprovalOrderType.MatureOrder:
{
MatureOrder order = (MatureOrder)_cacheHelper.SetApprovalOrder(_xbService.GetMatureOrder(x.Key));
CollectParameters(order.Id.ToString(), order.Account.AccountNumber.ToString(), "0", Math.Truncate(order.Amount).ToString(), ipAddress);
}
break;
case ApprovalOrderType.ReferenceOrder:
{
ReferenceOrder order = (ReferenceOrder)_cacheHelper.SetApprovalOrder(_xbService.GetReferenceOrder(x.Key));
if (order.FeeAccount != null)
{
CollectParameters(order.Id.ToString(), order.FeeAccount.AccountNumber.ToString(), "0", Math.Truncate(order.Amount).ToString(), ipAddress);
}
else
{
CollectParameters(order.Id.ToString(), "0", "0", Math.Truncate(order.Amount).ToString(), ipAddress);
}
}
break;
case ApprovalOrderType.LoanProductOrder:
{
LoanProductOrder order = null;
var type = _xbService.GetDocumentType((int)x.Key);
switch (type)
{
case OrderType.CreditSecureDeposit:
order = (LoanProductOrder)_cacheHelper.SetApprovalOrder(_xbService.GetLoanOrder(x.Key));
break;
default:
order = (LoanProductOrder)_cacheHelper.SetApprovalOrder(_xbService.GetCreditLineOrder(x.Key));
break;
}
CollectParameters(order.Id.ToString(), "0", "0", Math.Truncate(order.Amount).ToString(), ipAddress);
}
break;
case ApprovalOrderType.ReceivedFastTransferPaymentOrder:
{
ReceivedFastTransferPaymentOrder order = (ReceivedFastTransferPaymentOrder)_cacheHelper.SetApprovalOrder(_xbService.GetReceivedFastTransferPaymentOrder(x.Key));
CollectParameters(order.Id.ToString(), "0", order.ReceiverAccount.AccountNumber.ToString(), Math.Truncate(order.Amount).ToString(), ipAddress);
}
break;
case ApprovalOrderType.AccountClosingOrder:
{
AccountClosingOrder order = (AccountClosingOrder)_cacheHelper.SetApprovalOrder(_xbService.GetAccountClosingOrder(x.Key));
CollectParameters(order.Id.ToString(), "0", "0", "0", ipAddress);
}
break;
case ApprovalOrderType.SwiftCopyOrder:
{
SwiftCopyOrder order = (SwiftCopyOrder)_cacheHelper.SetApprovalOrder(_xbService.GetSwiftCopyOrder(x.Key));
if (order.FeeAccount != null)
{
CollectParameters(order.Id.ToString(), order.FeeAccount.AccountNumber.ToString(), "0", Math.Truncate(order.Amount).ToString(), ipAddress);
}
else
{
CollectParameters(order.Id.ToString(), "0", "0", Math.Truncate(order.Amount).ToString(), ipAddress);
}
}
break;
case ApprovalOrderType.CredentialOrder:
{
CredentialOrder order = (CredentialOrder)_cacheHelper.SetApprovalOrder(_xbService.GetCredentialOrder(x.Key));
if (order.Fees != null && order.Fees[0] != null && order.Fees[0].Account != null)
{
CollectParameters(order.Id.ToString(), order.Fees[0].Account.AccountNumber.ToString(), "0", Math.Truncate(order.Amount).ToString(), ipAddress);
}
else
{
CollectParameters(order.Id.ToString(), "0", "0", Math.Truncate(order.Amount).ToString(), ipAddress);
}
}
break;
case ApprovalOrderType.DepositOrder:
{
DepositOrder order = (DepositOrder)_cacheHelper.SetApprovalOrder(_xbService.GetDepositorder(x.Key));
CollectParameters(order.Id.ToString(), order.DebitAccount.AccountNumber.ToString(), "0", Math.Truncate(order.Amount).ToString(), ipAddress);
}
break;
case ApprovalOrderType.AccountOrder:
{
AccountOrder order = (AccountOrder)_cacheHelper.SetApprovalOrder(_xbService.GetAccountOrder(x.Key));
CollectParameters(order.Id.ToString(), "0", "0", order.Currency, ipAddress);
}
break;
case ApprovalOrderType.CashOrder:
{
CashOrder order = (CashOrder)_cacheHelper.SetApprovalOrder(_xbService.GetCashOrder(x.Key));
CollectParameters(order.Id.ToString(), "0", "0", Math.Truncate(order.Amount).ToString(), ipAddress);
}
break;
case ApprovalOrderType.CreditLineTerminationOrder:
{
CreditLineTerminationOrder order = (CreditLineTerminationOrder)_cacheHelper.SetApprovalOrder(_xbService.GetCreditLineTerminationOrder(x.Key));
CollectParameters(order.Id.ToString(), "0", "0", order.Currency, ipAddress);
}
break;
case ApprovalOrderType.CardClosingOrder:
{
CardClosingOrder order = (CardClosingOrder)_cacheHelper.SetApprovalOrder(_xbService.GetCardClosingOrder(x.Key));
CollectParameters(order.Id.ToString(), "0", "0", order.ProductId.ToString(), ipAddress);
}
break;
case ApprovalOrderType.CustomerDataOrder:
{
CustomerDataOrder order = (CustomerDataOrder)_cacheHelper.SetApprovalOrder(_xbService.GetCustomerDataOrder(x.Key));
CollectParameters(order.Id.ToString(), "0", "0", order.Password, ipAddress);
}
break;
case ApprovalOrderType.StatmentByEmailOrder:
{
StatmentByEmailOrder order = (StatmentByEmailOrder)_cacheHelper.SetApprovalOrder(_xbService.GetStatmentByEmailOrder(x.Key));
}
break;
case ApprovalOrderType.DepositTerminationOrder:
{
DepositTerminationOrder order = (DepositTerminationOrder)_cacheHelper.SetApprovalOrder(_xbService.GetDepositTerminationOrder(x.Key));
CollectParameters(order.Id.ToString(), "0", "0", order.ProductId.ToString(), ipAddress);
}
break;
case ApprovalOrderType.ReestrTransferOrder:
{
ReestrTransferOrder order = (ReestrTransferOrder)_cacheHelper.SetApprovalOrder(_xbService.GetReestrTransferOrder(x.Key));
CollectParameters(order.Id.ToString(), order.DebitAccount.AccountNumber.ToString(), "0", Math.Truncate(order.Amount).ToString(), ipAddress);
}
break;
case ApprovalOrderType.ArcaCardsTransactionOrder:
{
ArcaCardsTransactionOrder order = (ArcaCardsTransactionOrder)_cacheHelper.SetApprovalOrder(_xbService.GetArcaCardsTransactionOrder(x.Key));
CollectParameters(order.Id.ToString(), order.CardNumber.Substring(0, 10), "0", "0", ipAddress);
}
break;
case ApprovalOrderType.CardToCardOrder:
{
CardToCardOrder order = (CardToCardOrder)_cacheHelper.SetApprovalOrder(_xbService.GetCardToCardOrder(x.Key));
CollectParameters(order.Id.ToString(), order.DebitCardNumber.Substring(0, 10), order.CreditCardNumber, Math.Truncate(order.Amount).ToString(), ipAddress);
}
break;
case ApprovalOrderType.CardLimitChangeOrder:
{
CardLimitChangeOrder order = (CardLimitChangeOrder)_cacheHelper.SetApprovalOrder(_xbService.GetCardLimitChangeOrder(x.Key));
CollectParameters(order.Id.ToString(), "0", "0", Math.Truncate(order.Limits[0].LimitValue).ToString(), ipAddress);
}
break;
case ApprovalOrderType.PeriodicPaymentOrder:
{
PaymentOrder order = (PaymentOrder)_cacheHelper.SetApprovalOrder(_xbService.GetPaymentOrder(x.Key));
CollectParameters(order.Id.ToString(), order.DebitAccount.AccountNumber.ToString(), "0", Math.Truncate(order.Amount).ToString(), ipAddress);
}
break;
case ApprovalOrderType.InternationalPaymentOrder:
{
InternationalPaymentOrder order = (InternationalPaymentOrder)_cacheHelper.SetApprovalOrder(_xbService.GetInternationalPaymentOrder(x.Key));
CollectParameters(order.Id.ToString(), order.DebitAccount.AccountNumber.ToString(), order.ReceiverAccount.AccountNumber.ToString(),
Math.Truncate(order.Amount).ToString(), ipAddress);
}
break;
case ApprovalOrderType.AccountReOpenOrder:
{
AccountReOpenOrder order = (AccountReOpenOrder)_cacheHelper.SetApprovalOrder(_xbService.GetAccountReOpenOrder(x.Key));
CollectParameters(order.Id.ToString(), "0", "0", "0", ipAddress);
}
break;
case ApprovalOrderType.PlasticCardSmsServiceOrder:
{
PlasticCardSMSServiceOrder order = (PlasticCardSMSServiceOrder)_cacheHelper.SetApprovalOrder(_xbService.GetPlasticCardSMSServiceOrder(x.Key));
CollectParameters(order.Id.ToString(), "0", "0", order.ProductID.ToString(), ipAddress);
}
break;
case ApprovalOrderType.RemovalOrder:
{
RemovalOrder order = context.ActionArguments.Values.First() as RemovalOrder;
CollectParameters("0", order.RemovingOrderId.ToString(), "0", "0", ipAddress);
}
break;
case ApprovalOrderType.PeriodicTerminationOrder:
{
PeriodicTerminationOrder order = (PeriodicTerminationOrder)_cacheHelper.SetApprovalOrder(_xbService.GetPeriodicTerminationOrder(x.Key));
CollectParameters(order.Id.ToString(), "0", "0", order.ProductId.ToString(), ipAddress);
}
break;
case ApprovalOrderType.PeriodicDataChangeOrder:
{
PeriodicTransferDataChangeOrder order = (PeriodicTransferDataChangeOrder)_cacheHelper.SetApprovalOrder(_xbService.GetPeriodicDataChangeOrder(x.Key));
CollectParameters(order.Id.ToString(), "0", "0", order.ProductId.ToString(), ipAddress);
}
break;
case ApprovalOrderType.CardActivationOrder:
{
CollectParameters(x.Key.ToString(), "0", "0", "0", ipAddress);
}
break;
default:
break;
}
}
;
//CheckSign Filter-ն անհրաժեշտ է աշխատի միայն sourceType-ը 5-ի՝ MobileBanking-ի դեպքում
if (sourceType != SourceType.MobileBanking)
{
return;
}
else
{
signData = this.GenerateSignData(TransactionID, SenderAccount, RecepientAccount, Amount, IpAddress);
}
isSigned = _xbSecurityService.SingData(sessionId, otp, signData, language);
//թեստային միջավայրի համար
if ((sessionId == "ba0f312d-8487-445e-aee2-d5877ac1d4de" || otp == "0123456") && Convert.ToBoolean(_config["TestVersion"]))
{
return;
}
if (!isSigned)
{
Response response = new Response();
response.ResultCode = ResultCodes.validationError;
response.Description = (Languages)language == Languages.hy ? "Սխալ PIN կոդ։" : "Incorrect PIN code.";
context.Result = ResponseExtensions.ToHttpResponse(response);
}
}
public Selling Sell([FromBody] Selling selling)
{
using (var transaction = _repository.BeginTransaction())
{
if (selling.Id == 0)
{
throw new PawnshopApplicationException("Сохраните реализацию для регистрации продажи");
}
if (selling.CashOrderId.HasValue)
{
throw new PawnshopApplicationException("Продажа уже зарегистрирована");
}
selling.Status = SellingStatus.Sold;
if (selling.ContractId.HasValue && selling.ContractPositionId.HasValue)
{
var contract = _contractRepository.Get(selling.ContractId.Value);
var position = contract.Positions.SingleOrDefault(p => p.Id == selling.ContractPositionId.Value);
if (position != null)
{
position.Status = ContractPositionStatus.Disposed;
}
if (contract.Positions.All(p => p.Status == ContractPositionStatus.Disposed))
{
contract.Status = ContractStatus.Disposed;
}
_contractRepository.Update(contract);
}
ModelState.Clear();
TryValidateModel(selling);
ModelState.Validate();
var settings = _branchContext.Configuration.CashOrderSettings
.Get(selling.CollateralType).DisposeSettings;
if (!selling.SellingDate.HasValue)
{
throw new PawnshopApplicationException("Поле дата продажи обязательно для заполнения");
}
if (!selling.SellingCost.HasValue)
{
throw new PawnshopApplicationException("Поле стоимость продажи обязательно для заполнения");
}
if (!settings.DebitId.HasValue)
{
throw new PawnshopApplicationException("В настройках организации заполните счет дебет для реализации");
}
if (!settings.CreditId.HasValue)
{
throw new PawnshopApplicationException("В настройках организации заполните счет кредит для реализации");
}
var cashOrder = new CashOrder
{
OrderType = OrderType.CashIn,
OrderNumber = _counterRepository.Next(
OrderType.CashIn, selling.SellingDate.Value.Year,
_branchContext.Branch.Id,
_branchContext.Configuration.CashOrderSettings.CashInNumberCode),
OrderDate = selling.SellingDate.Value,
OrderCost = selling.SellingCost.Value,
DebitAccountId = settings.DebitId.Value,
CreditAccountId = settings.CreditId.Value,
UserId = _sessionContext.UserId,
Reason = $"Продажа изделия {selling.Note}",
RegDate = DateTime.Now,
OwnerId = _branchContext.Branch.Id,
BranchId = _branchContext.Branch.Id,
AuthorId = _sessionContext.UserId
};
_cashOrderRepository.Insert(cashOrder);
selling.CashOrderId = cashOrder.Id;
selling.CashOrder = _cashOrderRepository.Get(cashOrder.Id);
_repository.Update(selling);
transaction.Commit();
}
return(selling);
}
