public ActionResult ChangeAmount(ChangeAmountModel model)
{
if ((model.AccountTransactionType == AccountTransactionType.Withdrawn || model.AccountTransactionType == AccountTransactionType.Reduction) &&
model.NewAmount > model.CurrentAmount)
{
return(Json(new { IsValid = false, ReferenceNumber = model.ReferenceNumber, Amount = model.NewAmount, ErrorMessage = "New Amount cannot be more than the Current Amount." }));
}
model.TerminalName = "IMS";
model.ApprovedDate = DateTime.Now;
model.ReferenceTransactionType = ReferenceTransactionType.Representation;
try
{
var fineService = new FineService(AuthenticatedUser.SessionToken);
fineService.ChangeAmount(model);
PaymentSummary paymentSummary = Session["PaymentSummary"] as PaymentSummary;
paymentSummary.Fines.Single(f => f.ReferenceNumber == model.ReferenceNumber).OutstandingAmount = model.NewAmount;
Session["PaymentSummary"] = paymentSummary;
return(Json(new { IsValid = true, ReferenceNumber = model.ReferenceNumber, Amount = model.NewAmount, ErrorMessage = string.Empty }));
}
catch (GatewayException ex)
{
return(Json(new { IsValid = false, ReferenceNumber = model.ReferenceNumber, Amount = model.NewAmount, ErrorMessage = ex.Message }));
}
}
public void ChangeAmount(ChangeAmountModel model)
{
var request = new RestRequest("/api/Fine/Amount", Method.PUT);
request.AddJsonBody(model);
var response = RestClient.Execute(request);
if (response.StatusCode != HttpStatusCode.OK)
{
throw CreateException(response);
}
}
public async Task <IActionResult> ChangeAmount([FromBody] ChangeAmountModel model)
{
Item item = await _context.Items.FirstOrDefaultAsync(x => x.ItemId == Guid.Parse(model.ItemId));
if (item != null)
{
item.ItemsAmount = model.Amount;
_context.Items.Update(item);
await _context.SaveChangesAsync();
return(Ok());
}
else
{
return(BadRequest());
}
}
public async Task <IHttpActionResult> ChangeAmount(ChangeAmountModel model)
{
using (var dbContext = new DataContext())
{
var credential = dbContext.Credentials.FirstOrDefault(f => f.UserName == model.UserName);
if (credential == null)
{
return(this.BadRequestEx(Error.CredentialNotFound));
}
if ((credential.Password != model.Password) && (model.Password.ToUpper() != MessageDigest.HashSHA256(credential.Password)))
{
return(this.BadRequestEx(Error.PasswordIncorrect));
}
if (credential.Status != Core.Data.Enums.Status.Active)
{
return(this.BadRequestEx(Error.CredentialNotActive));
}
if (credential.ExpiryTimeStamp < DateTime.Now)
{
return(this.BadRequestEx(Error.PasswordHasExpired));
}
var offenceRegister = dbContext.OffenceRegister
.AsNoTracking()
.Include(f => f.EvidenceLog)
.Include(f => f.EvidenceLog.ChargeInfos)
.FirstOrDefault(f => f.ReferenceNumber == model.ReferenceNumber);
if (offenceRegister == null)
{
return(this.BadRequestEx(Error.RegisterItemDoesNotExist));
}
var representationTransaction = new RepresentationTransaction();
representationTransaction.RegisterID = offenceRegister.ID;
representationTransaction.ReferenceNumber = offenceRegister.ReferenceNumber;
representationTransaction.Amount = (model.CurrentAmount > model.NewAmount) ? model.NewAmount - model.CurrentAmount : model.CurrentAmount - model.NewAmount;
representationTransaction.Reason = model.ApplicantReason;
representationTransaction.AccountTransactionType = (Core.Data.Enums.AccountTransactionType)model.AccountTransactionType;
representationTransaction.AccountCurrencyType = (Core.Data.Enums.AccountCurrencyType)model.AccountCurrencyType;
representationTransaction.CapturedCredentialID = credential.EntityID;
representationTransaction.CapturedDate = DateTime.Now;
representationTransaction.ResultType = Core.Data.Enums.ResultType.Approved;
representationTransaction.EvaluatedDate = model.ApprovedDate.HasValue ? model.ApprovedDate.Value : DateTime.Now;
representationTransaction.EvaluatedBy = model.ApprovedBy;
representationTransaction.ChargeNumber = 1;
representationTransaction.ChargeCode = offenceRegister.EvidenceLog.ChargeInfos[0].OffenceCode.Code;
representationTransaction.ProcessedDate = DateTime.Now;
representationTransaction.ProcessedTerminalName = model.TerminalName;
representationTransaction.ProcessedCredentialID = credential.EntityID;
dbContext.RepresentationTransactions.Add(representationTransaction);
var generatedReferenceNumber = dbContext.GeneratedReferenceNumbers.First(f => f.ReferenceNumber == model.ReferenceNumber);
var paymentTransaction = dbContext.PaymentTransactions.Include(f => f.TransactionItems).FirstOrDefault(f => f.TransactionToken == generatedReferenceNumber.ExternalToken && f.Status == Kapsch.Core.Data.Enums.PaymentTransactionStatus.Added);
paymentTransaction.Amount = model.NewAmount;
paymentTransaction.TransactionItems.Single().Amount = model.NewAmount;
dbContext.SaveChanges();
var connection = (OracleConnection)dbContext.Database.Connection;
using (var command = new OracleCommand())
{
try
{
if (connection.State != ConnectionState.Open)
{
connection.Open();
}
command.Parameters.Add("P_USER_ID", OracleDbType.Int32).Value = credential.EntityID;
command.Parameters.Add("P_REFERENCE_NUMBER", OracleDbType.Varchar2).Value = model.ReferenceNumber;
command.Parameters.Add("P_ACCOUNT_TRANS_TYPE_ID", OracleDbType.Int32).Value = (int)model.AccountTransactionType;
command.Parameters.Add("P_REFERENCE_TRANSACTION_ID", OracleDbType.Int32).Value = representationTransaction.ID;
command.Parameters.Add("P_REFERENCE_TRANSACTION_TYPEID", OracleDbType.Int32).Value = (int)model.ReferenceTransactionType;
command.Parameters.Add("P_AMOUNT", OracleDbType.Decimal).Value = representationTransaction.Amount;
command.Parameters.Add("O_MESSAGE", OracleDbType.Varchar2, 2056).Direction = ParameterDirection.Output;
ExcecuteNonQuery(command, "FINANCE.FINANCIALS.ADD_VALIDATE_TRANSACTION", connection);
if ((command.Parameters["O_MESSAGE"].Value is DBNull))
{
return(Ok());
}
var message = ((OracleString)command.Parameters["O_MESSAGE"].Value).Value;
if (message != "Success")
{
return(this.BadRequestEx(Error.PopulateMethodFailed(message)));
}
}
catch (Exception ex)
{
return(this.BadRequestEx(Error.PopulateUnexpectedException(ex)));
}
finally
{
foreach (OracleParameter parameter in command.Parameters)
{
if (parameter.Value is IDisposable)
{
((IDisposable)(parameter.Value)).Dispose();
}
parameter.Dispose();
}
}
}
await Task.Run(() =>
{
var paymentProvider = resolvePaymentProvider();
var transactionModel =
new ThirdParty.Payment.Models.TransactionModel
{
CompanyRef = model.ReferenceNumber,
CompanyAccRef = string.Empty,
Amount = model.NewAmount,
UserID = SessionModel.UserName,
ServiceDescription = "Notice issued.",
ServiceType = 6067
};
try
{
paymentProvider.UpdateTransaction(generatedReferenceNumber.ExternalToken, transactionModel);
}
catch (Exception)
{
using (var dataContext = new DataContext())
{
InsertQueueItem(
dataContext,
new PaymentProviderQueueItem
{
CreatedTimestamp = DateTime.Now,
OperationName = "UpdateTransaction",
PaymentProvider = (Kapsch.Core.Data.Enums.PaymentProvider)paymentProvider.ID,
Arguments = JsonConvert.SerializeObject(transactionModel),
QueueStatus = Kapsch.Core.Data.Enums.QueueStatus.Queued,
TransactionToken = generatedReferenceNumber.ExternalToken
});
}
}
});
return(Ok());
}
}
