protected new void Page_Load(object sender, EventArgs e)
{
base.AllowHttpMethod("GET", "POST");
base.DisableTop(false);
if (Request.HttpMethod.Equals("POST"))
{
Dictionary <string, DateTime> dict = new Dictionary <string, DateTime>();
dict.Add("nowLogin", AuthServer.GetLoginUser().LoginDate);
nowLogin = JsonConvert.SerializeObject(dict);
UserID = GetNumber <int>("i");
DataTable dt = MSDB.GetDataTable("ConnUser", "dbo.usp_AccountM_xGetAccountDetailByID"
, new Dictionary <string, object>()
{
{ "@UserID", UserID }
});
VM = new AccountDetailVM();
EntityS.FillModel(VM, dt);
ApplyDate = VM.ApplyDate.ToShortTaiwanDate();
}
else
{
Response.Write("");
Response.End();
}
}
public IActionResult RegisterAccount(AccountDetailVM vm)
{
Account account = vmConverter.ViewModelToModel(vm);
accountContainer.Insert(account);
return(RedirectToAction("Index", "Forum"));
}
public IActionResult Profile(int id)
{
AccountDetailVM account = new AccountDetailVM();
account = vmConverter.ModelToViewModel(accountContainer.GetById(id));
return(View(account));
}
public IHttpActionResult AccountDetails([FromBody] int id)
{
var user = db.Users.Find(User.Identity.GetUserId());
Account account = user.Household.Accounts.FirstOrDefault(a => a.Id == id);
AccountDetailVM accountDetail = new AccountDetailVM()
{
Id = account.Id,
Name = account.Name,
Balance = account.Balance,
HouseholdId = account.HouseholdId,
Archived = account.Archived,
Transactions = account.Transactions.Select(t => new AccountDetailVM.Transaction
{
Id = t.Id,
Description = t.Description,
Amount = t.Amount,
Created = t.Created,
Updated = t.Updated,
Reconciled = t.Reconciled,
AccountId = t.AccountId,
CategoryId = t.CategoryId,
Archived = t.Archived,
IsIncome = t.IsIncome
}).ToList()
};
return(Ok(accountDetail));
}
public async Task <BodyResponse <AccountDetailVM> > GetSelfAccount(long id)
{
var response = await _bus.SendCommand(new GetSelfAccountCommand(id));
AccountDetailVM info = _mapper.Map <AccountDetailVM>(response.Body);
return(new BodyResponse <AccountDetailVM>(response.StatusCode, response.ErrorInfos, info));
}
public async Task <IHttpActionResult> delete([FromBody] AccountDetailVM entity)
{
var result = await _AcountsDetailsService.DeleteAsync(entity);
await LogData(null, entity.PARENT_ACC_ID.ToString());
return(Ok(result));
}
public IActionResult Index()
{
if (HttpContext.Session.GetInt32("User") != null)
{
AccountDetailVM account = new AccountDetailVM();
account = JsonConvert.DeserializeObject <AccountDetailVM>(HttpContext.Session.GetString("User"));
}
return(View());
}
public Account(AccountDetailVM account)
{
AccountName = account.AccountName;
LocalId = account.AccountId;
Notes = account.Notes;
AccountType = Constants.Accounts.GetDisplay(account.AccountType).TypeName;
DateTime_Created = account.DateTime_Created;
DateTime_Deactivated = account.DateTime_Deactivated;
}
public IActionResult Index()
{
if (HttpContext.Session.GetInt32("User") != null)
{
AccountDetailVM user = new AccountDetailVM();
user = JsonConvert.DeserializeObject <AccountDetailVM>(HttpContext.Session.GetString("User"));
return(View(user));
}
return(RedirectToAction("Index", "Login"));
}
public IActionResult Login(AccountDetailVM vm)
{
if (ModelState.IsValid)
{
vm = converter.ModelToViewModel(accountContainer.GetByName(converter.ViewModelToModel(vm)));
if (vm.Id != 0)
{
HttpContext.Session.SetString("User", JsonConvert.SerializeObject(vm));
return(RedirectToAction("Index", "Forum"));
}
}
return(View(vm));
}
public IActionResult Create(ForumDetailVM vm)
{
if (HttpContext.Session.GetInt32("User") != null)
{
AccountDetailVM account = new AccountDetailVM();
account = JsonConvert.DeserializeObject <AccountDetailVM>(HttpContext.Session.GetString("User"));
Forum forum = forumConverter.ViewModelToModel(vm);
forum.CreatorID = account.Id;
forumContainer.Insert(forum);
return(RedirectToAction("Index"));
}
return(RedirectToAction("Index", "Login"));
}
public IActionResult SendMessage(MessageDetailVM vm)
{
if (HttpContext.Session.GetInt32("User") != null)
{
AccountDetailVM account = new AccountDetailVM();
account = JsonConvert.DeserializeObject <AccountDetailVM>(HttpContext.Session.GetString("User"));
Message message = messageVMConverter.ViewModelToModel(vm);
message.SenderId = account.Id;
messageContainer.Insert(message);
return(RedirectToAction("Index"));
}
return(RedirectToAction("Index", "Login"));
}
public async Task <IHttpActionResult> add([FromBody] AccountDetailVM entity)
{
var controllerName = ControllerContext.RouteData.Values["controller"];
var result = await _AcountsDetailsService.InsertAsync(entity);
await LogData(null, result.ToString());
if (result != 0)
{
return(Ok(true));
}
return(Ok(false));
}
public IActionResult Create()
{
if (HttpContext.Session.GetInt32("User") != null)
{
AccountDetailVM account = new AccountDetailVM();
account = JsonConvert.DeserializeObject <AccountDetailVM>(HttpContext.Session.GetString("User"));
if (account.Administrator)
{
return(View());
}
}
return(RedirectToAction("Index", "Login"));
}
internal IncomeSourceDetailVM SaveAccount(IncomeSourceDetailVM account)
{
AccountDetailVM baseAccount = SaveAccount((AccountDetailVM)account);
account.AccountId = baseAccount.AccountId;
IncomeSource result = Repo.SaveAccount(new IncomeSource(account));
Schedule accountSchedule = null;
if (result.ScheduleId.HasValue)
{
accountSchedule = Repo.GetSchedule(result.ScheduleId.Value);
}
return(new IncomeSourceDetailVM(result, baseAccount, accountSchedule));
}
public IActionResult CreatePost(PostDetailVM vm)
{
if (HttpContext.Session.GetInt32("User") != null)
{
AccountDetailVM account = new AccountDetailVM();
account = JsonConvert.DeserializeObject <AccountDetailVM>(HttpContext.Session.GetString("User"));
Post post = vmconverter.ViewModelToModel(vm);
post.AccountId = account.Id;
int forumId = JsonConvert.DeserializeObject <int>(HttpContext.Session.GetString("forumId"));
post.ForumId = forumId;
Container.Insert(post);
return(RedirectToAction("Index"));
}
return(RedirectToAction("Index", "Login"));
}
public IActionResult Detail(int postID)
{
if (HttpContext.Session.GetInt32("User") != null)
{
AccountDetailVM account = new AccountDetailVM();
account = JsonConvert.DeserializeObject <AccountDetailVM>(HttpContext.Session.GetString("User"));
PostDetailVM vm = new PostDetailVM();
Post post = Container.GetById(postID);
post.Replies = replyContainer.GetAll();
HttpContext.Session.SetString("Id", JsonConvert.SerializeObject(post.Id));
vm = vmconverter.ModelToViewModel(post);
vm.account = account;
return(View(vm));
}
return(RedirectToAction("Index", "Login"));
}
public IActionResult Detail(int ForumID)
{
if (HttpContext.Session.GetInt32("User") != null)
{
ForumDetailVM vm = new ForumDetailVM();
Forum forum = forumContainer.GetById(ForumID);
forum.Posts = postContainer.GetAll();
vm = forumConverter.ModelToViewModel(forum);
vm.posts = postConverter.ModelsToViewModels(forum.Posts);
AccountDetailVM account = JsonConvert.DeserializeObject <AccountDetailVM>(HttpContext.Session.GetString("User"));
vm.account = account;
HttpContext.Session.SetString("forumId", JsonConvert.SerializeObject(forum.Id));
return(View(vm));
}
return(RedirectToAction("Index", "Login"));
}
public IActionResult Index()
{
if (HttpContext.Session.GetInt32("User") != null)
{
AccountDetailVM account = new AccountDetailVM();
account = JsonConvert.DeserializeObject <AccountDetailVM>(HttpContext.Session.GetString("User"));
PostViewModel vm = new PostViewModel();
List <Post> posts = new List <Post>();
posts = Container.GetAll();
int forumId = JsonConvert.DeserializeObject <int>(HttpContext.Session.GetString("forumId"));
vm.PostViewModels = vmconverter.ModelsToViewModels(posts);
vm.currentForumId = forumId;
vm.account = account;
return(View(vm));
}
return(RedirectToAction("Index", "Login"));
}
public bool Delete(AccountDetailVM entity)
{
ACCOUNT_DETAILS emp = new ACCOUNT_DETAILS
{
PARENT_ACC_ID = entity.PARENT_ACC_ID,
AddedBy = entity.AddedBy,
AddedOn = entity.AddedOn,
CHILD_ACC_ID = entity.CHILD_ACC_ID,
Disable = entity.Disable,
PARTITIONING_FACTOR = entity.PARTITIONING_FACTOR,
UpdatedBy = entity.UpdatedBy,
UpdatedOn = entity.UpdatedOn
};
_ACCOUNT_DETAILSRepo.Delete(emp, entity.PARENT_ACC_ID);
return(true);
}
public IActionResult Delete(int id)
{
if (HttpContext.Session.GetInt32("User") != null)
{
AccountDetailVM account = new AccountDetailVM();
account = JsonConvert.DeserializeObject <AccountDetailVM>(HttpContext.Session.GetString("User"));
if (account.Administrator)
{
Reply r = replyContainer.GetById(id);
replyContainer.Delete(r);
int postID = JsonConvert.DeserializeObject <int>(HttpContext.Session.GetString("Id"));
return(Redirect("~/Post/Detail/?postID=" + postID));
}
return(RedirectToAction("Index", "Login"));
}
return(RedirectToAction("Index", "Login"));
}
public IActionResult Create(ReplyDetailVM vm)
{
if (HttpContext.Session.GetInt32("User") != null)
{
Reply reply = vmconverter.ViewModelToModel(vm);
AccountDetailVM account = new AccountDetailVM();
account = JsonConvert.DeserializeObject <AccountDetailVM>(HttpContext.Session.GetString("User"));
int accountID = account.Id;
int postID = JsonConvert.DeserializeObject <int>(HttpContext.Session.GetString("Id"));
reply.PostId = postID;
reply.AccountId = accountID;
reply.Username = account.Username;
replyContainer.Insert(reply);
return(Redirect("~/Post/Detail/?postID=" + postID));
}
return(RedirectToAction("Index", "Login"));
}
public IActionResult Index()
{
if (HttpContext.Session.GetInt32("User") != null)
{
HttpContext.Session.Remove("forumId");
AccountDetailVM account = new AccountDetailVM();
ForumVM vm = new ForumVM();
List <Forum> forums = new List <Forum>();
forums = forumContainer.GetAll();
vm.Forums = forumConverter.ModelsToViewModels(forums);
foreach (ForumDetailVM detailVM in vm.Forums)
{
detailVM.Creator = accountConverter.ModelToViewModel(accountContainer.GetById(detailVM.CreatorID));
}
return(View(vm));
}
return(RedirectToAction("Index", "Login"));
}
public Task <bool> DeleteAsync(AccountDetailVM entity)
{
return(Task.Run <bool>(() =>
{
ACCOUNT_DETAILS emp = new ACCOUNT_DETAILS
{
PARENT_ACC_ID = entity.PARENT_ACC_ID,
AddedBy = entity.AddedBy,
AddedOn = entity.AddedOn,
CHILD_ACC_ID = entity.CHILD_ACC_ID,
Disable = entity.Disable,
PARTITIONING_FACTOR = entity.PARTITIONING_FACTOR,
UpdatedBy = entity.UpdatedBy,
UpdatedOn = entity.UpdatedOn
};
_ACCOUNT_DETAILSRepo.Delete(emp, entity.PARENT_ACC_ID);
return true;
}));
}
public Task <int> InsertAsync(AccountDetailVM entity)
{
return(Task.Run <int>(() =>
{
ACCOUNT_DETAILS emp = new ACCOUNT_DETAILS
{
AddedBy = entity.AddedBy,
AddedOn = entity.AddedOn,
CHILD_ACC_ID = entity.CHILD_ACC_ID,
Disable = entity.Disable,
PARENT_ACC_ID = entity.PARENT_ACC_ID,
PARTITIONING_FACTOR = entity.PARTITIONING_FACTOR,
UpdatedBy = entity.UpdatedBy,
UpdatedOn = entity.UpdatedOn
};
_ACCOUNT_DETAILSRepo.Add(emp);
return emp.PARENT_ACC_ID;
}));
}
public IActionResult ReceivedMessages()
{
if (HttpContext.Session.GetInt32("User") != null)
{
AccountDetailVM account = new AccountDetailVM();
account = JsonConvert.DeserializeObject <AccountDetailVM>(HttpContext.Session.GetString("User"));
MessageViewModel vm = new MessageViewModel();
vm.Receiver = account;
List <Message> messages = new List <Message>();
messages = messageContainer.GetAllByReceiver(account.Id);
foreach (Message item in messages)
{
Account acc = accountContainer.GetById(item.SenderId);
item.SenderName = acc.Username;
}
vm.Messages = messageVMConverter.ModelsToViewModels(messages);
return(View(vm));
}
return(RedirectToAction("Index", "Login"));
}
internal BankAccountDetailVM SaveAccount(BankAccountDetailVM account)
{
// Is this a new account?
if (account.AccountId == 0)
{
// Create the base account to get an accountId
AccountDetailVM baseAccount = SaveAccount((AccountDetailVM)account);
account.AccountId = baseAccount.AccountId;
// Add an initial deposit transaction
//maybe this needs to go? merge conflict but seems liek should be here
if (account.InitialBalance.HasValue)
{
var initialD = Repo.SaveTransaction(new Transaction(new TransactionSaveInfo()
{
Amount = account.InitialBalance.Value,
IsConfirmed = true,
IsUserCreated = true,
Notes = $"Initial Deposit for {account.AccountName} {Constants.Accounts.GetDisplay(account.AccountType)}",
DateTime_Occurred = account.DateTime_Created,
Title = "Initial Deposit",
ToAccount = account.AccountId,
TransactionType = Constants.TransactionType.Deposit,
FromAccount = account.DepositAccountId
}));
account.InitialDepositId = initialD.LocalId;
}
//end merge conflict question code
}
var result = Repo.SaveAccount(new DepositAccount(account));
Transaction transaction = null;
if (result.InitialDepositId.HasValue)
{
transaction = Repo.GetTransactionById(result.InitialDepositId.Value);
}
return(new BankAccountDetailVM(account, result, transaction));
}
protected void Page_Load(object sender, EventArgs e)
{
base.AllowHttpMethod("GET", "POST");
base.DisableTop(false);
base.BodyClass = "class='bodybg'";
if (Request.HttpMethod.Equals("POST"))
{
int UserID = 0;
int.TryParse(Request.Form["i"], out UserID);
DataTable dt = new DataTable();
using (SqlConnection sc = new SqlConnection(WebConfigurationManager.ConnectionStrings["ConnUser"].ToString()))
{
using (SqlCommand cmd = new SqlCommand("dbo.usp_AccountM_xGetAccountDetailByID", sc))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@UserID", UserID);
using (SqlDataAdapter da = new SqlDataAdapter(cmd))
{
sc.Open();
da.Fill(dt);
}
}
}
VM = new AccountDetailVM();
EntityS.FillModel(VM, dt);
ApplyDate = VM.ApplyDate.ToShortTaiwanDate();
}
else
{
Response.Write("");
Response.End();
}
}
public NewAccountPage(bool isAccount, User _user)
{
InitializeComponent();
BindingContext = acVM = new AccountDetailVM(isAccount, _user);
}
public NewAccountPage(AccountDetailVM _acVM)
{
InitializeComponent();
BindingContext = acVM = _acVM;
}
