public IActionResult Update(InvoicePayment model)
{
string note = AppGlobal.InitString;
model.Initialization(InitType.Update, RequestUserID);
int result = _invoicePaymentResposistory.Update(model.Id, model);
if (result > 0)
{
note = AppGlobal.Success + " - " + AppGlobal.EditSuccess;
}
else
{
note = AppGlobal.Success + " - " + AppGlobal.EditFail;
}
return(Json(note));
}
public ActionResult <string> SaveChange(InvoicePayment model)
{
Result routeResult;
int result = 0;
if (model.Id > 0)
{
model.Initialization(InitType.Update, RequestUserID);
result = _invoicePaymentResposistory.Update(model.Id, model);
if (result > 0)
{
routeResult = new Result()
.setResultType(ResultType.Success)
.setMessage(AppGlobal.EditSuccess);
}
else
{
routeResult = new Result()
.setResultType(ResultType.Error)
.setErrorType(ErrorType.EditError)
.setMessage(AppGlobal.EditFail);
}
}
else
{
model.Initialization(InitType.Insert, RequestUserID);
result = _invoicePaymentResposistory.Create(model);
if (result > 0)
{
routeResult = new Result()
.setResultType(ResultType.Success)
.setMessage(AppGlobal.CreateSuccess);
}
else
{
routeResult = new Result()
.setResultType(ResultType.Error)
.setErrorType(ErrorType.InsertError)
.setMessage(AppGlobal.CreateFail);
}
}
return(ObjectToJson(routeResult));
}
public static List <InvoicePayment> GetiInvoicePayments(OINV_Sales sale)
{
lock (Extensions.Locker)
{
var db = ContextFactory.GetDBContext();
var cashAccount = db.PaymentTypes
.FirstOrDefault(p => p.IdPaymentType == 1); // Cuenta para efectivo
var creditAccount = db.PaymentTypes
.FirstOrDefault(p => p.IdPaymentType == 2); // Cuenta para tarjeta..
var TDate = sale.DocDate;
var pagosaloha = (from inaloha in db.InvoiceALOHAs
where inaloha.Date == TDate
select new
{
alohaid = inaloha.IdInvoiceALOHA,
cash = inaloha.Cash,
credit = inaloha.Credit,
}).FirstOrDefault();
var pagos = new List <InvoicePayment>();
//pago en efectivo
var pagoe = new InvoicePayment();
pagoe.WhsCode = Config.WhsCode;
pagoe.Amount = pagosaloha.cash;
pagoe.PaymentType = cashAccount;
pagos.Add(pagoe);
//pago tarjeta
var pagot = new InvoicePayment();
pagot.WhsCode = Config.WhsCode;
pagot.Amount = pagosaloha.credit;
pagot.PaymentType = creditAccount;
pagos.Add(pagot);
return(pagos);
}
}
public BillingInvoiceViewModel()
{
Amount = "Zero";
Message = "";
Invoice = new Invoice();
Payment = new InvoicePayment();
Details = new List <InvoiceDetails>();
Tendered = new List <InvoicePaymentDetails>();
Payments = new List <InvoicePaymentDetails>();
//Initialize Items
for (int i = 0; i < 20; i++)
{
Payments.Add(new InvoicePaymentDetails());
}
Modes = new List <SelectListItem>();
}
public static InvoicePayment Create(InvoicePaymentAddModel model, string depositFrom, decimal amount, string userId)
{
var invoicePayment = new InvoicePayment()
{
InvoiceId = model.InvoiceId,
PaymentMode = model.PaymentMode,
BankAccountId = model.BankAccountId,
ChequeNumber = model.ChequeNumber,
DepositFrom = depositFrom,
Amount = amount,
PaymentDate = model.PaymentDate,
Description = model.Description,
Status = Constants.RecordStatus.Active,
CreatedBy = userId ?? "0",
CreatedOn = Utility.GetDateTime()
};
return(invoicePayment);
}
public async Task Create_WithInvalidApiKey_ShouldThrowNotAuthorizedException()
{
//arrange
var http = A.Fake <IHttpClient>();
var sut = GetSystemUnderTest(http);
var expectedRequestUri = new Uri("/api/invoice-payments", UriKind.Relative);
A.CallTo(() => http.PostAsync(expectedRequestUri, A <string> .Ignored, A <CancellationToken> .Ignored))
.ThrowsAsync(ExceptionFactory.CreateNotAuthorizedException);
var model = new InvoicePayment {
InvoiceId = 1, Amount = 17f
};
await Assert.ThrowsAsync <NotAuthorizedException>(() => sut.CreatePaymentAsync(model));
A.CallTo(() => http.PostAsync(expectedRequestUri, A <string> .Ignored, A <CancellationToken> .Ignored))
.MustHaveHappenedOnceExactly();
}
public static void OnTransactionConfirmed(JToken jsonParams)
{
TransactionConfirmedModel model = jsonParams.ToObject <TransactionConfirmedModel>();
using (DBEntities dbe = new DBEntities())
{
InvoicePayment payment = dbe.InvoicePayment.Include("Invoice").Include("Invoice.CreatedBy").SingleOrDefault(p => p.Address == model.Address && p.CurrencyCode == model.CurrencyCode);
if (payment != null)
{
double amountRequired = GetAmountRequired(payment.Invoice.FiatAmount, (double)payment.ExchangeRate, model.CurrencyCode);
if (model.Amount >= amountRequired)
{
payment.Invoice.State = (int)InvoiceState.TRANSACTION_CONFIRMED;
payment.Invoice.TransactionId = model.TXID;
payment.Invoice.DateReceived = DateTime.Now;
dbe.SaveChanges();
// send mail
EmailManager.SendMailToPaymentReciever(payment.Invoice, model);
EmailManager.SendMailToPaymentSender(payment.Invoice, model);
}
else
{
var transactionTime = DateTimeOffset.FromUnixTimeSeconds(model.Timestamp).UtcDateTime;
// Special case: if the transaction is less that 3 minutes late, previous exchange rate is still alowed
if (payment.Invoice.ExchangeRateSetTime != null && transactionTime.Subtract(payment.Invoice.ExchangeRateSetTime.Value).TotalMinutes < 3)
{
double previousAmountRequired = GetAmountRequired(payment.Invoice.FiatAmount, (double)payment.PreviousExchangeRate, model.CurrencyCode);
if (model.Amount >= previousAmountRequired)
{
payment.Invoice.State = (int)InvoiceState.TRANSACTION_SEEN;
payment.Invoice.TransactionId = model.TXID;
dbe.SaveChanges();
}
}
}
}
}
}
public static void OnTransactionSeen(JToken jsonParams)
{
TransactionSeenModel model = jsonParams.ToObject <TransactionSeenModel>();
//check if theres invoice with the same address and currencycode + amount in invoice is >= amount received
using (DBEntities dbe = new DBEntities())
{
InvoicePayment payment = dbe.InvoicePayment.Include("Invoice").SingleOrDefault(p => p.Address == model.Address && p.CurrencyCode == model.CurrencyCode);
if (payment != null)
{
double amountRequired = GetAmountRequired(payment.Invoice.FiatAmount, (double)payment.ExchangeRate, model.CurrencyCode);
if (payment.Invoice.State == (int)InvoiceState.NOT_PAID)
{
if (model.Amount >= amountRequired)
{
payment.Invoice.State = (int)InvoiceState.TRANSACTION_SEEN;
payment.Invoice.TransactionId = model.TXID;
dbe.SaveChanges();
}
else
{
var transactionTime = DateTimeOffset.FromUnixTimeSeconds(model.Timestamp).UtcDateTime;
// Special case: if the transaction is less that 3 minutes late, previous exchange rate is still alowed
if (payment.Invoice.ExchangeRateSetTime != null && transactionTime.Subtract(payment.Invoice.ExchangeRateSetTime.Value).TotalMinutes < 3)
{
double previousAmountRequired = GetAmountRequired(payment.Invoice.FiatAmount, (double)payment.PreviousExchangeRate, model.CurrencyCode);
if (model.Amount >= previousAmountRequired)
{
payment.Invoice.State = (int)InvoiceState.TRANSACTION_SEEN;
payment.Invoice.TransactionId = model.TXID;
dbe.SaveChanges();
}
}
}
}
}
}
}
private void AddPaymentClick(object sender, EventArgs eventArgs)
{
PaymentDialog d = new PaymentDialog(invoice);
if (d.ShowDialog(this) != DialogResult.OK)
{
return;
}
InvoicePayment ip = d.Payment;
NameValueCollection data = new NameValueCollection();
data.Add("invoiceID", invoice.ID);
data.Add("amount", ip.Amount);
data.Add("date", ip.Date.ToString("yyyy-MM-dd"));
data.Add("comment", ip.Comment);
data.Add("houseID", house.ID);
Invoice i = Caller.Post <Invoice>("AddInvoicePayment", data);
if (i != null)
{
gui.ShowCurrent();
}
}
public static bool SetInvoicePaymentSerial(InvoicePayment invoicePayment)
{
if (invoicePayment == null)
{
return(false);
}
if (IsInvoicePaymentHasSerial(invoicePayment))
{
return(true);
}
string nextSerial = FinancialBusinessLogicLibrary.GetNextMedicalInvoiceSerial();
if (string.IsNullOrEmpty(nextSerial) || string.IsNullOrWhiteSpace(nextSerial))
{
return(false);
}
invoicePayment.PaymentSerial = nextSerial;
return(true);
}
public async Task GetById_WithValidInputValue_ShouldReturnCorrectValue()
{
//arrange
const int id = 872254;
var expectedRequestUri = new Uri($"/api/invoice-payments/{id}", UriKind.Relative);
const string responseBody = "{\"invoice-payment\":{\"id\":\"872254\",\"created\":\"2015-06-04T09:51:54+02:00\",\"invoice_id\":\"1220304\",\"user_id\":\"52821\",\"date\":\"2015-05-04\",\"amount\":\"-17\",\"comment\":\"\",\"transaction_purpose\":\"\",\"currency_code\":\"\",\"quote\":\"1\",\"type\":\"\",\"customfield\":\"\"}}";
var expectedResult = new InvoicePayment
{
Id = 872254,
Created = DateTime.Parse("2015-06-04T09:51:54+02:00", CultureInfo.InvariantCulture),
InvoiceId = 1220304,
UserId = 52821,
Date = DateTime.Parse("2015-05-04", CultureInfo.InvariantCulture),
Amount = -17f,
Comment = "",
TransactionPurpose = "",
CurrencyCode = "",
Quote = 1,
MarkInvoiceAsPaid = true
};
var http = A.Fake <IHttpClient>();
A.CallTo(() => http.GetAsync(expectedRequestUri, A <CancellationToken> .Ignored))
.Returns(Task.FromResult(responseBody));
var sut = GetSystemUnderTest(http);
//act
var result = await sut.GetPaymentByIdAsync(id);
//assert
A.CallTo(() => http.GetAsync(expectedRequestUri, A <CancellationToken> .Ignored))
.MustHaveHappenedOnceExactly();
result.Should().BeEquivalentTo(expectedResult);
}
public static void AddInvoicePayment(InvoicePayment payment)
{
SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString);
SqlCommand command;
connection.Open();
try
{
command = connection.CreateCommand();
command.CommandText = "INSERT INTO UnileverInvoiceTrackingSystem.dbo.invoicepayment (invoiceno, paymentstatus, amountreceived, balance, paymentremarks, paiddate) VALUES (@IN,@PS,@AR,@B,@PR,@PD);";
command.Parameters.AddWithValue("@IN", Convert.ToInt64(payment.InvoiceNo));
command.Parameters.AddWithValue("@PS", Convert.ToString(payment.PaymentStatus));
command.Parameters.AddWithValue("@AR", Convert.ToDecimal(payment.AmountReceived));
command.Parameters.AddWithValue("@B", Convert.ToDecimal(payment.Balance));
command.Parameters.AddWithValue("@PR", Convert.ToString(payment.PaymentRemarks));
command.Parameters.AddWithValue("@PD", DBNull.Value);
command.ExecuteNonQuery();
}
catch (Exception)
{
throw;
}
finally
{
if (connection.State == ConnectionState.Open)
{
connection.Close();
}
}
}
public JsonResult GetInvoicesByPatientId(long id, long statusid, string DateStart, string DateEnd, long?invoiceId = null)
{
List <PatientInvoice> onlypatientInvoices = new List <PatientInvoice>();
List <PatientInvoice> patientInvoices;
DateTime invoiceDateStart = DateTime.Parse("1/1/1980");
DateTime invoiceDateEnd = DateTime.Today;
if (IsDate(DateEnd) && IsDate(DateStart))
{
invoiceDateStart = DateTime.Parse(DateStart);
invoiceDateEnd = DateTime.Parse(DateEnd);
}
using (PatientInvoiceRepository repository = new PatientInvoiceRepository())
{
/* ParameterExpression argParam = Expression.Parameter(typeof(PatientInvoice), "s");
* Expression patientProperty = Expression.Property(argParam, "PatientID");
* Expression statusProperty = Expression.Property(argParam, "InvoiceStatusId");
*
* var val1 = Expression.Constant(id);
* var val2 = Expression.Constant(statusid);
*
* Expression e1 = Expression.Equal(patientProperty, val1);
* Expression e2 = Expression.Equal(statusProperty, val2);
*
* BinaryExpression andExp;*/
// var andExp = e1;
//var lambda = Expression.Lambda<Func<PatientInvoice, bool>>(andExp, argParam);
Expression <Func <PatientInvoice, bool> > lambda;
if (id == 0)
{
if (statusid == 0)
{
lambda = (x => x.Active == true && x.InvoiceDate >= invoiceDateStart && x.InvoiceDate <= invoiceDateEnd && (invoiceId == null ? x.Id > 0 : x.Id == invoiceId));
}
else
{
lambda = (x => x.InvoiceStatusId == statusid && x.Active == true && x.InvoiceDate >= invoiceDateStart && x.InvoiceDate <= invoiceDateEnd && (invoiceId == null ? x.Id > 0 : x.Id == invoiceId));
}
}
else
{
if (statusid == 0)
{
lambda = (x => x.PatientID == id && x.Active == true && x.InvoiceDate >= invoiceDateStart && x.InvoiceDate <= invoiceDateEnd && (invoiceId == null ? x.Id > 0 : x.Id == invoiceId));
}
else
{
lambda = (x => x.PatientID == id && x.Active == true && x.InvoiceStatusId == statusid && x.InvoiceDate >= invoiceDateStart && x.InvoiceDate <= invoiceDateEnd && (invoiceId == null ? x.Id > 0 : x.Id == invoiceId));
}
}
patientInvoices = repository.GetByQuery(lambda).ToList();
patientInvoices = patientInvoices.OrderByDescending(x => x.InvoiceDate).ToList();
foreach (PatientInvoice pinvoice in patientInvoices)
{
PatientInvoice onlyPatientInvoice = new PatientInvoice();
Patient patient = new Patient();
onlyPatientInvoice.Patient = patient;
onlyPatientInvoice.Id = pinvoice.Id;
onlyPatientInvoice.InvoiceDate = pinvoice.InvoiceDate;
onlyPatientInvoice.DueDate = pinvoice.DueDate;
onlyPatientInvoice.PatientID = pinvoice.PatientID;
onlyPatientInvoice.TotalAmount = pinvoice.TotalAmount;
onlyPatientInvoice.TotalDiscount = pinvoice.TotalDiscount;
onlyPatientInvoice.InvoiceStatusId = pinvoice.InvoiceStatusId;
onlyPatientInvoice.ItemDiscount = pinvoice.ItemDiscount;
onlyPatientInvoice.UserId = pinvoice.UserId;
onlyPatientInvoice.LabStatusId = pinvoice.LabStatusId;
onlyPatientInvoice.IsRefunded = pinvoice.IsRefunded;
onlyPatientInvoice.Patient.FirstName = pinvoice.Patient.FirstName;
onlyPatientInvoice.Patient.LastName = pinvoice.Patient.LastName;
onlyPatientInvoice.UserId = GetLoggedinUserInfo().UserId;
foreach (InvoicePayment invoicepayment in pinvoice.InvoicePayments)
{
InvoicePayment invoicePayment = new InvoicePayment();
invoicePayment.Id = invoicepayment.Id;
invoicePayment.PatientInvoiceId = invoicepayment.PatientInvoiceId;
invoicePayment.Amount = invoicepayment.Amount;
invoicePayment.PaymentID = invoicepayment.PaymentID;
invoicePayment.UserId = invoicepayment.UserId;
onlyPatientInvoice.InvoicePayments.Add(invoicePayment);
}
foreach (PatientService c in pinvoice.PatientServices)
{
PatientService patientstitem = new PatientService();
Item item = new Item();
ItemCategory Category = new ItemCategory();
patientstitem.Item = item;
patientstitem.Item.ItemCategory = Category;
patientstitem.Id = c.Id;
patientstitem.PatientID = c.PatientID;
patientstitem.ItemId = c.ItemId;
patientstitem.InvoiceID = c.InvoiceID;
patientstitem.ReceiptId = c.ReceiptId;
patientstitem.PatientAdmissionId = c.PatientAdmissionId;
patientstitem.ServiceListPrice = c.ServiceListPrice;
patientstitem.ServiceActualPrice = c.ServiceActualPrice;
patientstitem.ServiceQuantity = c.ServiceQuantity;
patientstitem.ServiceDate = c.ServiceDate;
patientstitem.UserId = c.UserId;
patientstitem.Discount = c.Discount;
patientstitem.DiscountAfterInvoice = c.DiscountAfterInvoice;
patientstitem.Refund = c.Refund;
patientstitem.RefundNote = c.RefundNote;
patientstitem.Billed = c.Billed;
patientstitem.LabStatusId = c.LabStatusId;
patientstitem.ReferralFee = c.ReferralFee;
patientstitem.DeliveryDate = c.DeliveryDate;
patientstitem.DeliveryTime = c.DeliveryTime;
patientstitem.Item.Name = c.Item.Name;
patientstitem.Item.GenericName = c.Item.GenericName;
if (c.Item.ItemCategory != null)
{
patientstitem.Item.ItemCategory.Name = c.Item.ItemCategory.Name;
}
patientstitem.Item.ReferralAllowed = c.Item.ReferralAllowed;
patientstitem.ReferralFeePaid = c.ReferralFeePaid;
patientstitem.ServiceProviderId = c.ServiceProviderId;
patientstitem.UserId = GetLoggedinUserInfo().UserId;
onlyPatientInvoice.PatientServices.Add(patientstitem);
}
onlypatientInvoices.Add(onlyPatientInvoice);
}
if (onlypatientInvoices == null)
{
return(Json(HttpNotFound(), JsonRequestBehavior.AllowGet));
}
return(Json(onlypatientInvoices, JsonRequestBehavior.AllowGet));
}
}
/// <summary>
/// Updates an invoice payment
/// </summary>
/// <param name="invoicePayment">The invoice payment to update</param>
/// <returns>The updated invoice payment</returns>
public InvoicePayment Update(InvoicePayment invoicePayment)
{
return(BaseUpdate(invoicePayment, invoicePayment.Number));
}
public static bool IsInvoicePaymentHasSerial(InvoicePayment invoicePayment)
{
return(invoicePayment != null && invoicePayment.PaymentSerial != null);
}
public async Task Test_InvoicePayment_CRUD()
{
#region Arrange
var tmpCustomer = await FortnoxClient.CustomerConnector.CreateAsync(new Customer()
{
Name = "TmpCustomer", CountryCode = "SE", City = "Testopolis"
});
var tmpArticle = await FortnoxClient.ArticleConnector.CreateAsync(new Article()
{
Description = "TmpArticle", Type = ArticleType.Stock, PurchasePrice = 10
});
var invoiceConnector = FortnoxClient.InvoiceConnector;
var tmpInvoice = await invoiceConnector.CreateAsync(new Invoice()
{
CustomerNumber = tmpCustomer.CustomerNumber,
InvoiceDate = new DateTime(2020, 1, 20),
DueDate = new DateTime(2020, 6, 20),
InvoiceRows = new List <InvoiceRow>()
{
new InvoiceRow()
{
ArticleNumber = tmpArticle.ArticleNumber, DeliveredQuantity = 2, Price = 10
},
}
});
await invoiceConnector.BookkeepAsync(tmpInvoice.DocumentNumber);
#endregion Arrange
var connector = FortnoxClient.InvoicePaymentConnector;
#region CREATE
var newInvoicePayment = new InvoicePayment()
{
InvoiceNumber = tmpInvoice.DocumentNumber,
Amount = 10.5m,
AmountCurrency = 10.5m,
PaymentDate = new DateTime(2020, 2, 1)
};
var createdInvoicePayment = await connector.CreateAsync(newInvoicePayment);
Assert.AreEqual("2020-02-01", createdInvoicePayment.PaymentDate?.ToString(ApiConstants.DateFormat));
#endregion CREATE
#region UPDATE
createdInvoicePayment.PaymentDate = new DateTime(2020, 3, 1);
var updatedInvoicePayment = await connector.UpdateAsync(createdInvoicePayment);
Assert.AreEqual("2020-03-01", updatedInvoicePayment.PaymentDate?.ToString(ApiConstants.DateFormat));
#endregion UPDATE
#region READ / GET
var retrievedInvoicePayment = await connector.GetAsync(createdInvoicePayment.Number);
Assert.AreEqual("2020-03-01", retrievedInvoicePayment.PaymentDate?.ToString(ApiConstants.DateFormat));
#endregion READ / GET
#region DELETE
await connector.DeleteAsync(createdInvoicePayment.Number);
await Assert.ThrowsExceptionAsync <FortnoxApiException>(
async() => await connector.GetAsync(createdInvoicePayment.Number),
"Entity still exists after Delete!");
#endregion DELETE
#region Delete arranged resources
//Can't cancel invoice after it is booked
//FortnoxClient.InvoiceConnector.Cancel(tmpInvoice.DocumentNumber);
//FortnoxClient.CustomerConnector.Delete(tmpCustomer.CustomerNumber);
//FortnoxClient.ArticleConnector.Delete(tmpArticle.ArticleNumber);
#endregion Delete arranged resources
}
/// <summary>
/// Creates a new invoicePayment
/// </summary>
/// <param name="invoicePayment">The invoicePayment to create</param>
/// <returns>The created invoicePayment</returns>
public InvoicePayment Create(InvoicePayment invoicePayment)
{
return(CreateAsync(invoicePayment).Result);
}
public async Task <InvoicePayment> CreateAsync(InvoicePayment invoicePayment)
{
return(await BaseCreate(invoicePayment));
}
protected void InvoiceRecordButton_Click(object sender, EventArgs e)
{
DateTime duedate;
duedate = Convert.ToDateTime(InvoiceDateTextBox.Text);
duedate = duedate.AddDays(40);
InvoiceDetail invoiceentry = new InvoiceDetail();
InvoicePayment invoicepayment = new InvoicePayment();
ShortageDetails shortagedetail = new ShortageDetails();
invoiceentry.InvoiceNo = Convert.ToInt64(InvoiceNoTextBox.Text);
invoiceentry.InvoiceTerritory = getterritory();
invoiceentry.InvoiceRegion = InvoiceRegionDropDownList.SelectedValue;
invoiceentry.InvoiceDate = Convert.ToDateTime(InvoiceDateTextBox.Text).Date;
invoiceentry.InvoiceDueDate = duedate.Date;
invoiceentry.InvoiceAging = Convert.ToInt32((DateTime.Now.Date - Convert.ToDateTime(InvoiceDateTextBox.Text).Date).TotalDays);
invoiceentry.NPA = Convert.ToDecimal(NetAmountTextBox.Text);
invoiceentry.SC = ShortageCommentsDropDownList.SelectedValue;
InvoiceDetailHandler.AddInvoiceDetail(invoiceentry);
invoicepayment.InvoiceNo = Convert.ToInt64(InvoiceNoTextBox.Text);
invoicepayment.PaymentStatus = "Non-Paid";
invoicepayment.AmountReceived = Convert.ToDecimal("0.00");
invoicepayment.Balance = Convert.ToDecimal("0.00");
invoicepayment.PaymentRemarks = "Under Progress";
InvoicePaymentHandler.AddInvoicePayment(invoicepayment);
shortagedetail.InvoiceNo = Convert.ToInt64(InvoiceNoTextBox.Text);
shortagedetail.SD = ShortageDetailsTextBox.Text;
ShortageDetailHandler.AddShortageDetail(shortagedetail);
cleardata();
}
public async Task Create(InvoicePayment payment)
{
db.Add(payment);
await context.SaveChangesAsync();
}
public async Task Delete(InvoicePayment payment)
{
payment.DeletedAt = DateTime.Now;
db.Update(payment);
await context.SaveChangesAsync();
}
/// <summary>
/// Create a new invoice payment
/// </summary>
/// <param name="invoicePayment">The invoice payment to be created</param>
/// <returns>The created invoice payment</returns>
public InvoicePayment Create(InvoicePayment invoicePayment)
{
return(BaseCreate(invoicePayment));
}
private void CreateInvoice()
{
if (!Page.IsPostBack && Request.QueryString["i"] != null)
{
var oInvoicePayment = new InvoicePayment();
oInvoicePayment.Number = Request.QueryString["i"];
_invoicePayments.Add(oInvoicePayment);
}
else
{
_invoicePayments.Add(new InvoicePayment());
}
}
public InvoicePayment Delete(InvoicePayment domain)
{
Delete(domain.Id);
return(domain);
}
public void AddInvoicePayment(InvoicePayment invoicePayment)
{
UnitOfWork.InvoicePaymentRepository.Add(invoicePayment);
}
public static async Task <InvoicePayment> UpdateInvoicePaymentAsync(FortnoxApiRequest request, string invoicePaymentNumber, InvoicePayment invoicePayment)
{
var apiRequest =
new FortnoxApiClientRequest <SingleResource <InvoicePayment> >(HttpMethod.Put, request.AccessToken, request.ClientSecret,
$"{ApiEndpoints.InvoicePayments}/{invoicePaymentNumber}")
{
Data = new SingleResource <InvoicePayment> {
Data = invoicePayment
}
};
return((await FortnoxAPIClient.CallAsync <SingleResource <InvoicePayment>, SingleResource <InvoicePayment> >(apiRequest)).Data);
}
public void Test_InvoicePayment_CRUD()
{
#region Arrange
var tmpCustomer = new CustomerConnector().Create(new Customer()
{
Name = "TmpCustomer", CountryCode = "SE", City = "Testopolis"
});
var tmpArticle = new ArticleConnector().Create(new Article()
{
Description = "TmpArticle", Type = ArticleType.Stock, PurchasePrice = 10
});
var invoiceConnector = new InvoiceConnector();
var tmpInvoice = invoiceConnector.Create(new Invoice()
{
CustomerNumber = tmpCustomer.CustomerNumber,
InvoiceDate = new DateTime(2020, 1, 20),
DueDate = new DateTime(2020, 6, 20),
InvoiceRows = new List <InvoiceRow>()
{
new InvoiceRow()
{
ArticleNumber = tmpArticle.ArticleNumber, DeliveredQuantity = 2, Price = 10
},
}
});
invoiceConnector.Bookkeep(tmpInvoice.DocumentNumber);
MyAssert.HasNoError(invoiceConnector);
#endregion Arrange
IInvoicePaymentConnector connector = new InvoicePaymentConnector();
#region CREATE
var newInvoicePayment = new InvoicePayment()
{
InvoiceNumber = tmpInvoice.DocumentNumber,
Amount = 10.5m,
AmountCurrency = 10.5m,
PaymentDate = new DateTime(2020, 2, 1)
};
var createdInvoicePayment = connector.Create(newInvoicePayment);
MyAssert.HasNoError(connector);
Assert.AreEqual("2020-02-01", createdInvoicePayment.PaymentDate?.ToString(APIConstants.DateFormat));
#endregion CREATE
#region UPDATE
createdInvoicePayment.PaymentDate = new DateTime(2020, 3, 1);
var updatedInvoicePayment = connector.Update(createdInvoicePayment);
MyAssert.HasNoError(connector);
Assert.AreEqual("2020-03-01", updatedInvoicePayment.PaymentDate?.ToString(APIConstants.DateFormat));
#endregion UPDATE
#region READ / GET
var retrievedInvoicePayment = connector.Get(createdInvoicePayment.Number);
MyAssert.HasNoError(connector);
Assert.AreEqual("2020-03-01", retrievedInvoicePayment.PaymentDate?.ToString(APIConstants.DateFormat));
#endregion READ / GET
#region DELETE
connector.Delete(createdInvoicePayment.Number);
MyAssert.HasNoError(connector);
retrievedInvoicePayment = connector.Get(createdInvoicePayment.Number);
Assert.AreEqual(null, retrievedInvoicePayment, "Entity still exists after Delete!");
#endregion DELETE
#region Delete arranged resources
new CustomerConnector().Delete(tmpCustomer.CustomerNumber);
new ArticleConnector().Delete(tmpArticle.ArticleNumber);
#endregion Delete arranged resources
}
public async Task <InvoicePayment> CreateAsync(InvoicePayment invoicePayment)
{
return(await BaseCreate(invoicePayment).ConfigureAwait(false));
}
public int Payment(CustomerInvoicePaymentModel customerInvoicePaymentModel)
{
int Id = 0;
_serverContext.Database.BeginTransaction();
var Invoice = (from a in _serverContext.LedgerMasters
where a.SubsidiaryLedgerAccountId == customerInvoicePaymentModel.CustomerId
select new { a.SubsidiaryLedgerAccountId });
try
{
InvoicePayment invoice = new InvoicePayment();
//invoice.LedgerMasterId = customerInvoicePaymentModel.LedgerMasterId;
invoice.SubsidiaryLedgerAccountId = customerInvoicePaymentModel.CustomerId;
invoice.InvoicePaymentAmount = customerInvoicePaymentModel.InvoiceAmount;
invoice.ChartOfAccountId = customerInvoicePaymentModel.ChartOfAccountId;
invoice.InvoicePaymentReferenceNo = customerInvoicePaymentModel.ReferenceNo;
invoice.InvoicePaymentDate = customerInvoicePaymentModel.PaymentDate;
invoice.InvoicePaymentCreatedDate = DateTime.Now;
_serverContext.InvoicePayments.Add(invoice);
invoice.InvoicePaymentModifiedDate = DateTime.Now;
_serverContext.SaveChanges();
Id = invoice.Id;
foreach (CustomerInvoicePostPaymentItemModel item in customerInvoicePaymentModel.Items)
{
InvoicePaymentDetail invoicePaymentDetail = new InvoicePaymentDetail();
invoicePaymentDetail.InvoicePaymentId = Id;
invoicePaymentDetail.LedgerMasterId = item.Id;
invoicePaymentDetail.InvoicePaymentDetailAmount = item.Amount;
_serverContext.InvoicePaymentDetails.Add(invoicePaymentDetail);
_serverContext.SaveChanges();
}
foreach (var item in customerInvoicePaymentModel.Items)
{
GeneralLedger generalLedger = new GeneralLedger
{
SubsidiaryLedgerAccountId = customerInvoicePaymentModel.CustomerId,
GeneralLedgerInvoiceNo = string.Empty,
GeneralLedgerDate = customerInvoicePaymentModel.PaymentDate,
GeneralLedgerReferenceNo = customerInvoicePaymentModel.ReferenceNo,
GeneralLedgerType = "PI",
LedgerMasterId = item.Id
};
_serverContext.GeneralLedgers.Add(generalLedger);
_serverContext.SaveChanges();
GeneralLedgerDetail generalLedgerDetailDebit = new GeneralLedgerDetail();
generalLedgerDetailDebit.ChartOfAccountId = customerInvoicePaymentModel.ChartOfAccountId;
generalLedgerDetailDebit.GeneralLedgerDetailMode = "D";
generalLedgerDetailDebit.GeneralLedgerId = generalLedger.Id;
generalLedgerDetailDebit.GeneralLedgerDetailAmount = item.Amount;
generalLedgerDetailDebit.GeneralLedgerDetailDescription = string.Empty;
_serverContext.GeneralLedgerDetails.Add(generalLedgerDetailDebit);
_serverContext.SaveChanges();
GeneralLedgerDetail generalLedgerDetailCredit = new GeneralLedgerDetail();
generalLedgerDetailCredit.ChartOfAccountId = ARTradeKey;
generalLedgerDetailCredit.GeneralLedgerDetailMode = "C";
generalLedgerDetailCredit.GeneralLedgerId = generalLedger.Id;
generalLedgerDetailCredit.GeneralLedgerDetailAmount = item.Amount;
generalLedgerDetailCredit.GeneralLedgerDetailDescription = string.Empty;
_serverContext.GeneralLedgerDetails.Add(generalLedgerDetailCredit);
_serverContext.SaveChanges();
}
_serverContext.Database.CommitTransaction();
}
catch (Exception ex)
{
_serverContext.Database.RollbackTransaction();
}
return(Id);
}
public async Task <InvoicePayment> UpdateAsync(InvoicePayment invoicePayment)
{
return(await BaseUpdate(invoicePayment, invoicePayment.Number.ToString()).ConfigureAwait(false));
}
public ActionResult ChequeRealize(ChequeRealizeViewModel model)
{
if (ModelState.IsValid)
{
int GeneralLedgerHeadId = (int)db.BankAccountLedgerHeads.Find(1).GeneralLedgerHeadId;
GeneralLedger glObj = new GeneralLedger {
Amount = model.Amount, ApplicationUserId = User.Identity.GetUserId(), GeneralLedgerHeadId = GeneralLedgerHeadId, Notes = model.RealizationRemarks + " - " + model.Remarks + " - " + "Cheque Realization", PaymentMethods = PaymentMethod.Cheque, StatementTypes = TransactionType.Income, SysDateTime = DateTime.Now, GeneralLedgerType = LedgerType.Credit
};
db.GeneralLedgers.Add(glObj);
db.SaveChanges();
Agent agent = db.Agents.Find(model.Agents.Id);
agent.Balance = (agent.Balance - model.Amount);
db.Entry(agent).State = EntityState.Modified;
db.SaveChanges();
AgentLedger alObj = new AgentLedger {
AgentId = model.Agents.Id, AgentLedgerHeadId = 3, Amount = model.Amount, ApplicationUserId = glObj.ApplicationUserId, Balance = agent.Balance, Remarks = glObj.Notes, SystemDate = glObj.SysDateTime
};
db.AgentLedgers.Add(alObj);
db.SaveChanges();
BankAccount baObj = db.BankAccounts.Find(model.BankAccountId);
baObj.Balance = (baObj.Balance + model.Amount);
db.Entry(baObj).State = EntityState.Modified;
db.SaveChanges();
BankAccountLedger bclObj = new BankAccountLedger {
Amount = model.Amount, ApplicationUserId = glObj.ApplicationUserId, Balance = baObj.Balance, BankAccountId = model.BankAccountId, BankAccountLedgerHeadId = 1, LedgerTypes = LedgerType.Credit, Notes = glObj.Notes, PaymentMethods = PaymentMethod.Cheque, RelationId = null, SysDateTime = glObj.SysDateTime
};
db.BankAccountLedgers.Add(bclObj);
db.SaveChanges();
InvoicePayment ipObj = new InvoicePayment {
Amount = model.Amount, ApplicationUserId = glObj.ApplicationUserId, GeneralLedgerId = glObj.Id, InvoiceId = model.InvoiceId, PaymentMethods = PaymentMethod.Cheque, Remarks = model.RealizationRemarks + " - " + model.Remarks + " - " + "Cheque Realization", SysDateTime = glObj.SysDateTime, AgentLedgerId = alObj.Id, BankAccountLedgerId = bclObj.Id
};
db.InvoicePayments.Add(ipObj);
db.SaveChanges();
InvoiceLog ilObj = new InvoiceLog {
ApplicationUserId = glObj.ApplicationUserId, InvoiceId = model.InvoiceId, Remarks = "Payment Received by Cheque Transaction - Realization", SysDateTime = glObj.SysDateTime
};
db.InvoiceLogs.Add(ilObj);
db.SaveChanges();
IPChequeDetail ipchObj = db.IPChequeDetails.Find(model.IPChequeDetailId);
ipchObj.GeneralLedgerId = glObj.Id;
ipchObj.InvoicePaymentId = ipObj.Id;
ipchObj.BulkPayment = false;
ipchObj.Status = ChequeStatus.Passed;
db.Entry(ipchObj).State = EntityState.Modified;
db.SaveChanges();
bclObj.RelationId = ipchObj.Id;
db.Entry(ipchObj).State = EntityState.Modified;
db.SaveChanges();
FlashMessage.Confirmation("Floating Cheque Realized");
return(RedirectToAction("FloatingCheque", "Accounting"));
}
else
{
return(RedirectToAction("FloatingCheque", "Accounting"));
}
}
/// <summary>
/// Updates a invoicePayment
/// </summary>
/// <param name="invoicePayment">The invoicePayment to update</param>
/// <returns>The updated invoicePayment</returns>
public InvoicePayment Update(InvoicePayment invoicePayment)
{
return(UpdateAsync(invoicePayment).Result);
}
public async Task AddAsync(InvoicePayment entity)
{
await _dataContext.InvoicePayments.AddAsync(entity);
}
/// <summary>
/// Applies a single payment to multiple invoices
/// </summary>
/// <param name="accountId"></param>
/// <param name="invoiceIds"></param>
/// <param name="paymentMethodId"></param>
/// <param name="amount"></param>
/// <param name="type"></param>
/// <returns></returns>
public ResponseHolder ApplyPaymentToMultipleInvoices(String accountId, String[] invoiceIds, String paymentMethodId, Decimal amount, String type)
{
//create payment in draft
Payment payment = new Payment();
payment.Amount = amount;
payment.AmountSpecified = true;
payment.EffectiveDate = DateTime.Now;
payment.EffectiveDateSpecified = true;
payment.AccountId = accountId;
payment.PaymentMethodId = paymentMethodId;
payment.Type = type;
payment.Status = "Draft";
List<ResponseHolder> payCreateRes = zs.Create(new List<zObject> { payment }, false);
foreach (ResponseHolder rh in payCreateRes)
{
if (!rh.Success)
{
return rh;
}
}
List<zObject> ipList = new List<zObject>();
//create invoice payment objects for the invoice amount
foreach(String invId in invoiceIds)
{
ResponseHolder qRes = zs.Query("SELECT id, Amount FROM Invoice WHERE id = '" + invId + "'");
Invoice inv = (Invoice)qRes.Objects[0];
InvoicePayment ip = new InvoicePayment();
ip.AmountSpecified = true;
ip.Amount = inv.Amount;
ip.InvoiceId = inv.Id;
ip.PaymentId = payCreateRes[0].Id;
ipList.Add(ip);
}
List<ResponseHolder> ipCreateRes = zs.Create(ipList, false);
foreach (ResponseHolder rh in ipCreateRes)
{
if (!rh.Success)
{
return rh;
}
}
//update the original payment to be Proccessed
Payment updatePayment = new Payment();
updatePayment.Id = payCreateRes[0].Id;
updatePayment.Status = "Processed";
List<ResponseHolder> updateRes = zs.Update(new List<zObject>{ updatePayment });
return updateRes[0];
}
