public void CreateLedgers()
{
var dictionary = new Dictionary <string, object>();
var service = new Mock <IBankLedgerService>();
service.SetupGet(x => x.DataBase).Returns(dictionary);
var ledgerService = new LedgerService(service.Object);
var badAccount = new Account(null, "password", "", null);
var account = new Account("testing", "password", "", null);
var depLedger = new Ledger(0, TransactionType.Deposit, 10);
var withLedger = new Ledger(0, TransactionType.Withdrawl, 10);
Assert.Throws <ArgumentException>(() => ledgerService.CreateLedger(null, null));
Assert.Throws <ArgumentException>(() => ledgerService.CreateLedger(badAccount, null));
Assert.Throws <ArgumentException>(() => ledgerService.CreateLedger(account, null));
var ledgerKey = $"{account.UserName.ToLower()}_Ledger_{1}";
ledgerService.BankLedgerService.DataBase[ledgerKey] = null;
Assert.IsNull(ledgerService.CreateLedger(account, depLedger));
var ledgerCountKey = $"{account.UserName.ToLower()}_ledgerCount";
ledgerService.BankLedgerService.DataBase.Remove(ledgerKey);
Assert.IsNotNull(ledgerService.CreateLedger(account, depLedger));
Assert.IsNotNull(ledgerService.BankLedgerService.DataBase[ledgerCountKey]);
Assert.AreEqual(1, (ulong)ledgerService.BankLedgerService.DataBase[ledgerCountKey]);
Assert.IsNotNull(ledgerService.CreateLedger(account, withLedger));
Assert.IsNotNull(ledgerService.BankLedgerService.DataBase[ledgerCountKey]);
Assert.AreEqual(2, (ulong)ledgerService.BankLedgerService.DataBase[ledgerCountKey]);
}
public async void Add_New_Ledger()
{
using (var scope = Factory.Services.CreateScope())
{
var mapper = scope.ServiceProvider.GetRequiredService <IMapper>();
var responseService = scope.ServiceProvider.GetRequiredService <IResponseService <LedgerDto> >();
var ledgerDto = new LedgerDto
{
Code = RandomData.IntGenerate().ToString(),
Title = RandomData.StringGenerator(),
IsActive = true
};
var ledger = mapper.Map <LedgerDto, Ledger>(ledgerDto);
var legerRepositoryMock = new Mock <ILegerRepository>();
var unitOfWorkMock = new Mock <IUnitOfWork>();
legerRepositoryMock.Setup(c => c.AddAsync(ledger)).Returns(Task.CompletedTask);
unitOfWorkMock.Setup(c => c.SaveChangesAsync()).ReturnsAsync(1);
var ledgerService = new LedgerService(legerRepositoryMock.Object, mapper,
responseService, unitOfWorkMock.Object);
var result = await ledgerService.AddAsync(ledgerDto);
result.ApplicationMessage.Should().BeEquivalentTo(UserMessage.Success);
}
}
protected async override Task OnInitializedAsync()
{
//Trns =(Trn) await TrnService.GetTrns();
BookMaster = (IEnumerable <BookMaster>) await BookMasterService.GetBookMasters();
Ledgers = await LedgerService.GetLedgers();
}
public async void Add_Duplicate_Ledger_WithCode()
{
using (var scope = Factory.Services.CreateScope())
{
var mapper = scope.ServiceProvider.GetRequiredService <IMapper>();
var responseService = scope.ServiceProvider.GetRequiredService <IResponseService <LedgerDto> >();
var ledgerDto = new LedgerDto
{
Code = RandomData.IntGenerate().ToString(),
Title = RandomData.StringGenerator(),
IsActive = true
};
var legerRepositoryMock = new Mock <ILegerRepository>();
var unitOfWorkMock = new Mock <IUnitOfWork>();
legerRepositoryMock.Setup(c => c.ExistsAsync(It.IsAny <Expression <Func <Ledger, bool> > >()))
.ReturnsAsync((Expression <Func <Ledger, bool> > pre) => { return(true); });
unitOfWorkMock.Setup(c => c.SaveChangesAsync()).ReturnsAsync(1);
var ledgerService = new LedgerService(legerRepositoryMock.Object, mapper,
responseService, unitOfWorkMock.Object);
var result = await ledgerService.AddAsync(ledgerDto);
result.ApplicationMessage.Should().BeEquivalentTo(UserMessage.Duplicated);
}
}
public ActionResult DeletePost(LedgerAccountOpeningViewModel vm)
{
LedgerHeader Header = new LedgerHeaderService(_unitOfWork).Find(vm.LedgerHeaderId);
LedgerLine Line = new LedgerLineService(_unitOfWork).FindByLedgerHeader(vm.LedgerHeaderId).FirstOrDefault();
Ledger Ledger = new LedgerService(_unitOfWork).FindForLedgerHeader(vm.LedgerHeaderId).FirstOrDefault();
Ledger LedgerToDelete = db.Ledger.Find(Ledger.LedgerId);
LedgerLine LedgerLineToDelete = db.LedgerLine.Find(Line.LedgerLineId);
LedgerHeader LedgerHeaderToDelete = db.LedgerHeader.Find(Header.LedgerHeaderId);
LedgerToDelete.ObjectState = Model.ObjectState.Deleted;
db.Ledger.Remove(LedgerToDelete);
LedgerLineToDelete.ObjectState = Model.ObjectState.Deleted;
db.LedgerLine.Remove(LedgerLineToDelete);
LedgerHeaderToDelete.ObjectState = Model.ObjectState.Deleted;
db.LedgerHeader.Remove(LedgerHeaderToDelete);
try
{
db.SaveChanges();
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
PrepareViewBag();
ModelState.AddModelError("", message);
return(PartialView("EditSize", vm));
}
return(Json(new { success = true }));
}
public void CreateAccountLedgerTest()
{
//Forbidden
TestBadSignin(() => Controller.CreateAccountLedger(null));
var dto = new AccountLedgerDto
{
Amount = 1,
TransactionType = 1
};
//Bad Request, an account ledger wasnt created
AccountService.Setup(x => x.IsSignedIn(It.IsAny <HttpSessionStateBase>()))
.Returns(new Account("", "", "", null));
LedgerService.Setup(x => x.CreateLedger(It.IsAny <Account>(),
It.IsAny <Ledger>())).Returns((Ledger)null);
var result = Controller.CreateAccountLedger(dto);
var code = result.AssertResultIs <HttpStatusCodeResult>().StatusCode;
Assert.AreEqual(400, code);
//Should create correct ledgerview model with partialview
var ledger = new Ledger(1, dto.TransactionType, dto.Amount);
LedgerService.Setup(x => x.CreateLedger(It.IsAny <Account>(),
It.IsAny <Ledger>())).Returns(ledger);
result = Controller.CreateAccountLedger(dto);
result.AssertPartialViewRendered().ForView("_Ledger");
var model = result.AssertPartialViewRendered().WithViewData <LedgerViewModel>();
Assert.AreEqual(ledger.LedgerId, model.LedgerId);
Assert.AreEqual(ledger.TransactionType, model.TransactionType);
Assert.AreEqual(ledger.Amount, model.Amount);
}
public void GetLedgers()
{
var dictionary = new Dictionary <string, object>();
var service = new Mock <IBankLedgerService>();
service.SetupGet(x => x.DataBase).Returns(dictionary);
var ledgerService = new LedgerService(service.Object);
var account = new Account("testing", "password", "", null);
var badAccount = new Account(null, "password", "", null);
var depLedger = new Ledger(0, TransactionType.Deposit, 10);
var withLedger = new Ledger(0, TransactionType.Withdrawl, 10);
Assert.Throws <ArgumentException>(() => ledgerService.GetAllLedgers(null));
Assert.Throws <ArgumentException>(() => ledgerService.GetAllLedgers(badAccount));
Assert.IsNull(ledgerService.GetAllLedgers(account));
ledgerService.CreateLedger(account, depLedger);
ledgerService.CreateLedger(account, withLedger);
ledgerService.CreateLedger(account, depLedger);
ledgerService.CreateLedger(account, withLedger);
ledgerService.CreateLedger(account, depLedger);
ledgerService.CreateLedger(account, withLedger);
Assert.AreEqual(6, ledgerService.GetAllLedgers(account).Count);
ledgerService.CreateLedger(account, depLedger);
ledgerService.CreateLedger(account, withLedger);
Assert.AreEqual(8, ledgerService.GetAllLedgers(account).Count);
Assert.IsTrue(ledgerService.GetAllLedgers(account).Any(x => x.LedgerId == 8));
Assert.AreEqual(4, ledgerService.GetAllLedgers(account)
.Count(x => x.TransactionType == TransactionType.Deposit));
Assert.AreEqual(4, ledgerService.GetAllLedgers(account)
.Count(x => x.TransactionType == TransactionType.Withdrawl));
}
static void Main(string[] args)
{
NetPayService netPayService = new NetPayService();
HmrcService hmrcService = new HmrcService();
FpsService fpsService = new FpsService();
EpsService epsService = new EpsService();
LedgerService ledgerService = new LedgerService();
Console.ReadLine();
}
public void Verify_LedgerService_SqlLedgerRepository_GetLedgerReport_Returns_Empty_Data_Against_InValid_DbStudent()
{
ILedgerService ledgerService = new LedgerService(new SqlLedgerRepository());
var studentLedger = ledgerService.GetLedgerReport(TestConstants.InvalidUserId);
Assert.IsNotNull(studentLedger);
Assert.IsNull(studentLedger.StudentName);
Assert.IsNotNull(studentLedger.ledgerList);
Assert.IsTrue(studentLedger.ledgerList.Count == 0);
}
public void Verify_LedgerService_TestLedgerRepository_GetLedgerReport_Returns_Data_Against_TestStudent()
{
ILedgerService ledgerService = new LedgerService(new TestLedgerRepository());
var studentLedger = ledgerService.GetLedgerReport(1);
Assert.IsNotNull(studentLedger);
Assert.IsNotNull(studentLedger.StudentName);
Assert.IsNotNull(studentLedger.ledgerList);
Assert.IsTrue(studentLedger.ledgerList.Count > 0);
}
public void Verify_SqlLedgerService_GetLedgerReport_Returns_Data_Against_Valid_DbStudent()
{
ILedgerService ledgerRepository = new LedgerService();
var studentLedger = ledgerRepository.GetLedgerReport(TestConstants.DbStudentUserId);
Assert.IsNotNull(studentLedger);
Assert.IsNotNull(studentLedger.StudentName);
Assert.IsNotNull(studentLedger.ledgerList);
Assert.IsTrue(studentLedger.ledgerList.Count > 0);
}
public async Task <string> ProcessCredentialAsync(IAgentContext agentContext, CredentialIssueMessage credential, ConnectionRecord connection)
{
var credentialAttachment = credential.Credentials.FirstOrDefault(x => x.Id == "libindy-cred-0")
?? throw new ArgumentException("Credential attachment not found");
var credentialJson = credentialAttachment.Data.Base64.GetBytesFromBase64().GetUTF8String();
var credentialJobj = JObject.Parse(credentialJson);
var definitionId = credentialJobj["cred_def_id"].ToObject <string>();
var revRegId = credentialJobj["rev_reg_id"]?.ToObject <string>();
var credentialRecord = await this.GetByThreadIdAsync(agentContext, credential.GetThreadId());
if (credentialRecord.State != CredentialState.Requested)
{
throw new AgentFrameworkException(ErrorCode.RecordInInvalidState,
$"Credential state was invalid. Expected '{CredentialState.Requested}', found '{credentialRecord.State}'");
}
var credentialDefinition = await LedgerService.LookupDefinitionAsync(await agentContext.Pool, definitionId);
string revocationRegistryDefinitionJson = null;
if (!string.IsNullOrEmpty(revRegId))
{
// If credential supports revocation, lookup registry definition
var revocationRegistry =
await LedgerService.LookupRevocationRegistryDefinitionAsync(await agentContext.Pool, revRegId);
revocationRegistryDefinitionJson = revocationRegistry.ObjectJson;
}
var credentialId = await AnonCreds.ProverStoreCredentialAsync(
wallet : agentContext.Wallet,
credId : null,
credReqMetadataJson : credentialRecord.CredentialRequestMetadataJson,
credJson : credentialJson,
credDefJson : credentialDefinition.ObjectJson,
revRegDefJson : revocationRegistryDefinitionJson);
credentialRecord.CredentialId = credentialId;
credentialRecord.CredentialAttributesValues = null;
await credentialRecord.TriggerAsync(CredentialTrigger.Issue);
await RecordService.UpdateAsync(agentContext.Wallet, credentialRecord);
EventAggregator.Publish(new ServiceMessageProcessingEvent
{
RecordId = credentialRecord.Id,
MessageType = credential.Type,
ThreadId = credential.GetThreadId()
});
return(credentialRecord.Id);
}
public void AccountLedgerTest()
{
//Redirect
TestBadSignin(Controller.AccountLedger);
AccountService.Setup(x => x.IsSignedIn(It.IsAny <HttpSessionStateBase>()))
.Returns(new Account("", "", "", null));
var results = new List <Ledger>
{
new Ledger(0, TransactionType.Deposit, 0),
new Ledger(1, TransactionType.Deposit, 0),
new Ledger(2, TransactionType.Withdrawl, 0),
new Ledger(3, TransactionType.Withdrawl, 0),
new Ledger(4, TransactionType.Deposit, 0),
new Ledger(5, TransactionType.Withdrawl, 0),
};
//Verify it can handle null
LedgerService.Setup(x => x.GetAllLedgers(It.IsAny <Account>()))
.Returns((List <Ledger>)null);
var result = Controller.AccountLedger();
result.AssertViewRendered().ForView("AccountLedger");
var model = result.AssertViewRendered().WithViewData <AccountLedgerViewModel>();
Assert.IsEmpty(model.Ledgers);
var viewModels = new List <LedgerViewModel>();
LedgerService.Setup(x => x.GetAllLedgers(It.IsAny <Account>()))
.Returns(results);
foreach (var ledger in results)
{
viewModels.Add(new LedgerViewModel
{
LedgerId = ledger.LedgerId,
TransactionType = ledger.TransactionType,
Amount = ledger.Amount
});
}
//Returns AccountLedger view. Models should match.
result = Controller.AccountLedger();
result.AssertViewRendered().ForView("AccountLedger");
model = result.AssertViewRendered().WithViewData <AccountLedgerViewModel>();
Assert.AreEqual(viewModels.Count, model.Ledgers.Count);
for (int i = 0; i < viewModels.Count; i++)
{
var areEqual = viewModels[i].Amount == model.Ledgers[i].Amount;
areEqual &= viewModels[i].TransactionType == model.Ledgers[i].TransactionType;
areEqual &= viewModels[i].LedgerId == model.Ledgers[i].LedgerId;
Assert.IsTrue(areEqual);
}
}
public IStock BindCostFromLedgerLite(IStock stock)
{
LedgerService ledgerService = new LedgerService(repository);
LedgerLite ledger = ledgerService.GetLedgerLite(stock.ItemId, stock.UnitId, stock.ManufacturerId,
stock.MovingAverageId);
stock.UnitCost = ledger.UnitCost;
stock.Margin = ledger.Margin;
stock.SellingPrice = ledger.SellingPrice;
return(stock);
}
protected async override Task OnInitializedAsync()
{
var authenticationState = await authenticationStateTask;
if (!authenticationState.User.Identity.IsAuthenticated)
{
NavigationManager.NavigateTo("/identity/account/login");
}
Ledgers = (await LedgerService.GetLedgers()).ToList();
AccountGroupMasters = (await AccountGroupMasterService.GetAccountGroupMasters()).ToList();
Lcd = Lcd ?? "GL";
AcMasters = (await AcMasterService.LedgerOfAccounts(Lcd)).ToList();
}
public void chart_of_account_insert_new()
{
ChartOfAccount newObject = new ChartOfAccount();
Mock <IBusinessEngineFactory> mockBusinessEngineFactory = new Mock <IBusinessEngineFactory>();
mockBusinessEngineFactory.Setup(mock => mock.GetBusinessEngine <IChartOfAccountBusinessEngine>().ChartOfAccountSave(newObject)).Returns(123);
LedgerService service = new LedgerService(mockBusinessEngineFactory.Object);
int update_ret_val = service.CreateChartOfAccount(newObject);
Assert.IsTrue(update_ret_val == 123);
}
protected async override Task OnInitializedAsync()
{
Ledgers = (await LedgerService.GetLedgers()).ToList();
AccountGroupMasters = (await AccountGroupMasterService.GetAccountGroupMasters()).ToList();
//AcMasters = (AcMaster)await AcMasterService.GetAcMasters();
AcMasters = new AcMaster
{
Acno = Maxaccountno,
Ason = DateTime.Now,
CreatedBy = CreatedUser,
CreatedDate = DateTime.Now,
AuthorisedAc = false,
AuthorisedDate = DateTime.Now,
AuthorisedBy = "pdp"
};
}
public void GetBalance()
{
var dictionary = new Dictionary <string, object>();
var service = new Mock <IBankLedgerService>();
service.SetupGet(x => x.DataBase).Returns(dictionary);
var ledgerService = new LedgerService(service.Object);
var account = new Account("testing", "password", "", null);
var badAccount = new Account(null, "password", "", null);
var depLedger = new Ledger(0, TransactionType.Deposit, 10);
var withLedger = new Ledger(0, TransactionType.Withdrawl, 10);
Assert.Throws <ArgumentException>(() => ledgerService.GetTotalBalance(null));
Assert.Throws <ArgumentException>(() => ledgerService.GetTotalBalance(badAccount));
Assert.AreEqual(0, ledgerService.GetTotalBalance(account));
ledgerService.CreateLedger(account, depLedger);
ledgerService.CreateLedger(account, withLedger);
ledgerService.CreateLedger(account, depLedger);
ledgerService.CreateLedger(account, withLedger);
ledgerService.CreateLedger(account, depLedger);
ledgerService.CreateLedger(account, withLedger);
Assert.AreEqual(0, ledgerService.GetTotalBalance(account));
ledgerService.CreateLedger(account, depLedger);
Assert.AreEqual(10, ledgerService.GetTotalBalance(account));
ledgerService.CreateLedger(account, withLedger);
ledgerService.CreateLedger(account, withLedger);
Assert.AreEqual(-10, ledgerService.GetTotalBalance(account));
for (int i = 0; i < 11; i++)
{
ledgerService.CreateLedger(account, depLedger);
}
Assert.AreEqual(100, ledgerService.GetTotalBalance(account));
for (int i = 0; i < 11; i++)
{
ledgerService.CreateLedger(account, withLedger);
}
Assert.AreEqual(-10, ledgerService.GetTotalBalance(account));
}
public async Task <(CredentialRequestMessage, CredentialRecord)> CreateRequestAsync(IAgentContext agentContext, string credentialId)
{
var credential = await GetAsync(agentContext, credentialId);
if (credential.State != CredentialState.Offered)
{
throw new AgentFrameworkException(ErrorCode.RecordInInvalidState,
$"Credential state was invalid. Expected '{CredentialState.Offered}', found '{credential.State}'");
}
var connection = await ConnectionService.GetAsync(agentContext, credential.ConnectionId);
var definition =
await LedgerService.LookupDefinitionAsync(await agentContext.Pool, credential.CredentialDefinitionId);
var provisioning = await ProvisioningService.GetProvisioningAsync(agentContext.Wallet);
var request = await AnonCreds.ProverCreateCredentialReqAsync(agentContext.Wallet, connection.MyDid,
credential.OfferJson,
definition.ObjectJson, provisioning.MasterSecretId);
// Update local credential record with new info
credential.CredentialRequestMetadataJson = request.CredentialRequestMetadataJson;
await credential.TriggerAsync(CredentialTrigger.Request);
await RecordService.UpdateAsync(agentContext.Wallet, credential);
var threadId = credential.GetTag(TagConstants.LastThreadId);
var response = new CredentialRequestMessage
{
Requests = new[] {
new Attachment
{
Id = "libindy-cred-request-0",
MimeType = CredentialMimeTypes.ApplicationJsonMimeType,
Data = new AttachmentContent
{
Base64 = request.CredentialRequestJson.GetUTF8Bytes().ToBase64String()
}
}
}
};
response.ThreadFrom(threadId);
return(response, credential);
}
public static DataTable SetPrice(DataTable dataTable)
{
foreach (DataRow dataRow in dataTable.Rows)
{
var ledgerService = new LedgerService();
var ledgerObject = ledgerService.GetLedger(Convert.ToInt32(dataRow["ItemID"])
, Convert.ToInt32(dataRow["ItemUnitID"])
, Convert.ToInt32(dataRow["ManufacturerID"])
, Convert.ToInt32(dataRow["MovingAverageID"]));
dataRow["UnitCost"] = Math.Round(ledgerObject.UnitCost, Settings.NoOfDigitsAfterTheDecimalPoint,
MidpointRounding.AwayFromZero);
dataRow["TotalCost"] = Math.Round(ledgerObject.UnitCost * Convert.ToDecimal(dataRow["PreviousQty"]),
Settings.NoOfDigitsAfterTheDecimalPoint,
MidpointRounding.AwayFromZero);
}
return(dataTable);
}
public ActionResult StudentLedger()
{
try
{
ILedgerService studentLedgerService = new LedgerService();
var studentLedger = studentLedgerService.GetLedgerReport(StudentNo);
return(View(studentLedger));
}
catch (Exception ex)
{
//ViewData["ErrorMessage"] = ex.Message;
Response.Redirect("../User/Result/error");
return(null);
}
}
protected async override Task OnInitializedAsync()
{
Ledgers = (await LedgerService.GetLedgers()).ToList();
AcMaster = await AcMasterService.GetAcMaster(int.Parse(Id));
AcMaster = new AcMaster
{
AcMasterID = AcMaster.AcMasterID,
LedgerID = AcMaster.LedgerID,
LedgerCode = AcMaster.LedgerCode,
Acno = AcMaster.Acno,
Acname = AcMaster.Acname,
CreatedBy = AcMaster.CreatedBy,
CreatedDate = AcMaster.CreatedDate,
AuthorisedBy = AcMaster.AuthorisedBy == null ? "LoginUser" : AcMaster.AuthorisedBy,
AuthorisedAc = AcMaster.AuthorisedAc == false ? false : AcMaster.AuthorisedAc,
AuthorisedDate = AcMaster.AuthorisedDate == null ? DateTime.Now :AcMaster.AuthorisedDate
};
}
public ActionResult StudentLedger()
{
try
{
ILedgerService studentLedgerService = new LedgerService();
var studentLedger = studentLedgerService.GetLedgerReport(StudentNo);
return(View(studentLedger));
}
catch (Exception ex)
{
_logger.Error("Exception Occurred. StudentNo: " + StudentNo, ex);
Response.Redirect(AppHelper.SharedUrl("Reply/Error"));
return(null);
}
}
public DataRow priceChangeReport(DataRow dr)
{
var costLedgerService = new LedgerService();
var ledger = costLedgerService.GetLedger(ItemID, ItemUnitID, ManufacturerID,
MovingAverageID);
dr["FullItemName"] = ItemName;
dr["StockCode"] = StockCode;
dr["Manufacturer"] = ManufacturerName;
dr["Account"] = AccountName;
dr["Unit"] = ItemUnitName;
dr["PreviousUnitCost"] = ledger.UnitCost;
dr["PreviousMargin"] = ledger.Margin;
dr["PreviousSellingPrice"] = ledger.SellingPrice;
dr["NewUnitCost"] = AverageCost;
dr["NewMargin"] = Margin;
dr["NewSellingPrice"] = SellingPrice;
return(dr);
}
public void AccountIntoTest()
{
//Redirect
TestBadSignin(Controller.AccountInfo);
//Returns a model with 0 count, 10 totalcount, "name" accountname
LedgerService.Setup(x => x.GetAllLedgers(It.IsAny <Account>()))
.Returns((List <Ledger>)null);
LedgerService.Setup(x => x.GetTotalBalance(It.IsAny <Account>()))
.Returns(10);
AccountService.Setup(x => x.IsSignedIn(It.IsAny <HttpSessionStateBase>()))
.Returns(new Account("name", "", "", null));
var result = Controller.AccountInfo();
result.AssertViewRendered().ForView("AccountInfo");
var model = result.AssertViewRendered().WithViewData <AccountInfoViewModel>();
Assert.AreEqual(0, model.LegderCount);
Assert.AreEqual(10, model.TotalAmount);
Assert.AreEqual("name", model.AccountName);
}
public void WhenICreateALedgerWithTheProperties(string reference, Table table)
{
var service = new LedgerService(cc.GetContext());
var l = service.CreateLedger();
foreach (var r in table.Rows)
{
var property = r["Property"];
var value = r["Value"];
switch (property)
{
case "Name": l.Name = value; break;
case "Depth": l.Depth = int.Parse(value); break;
}
}
cc.GetContext().SaveChanges();
cc.ObjectBag["ledger-" + reference] = l;
}
private void LoadAndCalculate()
{
var ledgerService = new LedgerService();
var ledgerObject = ledgerService.GetLedger(costElement.ItemID, costElement.ItemUnitID, costElement.ManufacturerID,
costElement.MovingAverageID);
previousQty = ReceiveDoc.GetSoundStock(costElement);
previousUnitCost = Math.Round(ledgerObject.UnitCost, BLL.Settings.NoOfDigitsAfterTheDecimalPoint,
MidpointRounding.AwayFromZero);
AverageCostCalculator averageCostCalculator = new AverageCostCalculator(costElement);
costElement.AverageCost = averageCostCalculator.CalculateMovingAverage(Convert.ToDouble(previousQty),
Convert.ToDouble(previousUnitCost),
costElement.Qty, costElement.UnitCost);
costElement.SellingPrice = averageCostCalculator.GetSellingPrice(BLL.Settings.IsCenter?0:costElement.Margin);
txtItemName.Text = costElement.ItemName;
txtManufacturer.Text = costElement.ManufacturerName;
txtUnit.Text = costElement.ItemUnitName;
}
public int LedgerPost(SaleOrderHeader pd)
{
int LedgerHeaderId = 0;
if (pd.LedgerHeaderId == 0 || pd.LedgerHeaderId == null)
{
LedgerHeader LedgerHeader = new LedgerHeader();
LedgerHeader.DocTypeId = pd.DocTypeId;
LedgerHeader.DocDate = pd.DocDate;
LedgerHeader.DocNo = pd.DocNo;
LedgerHeader.DivisionId = pd.DivisionId;
LedgerHeader.SiteId = pd.SiteId;
LedgerHeader.Remark = pd.Remark;
LedgerHeader.CreatedBy = pd.CreatedBy;
LedgerHeader.CreatedDate = DateTime.Now.Date;
LedgerHeader.ModifiedBy = pd.ModifiedBy;
LedgerHeader.ModifiedDate = DateTime.Now.Date;
new LedgerHeaderService(_unitOfWork).Create(LedgerHeader);
}
else
{
LedgerHeader LedgerHeader = new LedgerHeaderService(_unitOfWork).Find((int)pd.LedgerHeaderId);
LedgerHeader.DocTypeId = pd.DocTypeId;
LedgerHeader.DocDate = pd.DocDate;
LedgerHeader.DocNo = pd.DocNo;
LedgerHeader.DivisionId = pd.DivisionId;
LedgerHeader.SiteId = pd.SiteId;
LedgerHeader.Remark = pd.Remark;
LedgerHeader.ModifiedBy = pd.ModifiedBy;
LedgerHeader.ModifiedDate = DateTime.Now.Date;
new LedgerHeaderService(_unitOfWork).Update(LedgerHeader);
IEnumerable <Ledger> LedgerList = new LedgerService(_unitOfWork).FindForLedgerHeader(LedgerHeader.LedgerHeaderId);
foreach (Ledger item in LedgerList)
{
new LedgerService(_unitOfWork).Delete(item);
}
LedgerHeaderId = LedgerHeader.LedgerHeaderId;
}
int SalesAc = new LedgerAccountService(_unitOfWork).Find(LedgerAccountConstants.Sale).LedgerAccountId;
if (pd.Advance > 0)
{
Ledger LedgerDr = new Ledger();
if (LedgerHeaderId != 0)
{
LedgerDr.LedgerHeaderId = LedgerHeaderId;
}
LedgerDr.LedgerAccountId = SalesAc;
LedgerDr.ContraLedgerAccountId = pd.BillToBuyerId;
LedgerDr.AmtDr = pd.Advance ?? 0;
LedgerDr.AmtCr = 0;
LedgerDr.Narration = "";
new LedgerService(_unitOfWork).Create(LedgerDr);
Ledger LedgerCr = new Ledger();
if (LedgerHeaderId != 0)
{
LedgerCr.LedgerHeaderId = LedgerHeaderId;
}
LedgerCr.LedgerAccountId = pd.BillToBuyerId;
LedgerCr.ContraLedgerAccountId = SalesAc;
LedgerCr.AmtDr = 0;
LedgerCr.AmtCr = pd.Advance ?? 0;
LedgerCr.Narration = "";
new LedgerService(_unitOfWork).Create(LedgerCr);
}
return(LedgerHeaderId);
}
public ActionResult Delete(ReasonViewModel vm)
{
if (ModelState.IsValid)
{
List <LogTypeViewModel> LogList = new List <LogTypeViewModel>();
//string temp = (Request["Redirect"].ToString());
//first find the Purchase Order Object based on the ID. (sience this object need to marked to be deleted IE. ObjectState.Deleted)
var SaleOrderHeader = _SaleOrderHeaderService.GetSaleOrderHeader(vm.id);
//For Updating Enquiry Header and Lines so that it can be edited and deleted as needed.
if (SaleOrderHeader.ReferenceDocId != null && SaleOrderHeader.ReferenceDocId != 0)
{
var SaleEnquiryHeader = (from H in context.SaleEnquiryHeader where H.SaleEnquiryHeaderId == SaleOrderHeader.ReferenceDocId && H.DocTypeId == SaleOrderHeader.ReferenceDocTypeId select H).FirstOrDefault();
if (SaleEnquiryHeader != null)
{
SaleEnquiryHeader Header = new SaleEnquiryHeaderService(_unitOfWork).Find(SaleEnquiryHeader.SaleEnquiryHeaderId);
Header.LockReason = null;
new SaleEnquiryHeaderService(_unitOfWork).Update(Header);
IEnumerable <SaleEnquiryLine> LineList = new SaleEnquiryLineService(_unitOfWork).GetSaleEnquiryLineListForHeader(SaleEnquiryHeader.SaleEnquiryHeaderId);
foreach (SaleEnquiryLine Line in LineList)
{
Line.LockReason = null;
new SaleEnquiryLineService(_unitOfWork).Update(Line);
}
}
}
LogList.Add(new LogTypeViewModel
{
ExObj = SaleOrderHeader,
});
//Then find all the Purchase Order Header Line associated with the above ProductType.
var SaleOrderLine = new SaleOrderLineService(_unitOfWork).GetSaleOrderLineList(vm.id);
List <int> StockIdList = new List <int>();
//Mark ObjectState.Delete to all the Purchase Order Lines.
foreach (var item in SaleOrderLine)
{
if (item.StockId != null)
{
StockIdList.Add((int)item.StockId);
}
LogList.Add(new LogTypeViewModel
{
ExObj = item,
});
new SaleOrderLineStatusService(_unitOfWork).Delete(item.SaleOrderLineId);
new SaleOrderLineService(_unitOfWork).Delete(item.SaleOrderLineId);
}
foreach (var item in StockIdList)
{
if (item != null)
{
new StockService(_unitOfWork).DeleteStock((int)item);
}
}
int?StockHeaderId = null;
StockHeaderId = SaleOrderHeader.StockHeaderId;
int LedgerHeaderId = SaleOrderHeader.LedgerHeaderId ?? 0;
// Now delete the Sale Order Header
new SaleOrderHeaderService(_unitOfWork).Delete(vm.id);
// Now delete the Ledger & Ledger Header
if (LedgerHeaderId != 0)
{
var LedgerList = new LedgerService(_unitOfWork).FindForLedgerHeader(LedgerHeaderId).ToList();
foreach (var item in LedgerList)
{
new LedgerService(_unitOfWork).Delete(item.LedgerId);
}
new LedgerHeaderService(_unitOfWork).Delete(LedgerHeaderId);
}
if (StockHeaderId != null)
{
new StockHeaderService(_unitOfWork).Delete((int)StockHeaderId);
}
XElement Modifications = new ModificationsCheckService().CheckChanges(LogList);
//Commit the DB
try
{
_unitOfWork.Save();
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
TempData["CSEXC"] += message;
return(PartialView("_Reason", vm));
}
//Logging Activity
LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
{
DocTypeId = SaleOrderHeader.DocTypeId,
DocId = SaleOrderHeader.SaleOrderHeaderId,
ActivityType = (int)ActivityTypeContants.Deleted,
UserRemark = vm.Reason,
DocNo = SaleOrderHeader.DocNo,
xEModifications = Modifications,
DocDate = SaleOrderHeader.DocDate,
DocStatus = SaleOrderHeader.Status,
}));
return(Json(new { success = true }));
}
return(PartialView("_Reason", vm));
}
public async Task <(CredentialIssueMessage, CredentialRecord)> CreateCredentialAsync(IAgentContext agentContext, string credentialId, IEnumerable <CredentialPreviewAttribute> values)
{
var credential = await GetAsync(agentContext, credentialId);
if (credential.State != CredentialState.Requested)
{
throw new AgentFrameworkException(ErrorCode.RecordInInvalidState,
$"Credential state was invalid. Expected '{CredentialState.Requested}', found '{credential.State}'");
}
if (values != null && values.Any())
{
credential.CredentialAttributesValues = values;
}
var definitionRecord =
await SchemaService.GetCredentialDefinitionAsync(agentContext.Wallet, credential.CredentialDefinitionId);
var connection = await ConnectionService.GetAsync(agentContext, credential.ConnectionId);
var provisioning = await ProvisioningService.GetProvisioningAsync(agentContext.Wallet);
if (connection.State != ConnectionState.Connected)
{
throw new AgentFrameworkException(ErrorCode.RecordInInvalidState,
$"Connection state was invalid. Expected '{ConnectionState.Connected}', found '{connection.State}'");
}
string revocationRegistryId = null;
BlobStorageReader tailsReader = null;
if (definitionRecord.SupportsRevocation)
{
var revocationRecordSearch = await RecordService.SearchAsync <RevocationRegistryRecord>(
agentContext.Wallet, SearchQuery.Equal(nameof(RevocationRegistryRecord.CredentialDefinitionId), definitionRecord.Id), null, 5);
var revocationRecord = revocationRecordSearch.Single(); // TODO: Credential definition can have multiple revocation registries
revocationRegistryId = revocationRecord.Id;
tailsReader = await TailsService.OpenTailsAsync(revocationRecord.TailsFile);
}
var issuedCredential = await AnonCreds.IssuerCreateCredentialAsync(agentContext.Wallet, credential.OfferJson,
credential.RequestJson, CredentialUtils.FormatCredentialValues(credential.CredentialAttributesValues), revocationRegistryId, tailsReader);
if (definitionRecord.SupportsRevocation)
{
var paymentInfo = await PaymentService.GetTransactionCostAsync(agentContext, TransactionTypes.REVOC_REG_ENTRY);
await LedgerService.SendRevocationRegistryEntryAsync(
wallet : agentContext.Wallet,
pool : await agentContext.Pool,
issuerDid : provisioning.IssuerDid,
revocationRegistryDefinitionId : revocationRegistryId,
revocationDefinitionType : "CL_ACCUM",
value : issuedCredential.RevocRegDeltaJson,
paymentInfo : paymentInfo);
credential.CredentialRevocationId = issuedCredential.RevocId;
if (paymentInfo != null)
{
await RecordService.UpdateAsync(agentContext.Wallet, paymentInfo.PaymentAddress);
}
}
await credential.TriggerAsync(CredentialTrigger.Issue);
await RecordService.UpdateAsync(agentContext.Wallet, credential);
var threadId = credential.GetTag(TagConstants.LastThreadId);
var credentialMsg = new CredentialIssueMessage
{
Credentials = new []
{
new Attachment
{
Id = "libindy-cred-0",
MimeType = CredentialMimeTypes.ApplicationJsonMimeType,
Data = new AttachmentContent
{
Base64 = issuedCredential.CredentialJson
.GetUTF8Bytes()
.ToBase64String()
}
}
}
};
credentialMsg.ThreadFrom(threadId);
return(credentialMsg, credential);
}
