public void SaveReconcilation(Reconciliation[] recons)
{
foreach (var recon in recons)
{
Reconciliation.SaveReconciliation(recon);
}
}
private static List <Reconciliation> ReadContents(ReconciliationFile rec)
{
var reconciliations = new List <Reconciliation>();
using (var stream = new StreamReader(new MemoryStream(rec.Contents), Encoding.Default))
{
var str = stream.ReadLine();
while (str != null)
{
var flag = str.AsRecordType();
if (flag.ToUpper().Equals("D")) //Detail
{
var recDto = new Reconciliation
{
ReconciliationFileId = rec.Id,
PaymentMethod = rec.FileType,
PaymentCode = str.AsCustomerNoRef1(),
PaymentDate = str.AsPaymentDateTime(),
PaymentBy = str.AsCustomerName(),
Amount = str.AsAmount()
};
reconciliations.Add(recDto);
}
str = stream.ReadLine();
}
}
return(reconciliations);
}
public void AddOrUpdate(Reconciliation reconciliation)
{
if (reconciliation.Id > 0)
{
var dbRecord = UnitOfWork.ReconciliationRepository.GetByIdAsNoTracking(reconciliation.Id);
reconciliation.Created_At = dbRecord.Created_At;
reconciliation.Status = dbRecord.Status;
var reconciliation_Transactions = UnitOfWork.ReconciliationTransactionRepository.Get(x => x.ReconciliationId == reconciliation.Id);
foreach (var reconciliation_Transaction in reconciliation_Transactions)
{
UnitOfWork.ReconciliationTransactionRepository.Delete(reconciliation_Transaction);
UnitOfWork.Save();
}
foreach (var item in reconciliation.Transactions)
{
UnitOfWork.ReconciliationTransactionRepository.Insert(item.MapFrom(reconciliation.Id));
UnitOfWork.Save();
}
reconciliation.Transactions = null;
UnitOfWork.ReconciliationRepository.Update(reconciliation.MapFrom());
}
else
{
reconciliation.Status = ReconciliationStatus.Unreconciled.ToString();
UnitOfWork.ReconciliationRepository.Insert(reconciliation.MapFrom());
}
UnitOfWork.Save();
}
public async Task <InvokedResult> CreateAsync(Reconciliation reconciliation)
{
DbContext.Set <Reconciliation>().AddOrUpdate(reconciliation);
await DbContext.SaveChangesAsync();
return(InvokedResult.SucceededResult);
}
public ActionResult Edit(Reconciliation Reconciliation)
{
Reconciliation oReconciliation = new Reconciliation();
oReconciliation.ReconciliationID = System.Convert.ToInt32(Reconciliation.ReconciliationID);
oReconciliation = ReconciliationData.Select_Record(Reconciliation);
if (ModelState.IsValid)
{
bool bSucess = false;
bSucess = ReconciliationData.Update(oReconciliation, Reconciliation);
if (bSucess == true)
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "Can Not Update");
}
}
// ComboBox
ViewData["InvoiceID"] = new SelectList(Reconciliation_InvoiceData.List(), "InvoiceID", "InvoiceNo", Reconciliation.InvoiceID);
return(View(Reconciliation));
}
public ActionResult Create([Bind(Include =
"InvoiceID"
+ "," + "PaymentDate"
+ "," + "PaymentAmount"
+ "," + "TDSAmount"
+ "," + "Remarks"
)] Reconciliation Reconciliation)
{
if (ModelState.IsValid)
{
bool bSucess = false;
bSucess = ReconciliationData.Add(Reconciliation);
if (bSucess == true)
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "Can Not Insert");
}
}
// ComboBox
ViewData["InvoiceID"] = new SelectList(Reconciliation_InvoiceData.List(), "InvoiceID", "InvoiceNo", Reconciliation.InvoiceID);
return(View(Reconciliation));
}
// GET: /Reconciliation/Edit/<id>
public ActionResult Edit(
Int32?ReconciliationID
)
{
if (
ReconciliationID == null
)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Reconciliation Reconciliation = new Reconciliation();
Reconciliation.ReconciliationID = System.Convert.ToInt32(ReconciliationID);
Reconciliation = ReconciliationData.Select_Record(Reconciliation);
if (Reconciliation == null)
{
return(HttpNotFound());
}
// ComboBox
ViewData["InvoiceID"] = new SelectList(Reconciliation_InvoiceData.List(), "InvoiceID", "InvoiceNo", Reconciliation.InvoiceID);
return(View(Reconciliation));
}
public async Task <InvokedResult> DeleteReconciliationAsync(Reconciliation reconciliation)
{
DbContext.Set <Reconciliation>().Remove(reconciliation);
await DbContext.SaveChangesAsync();
return(InvokedResult.SucceededResult);
}
public List <ReconciliationTransaction> GetTransactionsForReconciliation(Reconciliation reconciliation)
{
try
{
DateTime startDate = new DateTime(); DateTime endDate = new DateTime();
if (string.IsNullOrEmpty(reconciliation.StartDate))
{
startDate = DateTime.Now.StartOfMonth();
}
else
{
startDate = reconciliation.StartDate.ParseStringDate();
}
if (string.IsNullOrEmpty(reconciliation.EndDate))
{
endDate = startDate.EndOfMonth();
}
else
{
endDate = reconciliation.EndDate.ParseStringDate();
}
System.Linq.Expressions.Expression <Func <Tbl_Transaction, bool> > filter =
b =>
b.AccountId == reconciliation.AccountId &&
b.Created_At >= startDate &&
b.Created_At <= endDate;
var transactions = UnitOfWork.TransactionRepository.Get(filter, x => x.OrderByDescending(y => y.Created_At));
return(transactions.Select(x => x.MapForReconciliation()).ToList());
}
catch (Exception)
{
return(new List <ReconciliationTransaction>());
}
}
public IHttpActionResult PutReconciliation(int id, Reconciliation reconciliation)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != reconciliation.Reconciliations_id)
{
return(BadRequest());
}
db.Entry(reconciliation).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ReconciliationExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
// GET: /Reconciliation/Delete/<id>
public ActionResult Delete(
Int32?ReconciliationID
)
{
if (
ReconciliationID == null
)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
dtInvoice = Reconciliation_InvoiceData.SelectAll();
Reconciliation Reconciliation = new Reconciliation();
Reconciliation.ReconciliationID = System.Convert.ToInt32(ReconciliationID);
Reconciliation = ReconciliationData.Select_Record(Reconciliation);
Reconciliation.Invoice = new Invoice()
{
InvoiceID = (Int32)Reconciliation.InvoiceID
, InvoiceNo = (from DataRow rowInvoice in dtInvoice.Rows
where Reconciliation.InvoiceID == (int)rowInvoice["InvoiceID"]
select(String) rowInvoice["InvoiceNo"]).FirstOrDefault()
};
if (Reconciliation == null)
{
return(HttpNotFound());
}
return(View(Reconciliation));
}
public async Task <JsonResult> Stop(StopOrderViewModel stopOrderViewModel)
{
if (!ModelState.IsValid)
{
return(Json(false, data: ErrorToDictionary()));
}
var result = await ChangeStep(new string[] { stopOrderViewModel.OrderId }, OrderStatus.Delete);
if (stopOrderViewModel.DesginAmount <= 0 && stopOrderViewModel.OtherAmount <= 0)
{
return(Json(result));
}
var manager = new ReconciliationManager(User);
var reconciliation = new Reconciliation
{
CustomerId = stopOrderViewModel.CustomerId,
CustomerName = stopOrderViewModel.CustomerName,
Amount = stopOrderViewModel.DesginAmount + stopOrderViewModel.OtherAmount,
CompanyId = User.CompanyId,
Type = ReconciliationType.Arrearage,
Created = DateTime.Now,
CreatorId = User.Id,
Remark = $"{stopOrderViewModel.OrderId}消单," + (stopOrderViewModel.DesginAmount > 0 ? $"设计费用{stopOrderViewModel.DesginAmount}," : "")
+ (stopOrderViewModel.OtherAmount > 0 ? $"其他费用{ stopOrderViewModel.OtherAmount}" : "")
};
await manager.CreateAsync(reconciliation);
return(Json(result));
}
private void DoWork(object state)
{
_logger.LogInformation("Background Service is working. Am available");
if (DateTime.Now.DayOfWeek == DayOfWeek.Saturday)
{
if (haverun2 != DateTime.Now)
{
using (var db = new TrippleNTDBContext())
{
var reco = new Reconciliation();
var enddate = DateTime.Now.AddDays(-1).Date;
var comp = db.Company.Where(o => o.Status == "Acvtive").ToList();
foreach (var item in comp)
{
reco.Amount = db.Donations.Where(o => o.ComapanyId == item.CompanyId && o.Status == "NT" && o.DateDonated.Date <= enddate).Sum(o => o.Amount);
reco.StartPeriod = DateTime.Now.AddDays(-7);
reco.EndPeriod = DateTime.Now.AddDays(-1);
reco.CompanyId = item.CompanyId;
reco.Status = "Pending";
var msg = "Hello, " + item.Name + ", <br> Your donation reconciliation of NGN" + string.Format("{0:n}", reco.Amount) + " for this week is now ready. Kindly log in to make payment. <br> Thank you for your continuous co-operation and for your contribution to changing the world.<br><br>#ChangeTheWorldWithYourSpareChange <br><br>Regards,<br> Admin Edufund";
Utility.SendMail.Send("Welcome to EduFund", msg, item.Email, _configuration);
}
haverun2 = DateTime.Now;
}
}
}
}
/// <summary>
/// Close the day & print the reconciliation report
/// </summary>
/// <param name="options">Options in JSON string format</param>
/// <param name="options.baxiArgs">TransferAmount arguments in JSON string format</param>
/// <returns>JSON payload sent to the terminal</returns>
public string Reconcile(string options = "{}")
{
var opts = JsonConvert.DeserializeObject <OperationOptions>(options);
Reconciliation r = new Reconciliation(baxiArgs: opts.baxiArgs);
terminalCtrl.SendAdminOperation(r);
return(JsonConvert.SerializeObject(r.Args));
}
public static bool Update(Reconciliation oldReconciliation,
Reconciliation newReconciliation)
{
SqlConnection connection = PMMSData.GetConnection();
string updateProcedure = "[ReconciliationUpdate]";
SqlCommand updateCommand = new SqlCommand(updateProcedure, connection);
updateCommand.CommandType = CommandType.StoredProcedure;
updateCommand.Parameters.AddWithValue("@NewInvoiceID", newReconciliation.InvoiceID);
updateCommand.Parameters.AddWithValue("@NewPaymentDate", newReconciliation.PaymentDate);
updateCommand.Parameters.AddWithValue("@NewPaymentAmount", newReconciliation.PaymentAmount);
updateCommand.Parameters.AddWithValue("@NewTDSAmount", newReconciliation.TDSAmount);
if (newReconciliation.Remarks != null)
{
updateCommand.Parameters.AddWithValue("@NewRemarks", newReconciliation.Remarks);
}
else
{
updateCommand.Parameters.AddWithValue("@NewRemarks", DBNull.Value);
}
updateCommand.Parameters.AddWithValue("@OldReconciliationID", oldReconciliation.ReconciliationID);
updateCommand.Parameters.AddWithValue("@OldInvoiceID", oldReconciliation.InvoiceID);
updateCommand.Parameters.AddWithValue("@OldPaymentDate", oldReconciliation.PaymentDate);
updateCommand.Parameters.AddWithValue("@OldPaymentAmount", oldReconciliation.PaymentAmount);
updateCommand.Parameters.AddWithValue("@OldTDSAmount", oldReconciliation.TDSAmount);
if (oldReconciliation.Remarks != null)
{
updateCommand.Parameters.AddWithValue("@OldRemarks", oldReconciliation.Remarks);
}
else
{
updateCommand.Parameters.AddWithValue("@OldRemarks", DBNull.Value);
}
updateCommand.Parameters.Add("@ReturnValue", System.Data.SqlDbType.Int);
updateCommand.Parameters["@ReturnValue"].Direction = ParameterDirection.Output;
try
{
connection.Open();
updateCommand.ExecuteNonQuery();
int count = System.Convert.ToInt32(updateCommand.Parameters["@ReturnValue"].Value);
if (count > 0)
{
return(true);
}
else
{
return(false);
}
}
catch (SqlException)
{
return(false);
}
finally
{
connection.Close();
}
}
public static void Create(ReconciliationEditModel model, Reconciliation entity, string userId)
{
entity.BankAccountId = model.BankAccountId;
entity.ReconciliationDate = model.ReconciliationDate;
entity.StatementBalance = model.StatementBalance;
entity.IcloseBalance = model.IcloseBalance;
entity.ReconciliationStatus = model.ReconciliationStatus;
entity.IsReconciliation = model.IsReconciliation;
}
public static void Create(int id, Reconciliation entity)
{
entity.BankAccountId = id;
entity.ReconciliationDate = null;
entity.StatementBalance = 0;
entity.IcloseBalance = 0;
entity.ReconciliationStatus = 1;
entity.IsReconciliation = false;
}
public HttpResponseMessage UpdateReconciliation(HttpRequestMessage request, [FromBody] Reconciliation reconciliationModel)
{
return(GetHttpResponse(request, () =>
{
var reconciliation = _IFRS9Service.UpdateReconciliation(reconciliationModel);
return request.CreateResponse <Reconciliation>(HttpStatusCode.OK, reconciliation);
}));
}
public IHttpActionResult GetReconciliation(int id)
{
Reconciliation reconciliation = db.Reconciliations.Find(id);
if (reconciliation == null)
{
return(NotFound());
}
return(Ok(reconciliation));
}
public async Task AddAsync(Reconciliation entity)
{
if (entity.Id == 0)
{
await _dataContext.AddAsync(entity);
}
else
{
_dataContext.Update(entity);
}
}
public IHttpActionResult DeleteReconciliation(int id)
{
Reconciliation reconciliation = db.Reconciliations.Find(id);
if (reconciliation == null)
{
return(NotFound());
}
db.Reconciliations.Remove(reconciliation);
db.SaveChanges();
return(Ok(reconciliation));
}
public HttpResponseMessage GetReconciliation(HttpRequestMessage request, int reconciliationId)
{
return(GetHttpResponse(request, () =>
{
HttpResponseMessage response = null;
Reconciliation reconciliation = _IFRS9Service.GetReconciliation(reconciliationId);
// notice no need to create a seperate model object since Reconciliation entity will do just fine
response = request.CreateResponse <Reconciliation>(HttpStatusCode.OK, reconciliation);
return response;
}));
}
public async Task AddAsync(BankAccountAddModel model)
{
var result = BankAccountFactory.Create(model, _userId);
await _bankAccountRepository.AddAsync(result);
if (model.COA_AccountTypeId == 1 || model.COA_AccountTypeId == 2 || model.COA_AccountTypeId == 6 || model.COA_AccountTypeId == 7)
{
Reconciliation reconciliation = new Reconciliation();
ReconciliationFactory.Create(result.Id, reconciliation);
await _reconciliationRepository.AddAsync(reconciliation);
}
await _unitOfWork.SaveChangesAsync();
}
public static Tbl_Reconciliation MapFrom(this Reconciliation reconciliation)
{
return(new Tbl_Reconciliation
{
Id = reconciliation.Id,
AccountId = reconciliation.AccountId,
StartDate = reconciliation.StartDate,
EndDate = reconciliation.EndDate,
ClosingBalance = reconciliation.ClosingBalance,
Status = reconciliation.Status,
Created_By = reconciliation.Created_By,
Created_At = reconciliation.Id > 0 ? reconciliation.Created_At : DateTime.Now,
Updated_At = reconciliation.Id > 0 ? reconciliation.Updated_At:default(DateTime?)
});
}
public static Reconciliation Create(ReconciliationAddModel model, string userId)
{
var reconciliation = new Reconciliation
{
Id = model.Id,
BankAccountId = model.BankAccountId,
ReconciliationDate = model.ReconciliationDate,
StatementBalance = model.StatementBalance,
IcloseBalance = model.IcloseBalance,
ReconciliationStatus = model.ReconciliationStatus,
IsReconciliation = model.IsReconciliation
};
return(reconciliation);
}
private static void UpdateInstallmentGalileo(Reconciliation reconciliation, int seq)
{
using (var client = new GalileoInternalServiceWcfClient())
{
client.UpdateInstallment(new UpdateInstallmentRequest()
{
PaymentCode = reconciliation.PaymentCode,
Amount = reconciliation.Amount,
InstallmentSeq = (byte)seq,
Method = reconciliation.PaymentMethod,
ReconciliationId = reconciliation.Id,
InstallmentBy = reconciliation.PaymentBy,
InstallmentDate = reconciliation.PaymentDate
});
}
}
private async Task RetriveMonthYearMappingInfo(Reconciliation reconciliation)
{
MonthYearMapping monthYearMapping = new MonthYearMapping();
monthYearMapping.MonthId = reconciliation.MonthId;
monthYearMapping.Year = reconciliation.Year;
MonthYearMapping monthYear = bookkeepingDataStore.GetMonthYearMappingByMonthYear(reconciliation.MonthId, reconciliation.Year);
if (monthYear == null)
{
reconciliation.MonthYearMappingId = await repoMonthYearMapping.Add(monthYearMapping);
}
else
{
reconciliation.MonthYearMappingId = monthYear.Id;
}
}
public static bool Add(Reconciliation Reconciliation)
{
SqlConnection connection = PMMSData.GetConnection();
string insertProcedure = "[ReconciliationInsert]";
SqlCommand insertCommand = new SqlCommand(insertProcedure, connection);
insertCommand.CommandType = CommandType.StoredProcedure;
insertCommand.Parameters.AddWithValue("@InvoiceID", Reconciliation.InvoiceID);
insertCommand.Parameters.AddWithValue("@PaymentDate", Reconciliation.PaymentDate);
insertCommand.Parameters.AddWithValue("@PaymentAmount", Reconciliation.PaymentAmount);
insertCommand.Parameters.AddWithValue("@TDSAmount", Reconciliation.TDSAmount);
if (Reconciliation.Remarks != null)
{
insertCommand.Parameters.AddWithValue("@Remarks", Reconciliation.Remarks);
}
else
{
insertCommand.Parameters.AddWithValue("@Remarks", DBNull.Value);
}
insertCommand.Parameters.Add("@ReturnValue", System.Data.SqlDbType.Int);
insertCommand.Parameters["@ReturnValue"].Direction = ParameterDirection.Output;
try
{
connection.Open();
insertCommand.ExecuteNonQuery();
int count = System.Convert.ToInt32(insertCommand.Parameters["@ReturnValue"].Value);
if (count > 0)
{
return(true);
}
else
{
return(false);
}
}
catch (SqlException)
{
return(false);
}
finally
{
connection.Close();
}
}
public object NewRecord(Reconciliation rcd)
{
try
{
using (var db = new TrippleNTDBContext())
{
db.Reconciliation.Add(rcd);
db.SaveChanges();
return(new reconcileResponse {
value = 1
});
}
}
catch (Exception ex)
{
return(new reconcileResponse {
value = 0
});
}
}
public static Reconciliation[] CreateCreditCardToBBL(DataTable dt, string paymentMethod, long reconciliationFileId)
{
var result = new List <Reconciliation>();
for (var i = 0; i < dt.Rows.Count; i++)
{
var recon = new Reconciliation
{
PaymentCode = dt.Rows[i]["Merchant Ref."].ToString(),
Amount = dt.Rows[i]["Amount"].ToString().ToDecimal(),
PaymentDate = Convert.ToDateTime(dt.Rows[i]["Transaction Date"].ToString(), new CultureInfo("en-US")),
PaymentBy = dt.Rows[i]["Name"].ToString(),
PaymentMethod = paymentMethod,
ReconciliationFileId = reconciliationFileId
};
result.Add(recon);
}
return(result.ToArray());
}
protected override void ProcessSolution(SolutionFile toSolution, Reconciliation<SolutionProject> reconciliation) {
foreach (var project in reconciliation.Removed) {
toSolution.Add(project);
}
}
