public IActionResult ChangeStatus(TblAccount account) { var result = _accRepo.changeStatus(account); if (result == true) { return(Ok(result)); } return(NotFound()); }
public ActionResult CheckLogin(TblAccount account) { var result = _accRepo.CheckLogin(account); if (result != null) { return(Ok(result)); } return(NotFound()); }
// Sửa món ăn public void EditAccount(int ID, string UserName, string PassWord, string DisplayName, string Type) { TblAccount account = new TblAccount(); account = data.TblAccounts.Single(n => n.ID == ID); account.UserName = UserName; account.Pass = PassWord; account.DisplayName = DisplayName; account.AccountType = Type; data.SaveChanges(); }
public TblAccount Update(TblAccount account) { _context.Attach(account); IEnumerable <EntityEntry> unchangedEntities = _context.ChangeTracker.Entries().Where(x => x.State == EntityState.Unchanged); foreach (EntityEntry ee in unchangedEntities) { ee.State = EntityState.Modified; } _context.SaveChanges(); return(account); }
// Thêm Account public void AddAccount(string UserName, string PassWord, String DisplayName, string Type) { TblAccount account = new TblAccount() { UserName = UserName, Pass = PassWord, DisplayName = DisplayName, AccountType = Type }; data.TblAccounts.Add(account); data.SaveChanges(); }
private int DeleteTblAccount(TblAccount row, int index, string company) { using (var entity = new ccnewEntities(GetSqlConnectionString(company))) { var query = (from e in entity.TblAccounts where e.Iserial == row.Iserial select e).SingleOrDefault(); if (query != null) { entity.DeleteObject(query); } entity.SaveChanges(); } return(row.Iserial); }
private void UIElement_OnLostFocus(object sender, RoutedEventArgs e) { var txt = sender as TextBox; var currencyClient = new GlServiceClient(); currencyClient.GetTblAccountbyCodeCompleted += (s, sv) => { if (sv.Result != null) { SearchPerRow = sv.Result; } }; if (txt.Text != null) { currencyClient.GetTblAccountbyCodeAsync(txt.Text, LoggedUserInfo.DatabasEname, ChildOnlyPerRow); } }
public IActionResult SetPassword(SetPasswordViewModel model) { try { if (ModelState.IsValid) { using (var DB = _dbContext) { TblAccount oUser = _dbContext.TblAccounts.Where(x => x.UserName.Equals(model.EmailAddress)).SingleOrDefault(); oUser.Password = Encryption.EncryptText(model.ConfirmPassword); _dbContext.Entry(oUser).State = EntityState.Modified; _dbContext.SaveChanges(); ClaimsIdentity identity = null; identity = new ClaimsIdentity(new[] { new Claim(ClaimTypes.Name, oUser.UserName), new Claim(ClaimTypes.Role, "Company") }, CookieAuthenticationDefaults.AuthenticationScheme); var prinicpal = new ClaimsPrincipal(identity); var login = HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, prinicpal); SetCookie("EmailAddress", oUser.UserName); SetCookie("FullName", oUser.FullName); SetCookie("LoginAccountId", oUser.AccountId.ToString()); SetCookie("UserLoginTypeId", RoleType.Admin.GetHashCode().ToString()); if (model.KeepMeSigninIn) { return(RedirectToAction("Index", "Lead", new { area = "" })); } else { return(RedirectToAction("Login", "Account", new { area = "" })); } } } else { return(View(model)); } } catch (Exception ex) { string actionName = this.ControllerContext.RouteData.Values["action"].ToString(); string controllerName = this.ControllerContext.RouteData.Values["controller"].ToString(); ErrorLog.logError(DateTime.Now + "--" + actionName + "--" + controllerName + "--\n" + ex, Environment.WebRootPath); return(View(model)); } }
public bool changeStatus(TblAccount account) { var acc = _context.TblAccount.Where(record => record.Username == account.Username).FirstOrDefault(); if (acc == null) { return(false); } acc.Status = account.Status; var actor = _context.TblActor.Where(record => record.Username == account.Username).FirstOrDefault(); if (actor == null) { return(false); } actor.Status = account.Status; _context.SaveChanges(); return(true); }
public async Task <ActionResult <BankInfo> > PostBankInfo(BankInfo bankInfo) { _context.BankInfos.Add(bankInfo); await _context.SaveChangesAsync(); TblAccount tblAccount = new TblAccount() { AccountCode = bankInfo.AccountNo, AccountDescription = bankInfo.Iban, AccountTitle = bankInfo.Title, AccountTypeId = _context.AccountTypes.Where(x => x.AccountTypeName == "Asset").Select(x => x.AccountTypeId).FirstOrDefault(), DateAdded = DateTime.Now, IsActive = true }; _context.TblAccounts.Add(tblAccount); await _context.SaveChangesAsync(); return(CreatedAtAction("GetBankInfo", new { id = bankInfo.Id }, bankInfo)); }
public SearchAccountViewModel() { if (!IsDesignTime) { Glclient = new GlServiceClient(); MainRowList = new SortableCollectionView <TblAccount>(); SelectedMainRow = new TblAccount(); Glclient.GetTblAccountCompleted += (s, sv) => { foreach (var row in sv.Result) { MainRowList.Add(row); } Loading = false; FullCount = sv.fullCount; }; } }
public async Task <IActionResult> PutAccount(string id, string oldPassword, TblAccount account) { if (id != account.Username) { return(BadRequest()); } var acc = _context.TblAccount.Where(ac => ac.Username == id).FirstOrDefault(); if (acc != null) { if (oldPassword == acc.Password) { acc.Password = account.Password; } else { return(BadRequest("Wrong old password")); } } try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!AccountExists(id)) { return(NotFound()); } else { throw; } } return(Ok()); }
public async Task <int> UpdateActor(int id, ActorInfoVM actor) { TblAccount account = await _context.TblAccounts.FindAsync(id); if (account == null) { return(-1); } account.AccName = actor.AccName; account.AccPassword = actor.AccPassword; account.AccPhoneNum = actor.AccPhoneNum; account.AccImage = actor.AccImage; account.AccEmail = actor.AccEmail; account.AccDescription = actor.AccDescription; account.AccAdress = actor.AccAdress; account.AccUpdateBy = actor.AccUpdateBy; account.AccUpdateTime = actor.AccUpdateTime; _context.Entry(account).State = EntityState.Modified; try { await _context.SaveChangesAsync(); return(account.AccId); } catch (DbUpdateConcurrencyException) { if (!AccountExists(id)) { return(-1); } else { throw; } } }
private TblAccount UpdateOrInsertTblAccounts(TblAccount newRow, bool save, int index, out int outindex, string company) { outindex = index; using (var entity = new ccnewEntities(GetSqlConnectionString(company))) { if (save) { if (newRow.TblAccountType == 9) { newRow.TblAccountIntervals = new EntityCollection <TblAccountInterval> { new TblAccountInterval { FromRange = newRow.Code, ToRange = newRow.Code + "Z" } }; } entity.TblAccounts.AddObject(newRow); } else { var oldRow = (from e in entity.TblAccounts where e.Iserial == newRow.Iserial select e).SingleOrDefault(); if (oldRow != null) { GenericUpdate(oldRow, newRow, entity); } } entity.SaveChanges(); } return(newRow); }
public async Task <ActionResult <TblAccount> > Ledger(long id) { TblAccount tblAccount = new TblAccount(); try { // List<AccountTransaction> data = await _context.AccountTransactions.OrderByDescending(x => x.DateAdded).Include(x => x.AccountDebit).Include(x => x.AccountCredit).Where(x => x.AccountDebitId == id || x.AccountCreditId == id).ToListAsync(); tblAccount = await _context.TblAccounts.Include(x => x.AccountTransactionAccountDebits).OrderByDescending(x => x.DateAdded).Include(x => x.AccountTransactionAccountCredits).OrderByDescending(x => x.DateAdded).Include(x => x.AccountType).Include(x => x.Receivables).Include(x => x.Payable).FirstOrDefaultAsync(x => x.AccountId == id); foreach (var item in tblAccount.AccountTransactionAccountCredits) { item.AccountCredit = await _context.TblAccounts.FindAsync(item.AccountCreditId); item.AccountDebit = await _context.TblAccounts.FindAsync(item.AccountDebitId); } foreach (var item in tblAccount.AccountTransactionAccountDebits) { item.AccountCredit = await _context.TblAccounts.FindAsync(item.AccountCreditId); item.AccountDebit = await _context.TblAccounts.FindAsync(item.AccountDebitId); } } catch (Exception ex) { return(NotFound()); } if (tblAccount == null) { return(NotFound()); } return(tblAccount); }
public async Task <ActionResult <SaleContract> > PostSaleContract(SaleContract saleContract) { _context.SaleContracts.Add(saleContract); await _context.SaveChangesAsync(); var receivableExist = _context.Receivables.Where(x => x.CustomerId == saleContract.CustomerId && x.IsActive == true).FirstOrDefault(); //var payableExist = _context.Payables.Where(x => x.PayableName == saleContract.SaleContractNumber && x.IsActive==true).FirstOrDefault(); if (receivableExist != null) { //var tblAccountSaleContractExist = _context.TblAccounts.Where(x => x.AccountCode == saleContract.SaleContractNumber && x.PayableId == saleContract.SaleContractId); //Add Payable Payable payable = new Payable() { DateAdded = DateTime.Now, IsActive = true, PayableAddress = saleContract.ShipmentDetails, PayableDescription = "Sale Contract is Paybale", PayableName = saleContract.SaleContractNumber, PayablePhone = receivableExist.ReceivablePhone }; _context.Payables.Add(payable); await _context.SaveChangesAsync(); // Add Sale Contract Account TblAccount tblAccountSaleContract = new TblAccount() { AccountCode = saleContract.SaleContractNumber, AccountDescription = saleContract.SaleContractNumber, AccountTitle = saleContract.SaleContractNumber, AccountTypeId = _context.AccountTypes.Where(x => x.AccountTypeName == "Liabilities").Select(x => x.AccountTypeId).FirstOrDefault(), DateAdded = DateTime.Now, IsActive = true, PayableId = payable.PayableId }; _context.TblAccounts.Add(tblAccountSaleContract); try { await _context.SaveChangesAsync(); } catch (Exception ex) { var x = 0; } var tblAccountReceivableExist = _context.TblAccounts.Where(x => x.AccountCode == receivableExist.ReceivableId.ToString() && x.AccountTitle == receivableExist.ReceivableName && x.ReceivablesId == receivableExist.ReceivableId).FirstOrDefault(); if (tblAccountReceivableExist == null) { //Add Receiveable Account TblAccount tblAccountReceivable = new TblAccount() { AccountCode = receivableExist.ReceivableId.ToString(), AccountDescription = saleContract.SaleContractNumber, AccountTitle = receivableExist.ReceivableName, AccountTypeId = _context.AccountTypes.Where(x => x.AccountTypeName == "Receivables").Select(x => x.AccountTypeId).FirstOrDefault(), DateAdded = DateTime.Now, IsActive = true, ReceivablesId = receivableExist.ReceivableId }; _context.TblAccounts.Add(tblAccountReceivable); await _context.SaveChangesAsync(); // Add Double Entry of Receivable (DR) and Sale Contract Account (CR) AccountTransaction accountTransaction = new AccountTransaction() { Type = _context.TransactionTypes.Where(x => x.TransactionTypeName == "SalesContract").Select(x => x.TransactionTypeId).FirstOrDefault(), AccountDebitId = tblAccountReceivable.AccountId, AccountCreditId = tblAccountSaleContract.AccountId, AccountDebitCode = tblAccountReceivable.AccountCode, AccountCreditCode = tblAccountSaleContract.AccountCode, Narration = "Sale Contract Creation", AmountDebit = saleContract.TotalAmount, AmountCredit = saleContract.TotalAmount, SaleContractNumber = saleContract.SaleContractNumber, DateAdded = DateTime.Now, IsActive = true }; _context.AccountTransactions.Add(accountTransaction); try { await _context.SaveChangesAsync(); } catch (Exception ex) { var x = 0; } } else { // Add Double Entry of Receivable (DR) and Sale Contract Account (CR) AccountTransaction accountTransaction = new AccountTransaction() { Type = _context.TransactionTypes.Where(x => x.TransactionTypeName == "SalesContract").Select(x => x.TransactionTypeId).FirstOrDefault(), AccountDebitId = tblAccountReceivableExist.AccountId, AccountCreditId = tblAccountSaleContract.AccountId, AccountDebitCode = tblAccountReceivableExist.AccountCode, AccountCreditCode = tblAccountSaleContract.AccountCode, Narration = "Sale Contract Creation", AmountDebit = saleContract.TotalAmount, AmountCredit = saleContract.TotalAmount, SaleContractNumber = saleContract.SaleContractNumber, SaleContractId = saleContract.SaleContractId, DateAdded = DateTime.Now, IsActive = true }; _context.AccountTransactions.Add(accountTransaction); try { await _context.SaveChangesAsync(); } catch (Exception ex) { var x = 0; } } } if (receivableExist == null) { //Add Receiveable var customer = await _context.Customers.FindAsync(saleContract.CustomerId); Receivable receivable = new Receivable() { CustomerId = customer.CustomerId, DateAdded = DateTime.Now, IsActive = true, ReceivableAddress = customer.Address, ReceivableDescription = "Customer with Sale Contract", ReceivableName = customer.CustomerName, ReceivablePhone = customer.Contact }; _context.Receivables.Add(receivable); await _context.SaveChangesAsync(); //Add Payable Payable payable = new Payable() { DateAdded = DateTime.Now, IsActive = true, PayableAddress = saleContract.ShipmentDetails, PayableDescription = "Sale Contract is Paybale", PayableName = saleContract.SaleContractNumber, PayablePhone = customer.Contact }; _context.Payables.Add(payable); await _context.SaveChangesAsync(); //Add Receiveable Account TblAccount tblAccountReceivable = new TblAccount() { AccountCode = receivable.ReceivableId.ToString(), AccountDescription = saleContract.SaleContractNumber, AccountTitle = receivable.ReceivableName, AccountTypeId = _context.AccountTypes.Where(x => x.AccountTypeName == "Receivables").Select(x => x.AccountTypeId).FirstOrDefault(), DateAdded = DateTime.Now, IsActive = true, ReceivablesId = receivable.ReceivableId }; _context.TblAccounts.Add(tblAccountReceivable); // Add Sale Contract Account TblAccount tblAccountSaleContract = new TblAccount() { AccountCode = saleContract.SaleContractNumber, AccountDescription = saleContract.SaleContractNumber, AccountTitle = saleContract.SaleContractNumber, AccountTypeId = _context.AccountTypes.Where(x => x.AccountTypeName == "Liabilities").Select(x => x.AccountTypeId).FirstOrDefault(), DateAdded = DateTime.Now, IsActive = true, PayableId = payable.PayableId }; _context.TblAccounts.Add(tblAccountSaleContract); await _context.SaveChangesAsync(); // Add Double Entry of Receivable (DR) and Sale Contract Account (CR) AccountTransaction accountTransaction = new AccountTransaction() { Type = _context.TransactionTypes.Where(x => x.TransactionTypeName == "SalesContract").Select(x => x.TransactionTypeId).FirstOrDefault(), AccountDebitId = tblAccountReceivable.AccountId, AccountCreditId = tblAccountSaleContract.AccountId, AccountDebitCode = tblAccountReceivable.AccountCode, AccountCreditCode = tblAccountSaleContract.AccountCode, Narration = "Sale Contract Creation", AmountDebit = saleContract.TotalAmount, AmountCredit = saleContract.TotalAmount, SaleContractNumber = saleContract.SaleContractNumber, SaleContractId = saleContract.SaleContractId, DateAdded = DateTime.Now, IsActive = true }; _context.AccountTransactions.Add(accountTransaction); await _context.SaveChangesAsync(); } return(CreatedAtAction("GetSaleContract", new { id = saleContract.SaleContractId }, saleContract)); }
/// <param name='id'> /// </param> /// <param name='tblAccount'> /// </param> /// <param name='customHeaders'> /// Headers that will be added to request. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> /// <return> /// A response object containing the response body and response headers. /// </return> public async Task <HttpOperationResponse> PuttblWithHttpMessagesAsync(string id, TblAccount tblAccount, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken)) { if (id == null) { throw new ValidationException(ValidationRules.CannotBeNull, "id"); } if (tblAccount == null) { throw new ValidationException(ValidationRules.CannotBeNull, "tblAccount"); } if (tblAccount != null) { tblAccount.Validate(); } // Tracing bool _shouldTrace = ServiceClientTracing.IsEnabled; string _invocationId = null; if (_shouldTrace) { _invocationId = ServiceClientTracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("id", id); tracingParameters.Add("tblAccount", tblAccount); tracingParameters.Add("cancellationToken", cancellationToken); ServiceClientTracing.Enter(_invocationId, this, "Puttbl", tracingParameters); } // Construct URL var _baseUrl = this.Client.BaseUri.AbsoluteUri; var _url = new Uri(new Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "api/account/{id}").ToString(); _url = _url.Replace("{id}", Uri.EscapeDataString(id)); // Create HTTP transport objects HttpRequestMessage _httpRequest = new HttpRequestMessage(); HttpResponseMessage _httpResponse = null; _httpRequest.Method = new HttpMethod("PUT"); _httpRequest.RequestUri = new Uri(_url); // Set Headers if (customHeaders != null) { foreach (var _header in customHeaders) { if (_httpRequest.Headers.Contains(_header.Key)) { _httpRequest.Headers.Remove(_header.Key); } _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value); } } // Serialize Request string _requestContent = null; if (tblAccount != null) { _requestContent = SafeJsonConvert.SerializeObject(tblAccount, this.Client.SerializationSettings); _httpRequest.Content = new StringContent(_requestContent, Encoding.UTF8); _httpRequest.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json; charset=utf-8"); } // Set Credentials if (this.Client.Credentials != null) { cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false); } // Send Request if (_shouldTrace) { ServiceClientTracing.SendRequest(_invocationId, _httpRequest); } cancellationToken.ThrowIfCancellationRequested(); _httpResponse = await this.Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false); if (_shouldTrace) { ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse); } HttpStatusCode _statusCode = _httpResponse.StatusCode; cancellationToken.ThrowIfCancellationRequested(); string _responseContent = null; if ((int)_statusCode != 204) { var ex = new HttpOperationException(string.Format("Operation returned an invalid status code '{0}'", _statusCode)); _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent); ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent); if (_shouldTrace) { ServiceClientTracing.Error(_invocationId, ex); } _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw ex; } // Create Result var _result = new HttpOperationResponse(); _result.Request = _httpRequest; _result.Response = _httpResponse; if (_shouldTrace) { ServiceClientTracing.Exit(_invocationId, _result); } return(_result); }
public async Task <ActionResult <FactoryOverheadExpense> > PostFactoryOverheadExpense(FactoryOverheadExpense factoryOverheadExpense) { _context.FactoryOverheadExpenses.Add(factoryOverheadExpense); await _context.SaveChangesAsync(); var factoryOverheadAccountExist = _context.TblAccounts.Where(x => x.AccountCode == "FOH").FirstOrDefault(); var paymentSourceAccountExist = _context.TblAccounts.Where(x => x.AccountId == factoryOverheadExpense.PaymentSourceAccountId).FirstOrDefault(); if (factoryOverheadAccountExist != null) { // Add Double Entry of Factory Overhead Account (DR) and Cash/Bank Account (CR) AccountTransaction accountTransaction = new AccountTransaction() { Type = _context.TransactionTypes.Where(x => x.TransactionTypeName == "FOH").Select(x => x.TransactionTypeId).FirstOrDefault(), AccountDebitId = factoryOverheadAccountExist.AccountId, AccountCreditId = paymentSourceAccountExist.AccountId, AccountDebitCode = factoryOverheadAccountExist.AccountCode, AccountCreditCode = paymentSourceAccountExist.AccountCode, Narration = factoryOverheadExpense.Description, AmountDebit = factoryOverheadExpense.Amount, AmountCredit = factoryOverheadExpense.Amount, SaleContractNumber = "N/A", DateAdded = DateTime.Now, IsActive = true }; _context.AccountTransactions.Add(accountTransaction); try { await _context.SaveChangesAsync(); } catch (Exception ex) { var x = 0; } } else { //Add FOH Account TblAccount factoryOverheadAccount = new TblAccount() { AccountCode = "FOH", AccountDescription = "Factory Overhead Account", AccountTitle = "Factory Overhead", AccountTypeId = _context.AccountTypes.Where(x => x.AccountTypeName == "Expense").Select(x => x.AccountTypeId).FirstOrDefault(), DateAdded = DateTime.Now, IsActive = true }; _context.TblAccounts.Add(factoryOverheadAccount); await _context.SaveChangesAsync(); // Add Double Entry of Factory Overhead Account (DR) and Cash/Bank Account (CR) AccountTransaction accountTransaction = new AccountTransaction() { Type = _context.TransactionTypes.Where(x => x.TransactionTypeName == "FOH").Select(x => x.TransactionTypeId).FirstOrDefault(), AccountDebitId = factoryOverheadAccount.AccountId, AccountCreditId = paymentSourceAccountExist.AccountId, AccountDebitCode = factoryOverheadAccount.AccountCode, AccountCreditCode = paymentSourceAccountExist.AccountCode, Narration = factoryOverheadExpense.Description, AmountDebit = factoryOverheadExpense.Amount, AmountCredit = factoryOverheadExpense.Amount, SaleContractNumber = "N/A", DateAdded = DateTime.Now, IsActive = true }; _context.AccountTransactions.Add(accountTransaction); try { await _context.SaveChangesAsync(); } catch (Exception ex) { var x = 0; } } return(CreatedAtAction("GetFactoryOverheadExpense", new { id = factoryOverheadExpense.Fohid }, factoryOverheadExpense)); }
/// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='tblAccount'> /// </param> public static TblAccount Posttbl(this IAccount operations, TblAccount tblAccount) { return(Task.Factory.StartNew(s => ((IAccount)s).PosttblAsync(tblAccount), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult()); }
/// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='id'> /// </param> /// <param name='tblAccount'> /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task PuttblAsync(this IAccount operations, string id, TblAccount tblAccount, CancellationToken cancellationToken = default(CancellationToken)) { await operations.PuttblWithHttpMessagesAsync(id, tblAccount, null, cancellationToken).ConfigureAwait(false); }
/// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='id'> /// </param> /// <param name='tblAccount'> /// </param> public static void Puttbl(this IAccount operations, string id, TblAccount tblAccount) { Task.Factory.StartNew(s => ((IAccount)s).PuttblAsync(id, tblAccount), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult(); }
public async Task <ActionResult <SaleContractExpense> > PostSaleContractExpense(SaleContractExpense saleContractExpense) { _context.SaleContractExpenses.Add(saleContractExpense); await _context.SaveChangesAsync(); var saleContractAccountExist = _context.TblAccounts.Where(x => x.AccountCode == saleContractExpense.SaleContractNumber).FirstOrDefault(); var paymentSourceAccountExist = _context.TblAccounts.Where(x => x.AccountId == saleContractExpense.PaymentSourceAccountId).FirstOrDefault(); if (saleContractAccountExist != null) { // Add Double Entry of Sale Contract Account (DR) and Cash/Bank Account (CR) AccountTransaction accountTransaction = new AccountTransaction() { Type = _context.TransactionTypes.Where(x => x.TransactionTypeName == "SaleContractExpense").Select(x => x.TransactionTypeId).FirstOrDefault(), AccountDebitId = saleContractAccountExist.AccountId, AccountCreditId = paymentSourceAccountExist.AccountId, AccountDebitCode = saleContractAccountExist.AccountCode, AccountCreditCode = paymentSourceAccountExist.AccountCode, Narration = saleContractExpense.Description, AmountDebit = saleContractExpense.Amount, AmountCredit = saleContractExpense.Amount, SaleContractNumber = saleContractExpense.SaleContractNumber, DateAdded = DateTime.Now, IsActive = true }; _context.AccountTransactions.Add(accountTransaction); try { await _context.SaveChangesAsync(); } catch (Exception ex) { var x = 0; } } else { // Add Sale Contract Account TblAccount tblAccountSaleContract = new TblAccount() { AccountCode = saleContractExpense.SaleContractNumber, AccountDescription = saleContractExpense.SaleContractNumber, AccountTitle = saleContractExpense.SaleContractNumber, AccountTypeId = _context.AccountTypes.Where(x => x.AccountTypeName == "Liabilities").Select(x => x.AccountTypeId).FirstOrDefault(), DateAdded = DateTime.Now, IsActive = true }; _context.TblAccounts.Add(tblAccountSaleContract); try { await _context.SaveChangesAsync(); } catch (Exception ex) { var x = 0; } // Add Double Entry of Sale Contract Account (DR) and Cash/Bank Account (CR) AccountTransaction accountTransaction = new AccountTransaction() { Type = _context.TransactionTypes.Where(x => x.TransactionTypeName == "SaleContractExpense").Select(x => x.TransactionTypeId).FirstOrDefault(), AccountDebitId = tblAccountSaleContract.AccountId, AccountCreditId = paymentSourceAccountExist.AccountId, AccountDebitCode = tblAccountSaleContract.AccountCode, AccountCreditCode = paymentSourceAccountExist.AccountCode, Narration = saleContractExpense.Description, AmountDebit = saleContractExpense.Amount, AmountCredit = saleContractExpense.Amount, SaleContractNumber = saleContractExpense.SaleContractNumber, DateAdded = DateTime.Now, IsActive = true }; _context.AccountTransactions.Add(accountTransaction); try { await _context.SaveChangesAsync(); } catch (Exception ex) { var x = 0; } } return(CreatedAtAction("GetSaleContractExpense", new { id = saleContractExpense.ExpenseId }, saleContractExpense)); }
public async Task <ActionResult <FabricPurchase> > PostFabricPurchase(FabricPurchase fabricPurchase) { _context.FabricPurchases.Add(fabricPurchase); await _context.SaveChangesAsync(); //if (fabricPurchase.IsConversionContract == false) //{ // For Fabric Purchase Contract var payableExist = _context.Payables.Where(x => x.PayableId == fabricPurchase.Weaver && x.IsActive == true).FirstOrDefault(); if (payableExist != null) { var tblAccountPayableExist = _context.TblAccounts.Where(x => x.AccountCode == payableExist.PayableId.ToString() && x.AccountTitle == payableExist.PayableName && x.PayableId == payableExist.PayableId).FirstOrDefault(); if (tblAccountPayableExist != null) { var tblAccountSaleContractExist = _context.TblAccounts.Where(x => x.AccountCode == fabricPurchase.SaleContractNumber).FirstOrDefault(); // Add Double Entry of PAYABLE (CR) and Sale Contract Account (DR) AccountTransaction accountTransaction = new AccountTransaction() { Type = _context.TransactionTypes.Where(x => x.TransactionTypeName == "FabricPurchase").Select(x => x.TransactionTypeId).FirstOrDefault(), AccountDebitId = tblAccountSaleContractExist.AccountId, AccountCreditId = tblAccountPayableExist.AccountId, AccountDebitCode = tblAccountSaleContractExist.AccountCode, AccountCreditCode = tblAccountPayableExist.AccountCode, Narration = "Fabric Purchase Contract Creation", AmountDebit = fabricPurchase.QuantityInMeters * fabricPurchase.PerMeterRate, AmountCredit = fabricPurchase.QuantityInMeters * fabricPurchase.PerMeterRate, SaleContractNumber = fabricPurchase.SaleContractNumber, DateAdded = DateTime.Now, IsActive = true }; _context.AccountTransactions.Add(accountTransaction); try { await _context.SaveChangesAsync(); } catch (Exception ex) { var x = 0; } } else { //Add Payable Account TblAccount tblAccountPayable = new TblAccount() { AccountCode = payableExist.PayableId.ToString(), AccountDescription = fabricPurchase.SaleContractNumber, AccountTitle = payableExist.PayableName, AccountTypeId = _context.AccountTypes.Where(x => x.AccountTypeName == "Payable").Select(x => x.AccountTypeId).FirstOrDefault(), DateAdded = DateTime.Now, IsActive = true, ReceivablesId = payableExist.PayableId }; _context.TblAccounts.Add(tblAccountPayable); try { await _context.SaveChangesAsync(); } catch (Exception ex) { var x = 0; } var tblAccountSaleContractExist = _context.TblAccounts.Where(x => x.AccountCode == fabricPurchase.SaleContractNumber).FirstOrDefault(); // Add Double Entry of PAYABLE (CR) and Sale Contract Account (DR) AccountTransaction accountTransaction = new AccountTransaction() { Type = _context.TransactionTypes.Where(x => x.TransactionTypeName == "FabricPurchase").Select(x => x.TransactionTypeId).FirstOrDefault(), AccountDebitId = tblAccountSaleContractExist.AccountId, AccountCreditId = tblAccountPayable.AccountId, AccountDebitCode = tblAccountSaleContractExist.AccountCode, AccountCreditCode = tblAccountPayable.AccountCode, Narration = "Fabric Purchase Contract Creation", AmountDebit = fabricPurchase.QuantityInMeters * fabricPurchase.PerMeterRate, AmountCredit = fabricPurchase.QuantityInMeters * fabricPurchase.PerMeterRate, SaleContractNumber = fabricPurchase.SaleContractNumber, DateAdded = DateTime.Now, IsActive = true }; _context.AccountTransactions.Add(accountTransaction); try { await _context.SaveChangesAsync(); } catch (Exception ex) { var x = 0; } } } //} //else //{ // //programming for conversion contract //} return(CreatedAtAction("GetFabricPurchase", new { id = fabricPurchase.FabricPurchaseId }, fabricPurchase)); }
public async Task <IActionResult> MicrosoftResponse() { try { // Here the following code reperesent that user is sucessfully authenticated by microsoft var result = await HttpContext.AuthenticateAsync(CookieAuthenticationDefaults.AuthenticationScheme); if (result.Principal.Claims.Count() <= 0) { throw new Exception("User is not authorize!"); } // Here the following code reperesent that user is sucessfully authenticated by google. //We are taking user's information and redirecting user to his environment. TblAccount oUser = new TblAccount(); oUser.UserName = result.Principal.FindFirst(ClaimTypes.Email).Value; oUser.FullName = result.Principal.FindFirst(ClaimTypes.Name).Value; oUser.RoleId = RoleType.Admin.GetHashCode(); oUser.IsOwner = true; oUser.Status = true; if (!IsCompanyExist(oUser.UserName)) { oUser.CreatedDate = DateTime.Now; _dbContext.TblAccounts.Add(oUser); _dbContext.SaveChanges(); TblAccountCompany oDataCompany = new TblAccountCompany(); oDataCompany.AccountId = oUser.AccountId; oDataCompany.AddedBy = oUser.AccountId; oDataCompany.CreatedDate = DateTime.Now; _dbContext.TblAccountCompanies.Add(oDataCompany); _dbContext.SaveChanges(); } else { oUser = _dbContext.TblAccounts.Where(x => x.UserName.Equals(oUser.UserName)).FirstOrDefault(); } if (string.IsNullOrEmpty(oUser.Password)) { TempData["EmailAddress"] = oUser.UserName; TempData.Keep(); return(RedirectToAction("SetPassword", "Company")); } else { //Here we are storing claims for authentication ClaimsIdentity identity = null; identity = new ClaimsIdentity(new[] { new Claim(ClaimTypes.Name, oUser.UserName), new Claim(ClaimTypes.Role, "Company") }, CookieAuthenticationDefaults.AuthenticationScheme); var prinicpal = new ClaimsPrincipal(identity); var login = HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, prinicpal); //Redirection of lead user is here. Please give appropreate direction URL to it SetCookie("EmailAddress", oUser.UserName); SetCookie("FullName", oUser.FullName); SetCookie("LoginAccountId", oUser.AccountId.ToString()); SetCookie("UserLoginTypeId", RoleType.Admin.GetHashCode().ToString()); //SetCookie("EmailAddress", oCompany.Email); //SetCookie("FullName", oCompany.FullName); //SetCookie("LoginAccountId", oCompany.CompanyId.ToString()); //SetCookie("UserLoginTypeId", UserLoginType.Company.GetHashCode().ToString()); return(RedirectToAction("Index", "Lead")); } } catch (Exception ex) { string actionName = this.ControllerContext.RouteData.Values["action"].ToString(); string controllerName = this.ControllerContext.RouteData.Values["controller"].ToString(); ErrorLog.logError(DateTime.Now + "--" + actionName + "--" + controllerName + "--\n" + ex, Environment.WebRootPath); return(RedirectToAction("Login", "Account")); } }