Example #1
0
        public ResponseModel PutContact([FromRoute] int id, [FromBody] Contact contact)
        {
            if (!ModelState.IsValid)
            {
                ResponseModel res = new ResponseModel("Update fail", null, "404");
                return(res);
            }

            if (id != contact.Id_Contact)
            {
                ResponseModel res = new ResponseModel("Update fail", null, "404");
                return(res);
            }
            try
            {
                _context.Entry(contact).State = EntityState.Modified;
                _context.SaveChangesAsync();
                ResponseModel res = new ResponseModel("Update success", null, "404");
                return(res);
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ContactExists(id))
                {
                    ResponseModel res = new ResponseModel("Not found", null, "404");
                    return(res);
                }
                else
                {
                    throw;
                }
            };
        }
Example #2
0
        public async Task <IActionResult> PutTypeWallet([FromRoute] int id, [FromBody] TypeWallet typeWallet)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != typeWallet.Id_Type_Wallet)
            {
                return(BadRequest());
            }

            _context.Entry(typeWallet).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!TypeWalletExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Example #3
0
        public ResponseModel PutUser([FromRoute] int id, [FromBody] User user)
        {
            if (!ModelState.IsValid)
            {
                ResponseModel res = new ResponseModel("Update fail", null, "404");
                return(res);
            }

            if (id != user.User_Id)
            {
                ResponseModel res = new ResponseModel("Update fail", null, "404");
                return(res);
            }
            try
            {
                _context.Entry(user).State = EntityState.Modified;
                _context.SaveChangesAsync();
                ResponseModel res = new ResponseModel("Update success", null, "404");
                return(res);
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!UserExists(id))
                {
                    ResponseModel res = new ResponseModel("NotFound", null, "404");
                    return(res);
                }
                else
                {
                    throw;
                }
            }
        }
Example #4
0
        public async Task <IActionResult> PutUserCategory([FromRoute] int id, [FromBody] UserCategory userCategory)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != userCategory.Id_UserCategory)
            {
                return(BadRequest());
            }

            _context.Entry(userCategory).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!UserCategoryExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public async Task <IActionResult> PutgetBill([FromRoute] int id, [FromBody] getBill getBill)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != getBill.id_getBill)
            {
                return(BadRequest());
            }

            _context.Entry(getBill).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!getBillExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public async Task <IActionResult> PutTime_Periodic([FromRoute] int id, [FromBody] Time_Periodic time_Periodic)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != time_Periodic.id_Time)
            {
                return(BadRequest());
            }

            _context.Entry(time_Periodic).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!Time_PeriodicExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Example #7
0
        public async Task <IActionResult> PutLogin([FromRoute] string id, [FromBody] Login login)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != login.User_Name)
            {
                return(BadRequest());
            }

            _context.Entry(login).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!LoginExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Example #8
0
        public ResponseModel PutPeriodic([FromRoute] int id, [FromBody] Periodic periodic)
        {
            if (!ModelState.IsValid)
            {
                ResponseModel res = new ResponseModel("Fail", null, "200");
                return(res);
            }

            float    amount     = periodic.Amount_Per;
            string   disciption = periodic.Desciption;
            DateTime date_e     = periodic.date_e;
            DateTime date_s     = periodic.date_s;
            string   id_time    = periodic.id_Time;

            periodic            = _context.Periodic.Where(m => m.Id_Per == id).FirstOrDefault();
            periodic.Amount_Per = amount;
            periodic.Desciption = disciption;
            periodic.date_e     = date_e;
            periodic.date_s     = date_s;
            periodic.id_Time    = id_time;
            periodic.isComeback = false;
            //if (periodic.Id_Wallet == 0)
            //{
            //    periodic.Id_Wallet = 1;
            //}
            //if (periodic.Id_Cate == 0)
            //{
            //    periodic.Id_Cate = 1;
            //}
            //if (periodic.Id_Type == 0)
            //{
            //    periodic.Id_Type = 1;
            //}
            //if (periodic.id_Time == 0)
            //{
            //    periodic.id_Time = 1;
            //}
            try
            {
                _context.Entry(periodic).State = EntityState.Modified;
                _context.SaveChanges();
                ResponseModel res = new ResponseModel("Update success", null, "200");
                return(res);
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!PeriodicExists(id))
                {
                    ResponseModel res = new ResponseModel("Not found", null, "200");
                    return(res);
                }
                else
                {
                    throw;
                }
            }
        }
Example #9
0
        public ResponseModel PutBudget([FromRoute] int id, [FromBody] Budget budget)
        {
            if (!ModelState.IsValid)
            {
                ResponseModel res = new ResponseModel("Fail", null, "200");
                return res;
            }

            float amount = budget.Amount_Budget;
            float remain = budget.Remain;
            DateTime date_e = budget.time_e;
            DateTime date_s = budget.time_s;
            bool isfinnish = budget.isFinnish;
            string idtime = budget.id_Time;
            budget = _context.Budget.Where(m => m.Id_Budget == id).FirstOrDefault();
            budget.Amount_Budget = amount;
            budget.time_e = date_e;
            budget.time_s = date_s;
            budget.isFinnish = isfinnish;
            budget.id_Time = idtime;
            //if (budget.Id_Wallet == 0)
            //{
            //    budget.Id_Wallet = 1;
            //}
            //if (budget.Id_Cate == 0)
            //{
            //    budget.Id_Cate = 1;
            //}
            //if (budget.Id_type == 0)
            //{
            //    budget.Id_type = 1;
            //}
            budget.Remain = budget.Amount_Budget;
            budget.isFinnish = false;
            try
            {
                _context.Entry(budget).State = EntityState.Modified;
                _context.SaveChanges();
                ResponseModel res = new ResponseModel("Update success", null, "200");
                return res;
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!BudgetExists(id))
                {
                    ResponseModel res = new ResponseModel("Not found", null, "200");
                    return res;
                }
                else
                {
                    throw;
                }
            }
        }
        public ResponseModel PutIncome_Outcome([FromRoute] int id, [FromBody] Income_Outcome income_Outcome)
        {
            if (!ModelState.IsValid)
            {
                ResponseModel res = new ResponseModel("Update fail", null, "404");
                return(res);
            }

            float  amount     = income_Outcome.Amount;
            string date       = income_Outcome.Date_come;
            string desciption = income_Outcome.Description_come;
            bool   is_come    = income_Outcome.Is_Come;
            string id_cate    = income_Outcome.CategoryId_Cate;
            string id_loan    = income_Outcome.LoanId_Loan;
            string id_trip    = income_Outcome.TripId_Trip;
            string id_wallet  = income_Outcome.WalletId_Wallet;
            string id_type    = income_Outcome.Id_type;
            string id_bill    = income_Outcome.Id_Bill;
            string id_budget  = income_Outcome.Id_Budget;
            string id_per     = income_Outcome.Id_Per;

            income_Outcome.Amount           = amount;
            income_Outcome.Date_come        = date;
            income_Outcome.Description_come = desciption;
            income_Outcome.Is_Come          = is_come;
            income_Outcome.CategoryId_Cate  = id_cate.ToString();
            income_Outcome.LoanId_Loan      = id_loan.ToString();
            income_Outcome.TripId_Trip      = id_trip.ToString();
            income_Outcome.Id_Bill          = id_bill.ToString();
            income_Outcome.Id_Budget        = id_budget.ToString();
            income_Outcome.Id_Per           = id_per.ToString();
            income_Outcome.Id_type          = id_type.ToString();
            try
            {
                _context.Income_Outcomes.Update(income_Outcome);
                _context.Entry(income_Outcome).State = EntityState.Modified;
                _context.SaveChanges();
                ResponseModel res = new ResponseModel("Update success", null, "404");
                return(res);
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!Income_OutcomeExists(id))
                {
                    ResponseModel res = new ResponseModel("Not found", null, "404");
                    return(res);
                }
                else
                {
                    throw;
                }
            }
        }
        public ResponseModel PutBill([FromRoute] int id, [FromBody] Bill bill)
        {
            if (!ModelState.IsValid)
            {
                ResponseModel res = new ResponseModel("Update fail", null, "404");
                return(res);
            }
            float    amount     = bill.Amount_Bill;
            string   disciption = bill.Desciption;
            DateTime date_e     = bill.date_e;
            DateTime date_s     = bill.date_s;
            bool     isEdit     = bill.isEdit;
            string   id_time    = bill.id_Time;

            bill             = _context.Bill.Where(m => m.Id_Bill == id).FirstOrDefault();
            bill.Amount_Bill = amount;
            bill.Desciption  = disciption;
            bill.date_e      = date_e;
            bill.date_s      = date_s;
            bill.isEdit      = isEdit;
            bill.id_Time     = id_time;
            try
            {
                if (bill.isEdit == false)
                {
                    bill.isPay = true;
                }
                _context.Bill.Update(bill);
                _context.Entry(bill).State = EntityState.Modified;
                _context.SaveChanges();
                ResponseModel res = new ResponseModel("Update success", null, "404");
                return(res);
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!BillExists(id))
                {
                    ResponseModel res = new ResponseModel("Not found", null, "404");
                    return(res);
                }
                else
                {
                    throw;
                }
            }
        }
        public ResponseModel PutLoan([FromRoute] int id, [FromBody] Loan loan)
        {
            if (!ModelState.IsValid)
            {
                ResponseModel res = new ResponseModel("Update fail", null, "404");
                return(res);
            }

            if (id != loan.Id_Loan)
            {
                ResponseModel res = new ResponseModel("Update fail", null, "404");
                return(res);
            }



            try
            {
                _context.Entry(loan).State = EntityState.Modified;
                _context.SaveChangesAsync();
                ResponseModel res = new ResponseModel("Update success", null, "404");
                return(res);
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!LoanExists(id))
                {
                    ResponseModel res = new ResponseModel("Update fail", null, "404");
                    return(res);
                }
                else
                {
                    throw;
                }
            }
        }