public async Task UpdateCustomer(CustomersModel customersModel)
{
Customers customers = this.mapper.Map <Customers>(customersModel);
_CustomerRepository.Update(customers);
await _CustomerRepository.SaveChangesAsync();
}
[HttpGet]//刪除頁面
public ActionResult Delete(string id)
{
CustomersModel model = new CustomersModel();
model.Form = model.GetCustomer(id);
return(View(model));
}
public async Task <CustomerCreationResponse> CreateCustomer(CustomersModel customer)
{
string url = GetUrl();
var content = await BaseClient.PostEntities(url, JsonConvert.SerializeObject(customer), this._secretKey);
return(JsonConvert.DeserializeObject <CustomerCreationResponse>(content));
}
private Mock <ICustomerRepository> _getMockCustomers()
{
List <Customer> customers = new List <Customer>();
customers.Add(new Customer {
Id = 1, Name = "Bob"
});
customers.Add(new Customer {
Id = 2, Name = "Mary"
});
customers.Add(new Customer {
Id = 3, Name = "Joe"
});
CustomersModel model = new CustomersModel();
model.Customers = customers as ICollection <Customer>;
Mock <ICustomerRepository> mock = new Mock <ICustomerRepository>();
mock.Setup(m => m.GetCustomers()).Returns(model.Customers);
mock.Setup(m => m.GetCustomer(1)).Returns(customers[1]);
mock.Setup(m => m.AddCustomer(It.IsAny <Customer>())).Returns(new KeyValuePair <string, Customer>(string.Empty, _customerToAdd));
mock.Setup(m => m.UpdateCustomer(It.IsAny <Customer>())).Returns(_customerToUpdate);
return(mock);
}
public ActionResult AllCustomer(int?pageIndex)
{
CustomerRepositery costRep = new CustomerRepositery();
var countElementPage = 10;
var costumers = costRep.allCustomers();
if (costumers.Count() == 0)
{
ViewData["erreurMessage"] = "aucun customer !";
ViewData["element"] = "Customer";
ViewData["create"] = "true";
return(View("ErrorEmptyList"));
}
List <CustomersModel> customersModel = new List <CustomersModel>();
foreach (var cust in costumers)
{
CustomersModel custModel = new CustomersModel();
custModel.Customer_ID = cust.Customer_ID;
custModel.Code = cust.Code;
custModel.Name = cust.Name;
customersModel.Add(custModel);
}
IQueryable <CustomersModel> listCust = customersModel.AsQueryable();
PaginatedList <CustomersModel> lst = new PaginatedList <CustomersModel>(listCust, pageIndex, countElementPage);
return(View("AllCustomers", lst));
}
public ActionResult Searche(String query, int?pageIndex, Guid id)
{
var countElementPage = 10;
ExpanseRepositery expRepo = new ExpanseRepositery();
var expanses = expRepo.getSerachingExpanses(query, id);
List <ExpansesModel> expanseModel = new List <ExpansesModel>();
ViewData["idExpanseReport"] = id;
foreach (var exp in expanses)
{
ExpansesModel expanse = new ExpansesModel();
CustomersModel customer = new CustomersModel();
ExpanseTypesModel expType = new ExpanseTypesModel();
ExpanseReportsModel expanseRapport = new ExpanseReportsModel();
ProjectsModel projet = new ProjectsModel();
expanse.Expanse_ID = exp.Expanse_ID;
expanse.Amount_HT = exp.Amount_HT;
expanse.Amount_TTC = exp.Amount_TTC;
expanse.Amount_TVA = exp.Amount_TVA;
customer.Name = expRepo.GetByIdCutomer(exp.Customer_ID).Name;
projet.Name = expRepo.GetByIdProjects(exp.Project_ID).Name;
expType.Name = expRepo.GetByIdExpanseTypes(exp.ExpanseType_ID).Name;
expanseRapport.Year = expRepo.GetByIdExpansesRepport(exp.ExpanseReport_ID).Year;
expanse.Customers = customer;
expanse.Projects = projet;
expanse.ExpanseReports = expanseRapport;
expanse.ExpanseTypes = expType;
expanseModel.Add(expanse);
}
IQueryable <ExpansesModel> listCust = expanseModel.AsQueryable();
PaginatedList <ExpansesModel> lst = new PaginatedList <ExpansesModel>(listCust, pageIndex, countElementPage);
return(View("AllExpanses", lst));
}
public void AddOrUpdateCustomer(string address, string authority, DateTime?dateOfBirth,
DateTime?dateOfIssue, string fio, //int idCus,
string passportNo, int?phoneNumber)
{
var customer = new CustomersModel();
customer.Address = address;
customer.Authority = authority;
customer.DateOfBirth = dateOfBirth;
customer.DateOfIssue = dateOfIssue;
customer.FIO = fio;
//customer.IDCUS = idCus;
customer.PassportNo = passportNo;
customer.PhoneNumber = phoneNumber;
var flag = customersRepository.Items.Contains(customer);
if (flag)
{
customersRepository.Update(customer);
}
else
{
customersRepository.Add(customer);
}
}
public ActionResult CustomerEdit(CustomersModel customersModel)
{
Customers customers = customersModel.ModelToEnity();
_serviceCustomers.Update(customers);
return(RedirectToAction("CustomerEdit"));
}
public ActionResult Searche(String query, int?pageIndex)
{
var countElementPage = 10;
ProjetRepositery projetRep = new ProjetRepositery();
var projets = projetRep.getSerachingProjects(query);
List <ProjectsModel> projetsModel = new List <ProjectsModel>();
CustomersModel customer = new CustomersModel();
foreach (var prjt in projets)
{
ProjectsModel prjtModel = new ProjectsModel();
prjtModel.Project_ID = prjt.Project_ID;
prjtModel.Pole_ID = prjt.Pole_ID;
prjtModel.Description = prjt.Description;
prjtModel.Budget = prjt.Budget;
prjtModel.Name = prjt.Name;
customer.Name = projetRep.GetByIdCutomer(prjt.Customer_ID).Name;
prjtModel.Customers = customer;
projetsModel.Add(prjtModel);
}
IQueryable <ProjectsModel> listProjets = projetsModel.AsQueryable();
PaginatedList <ProjectsModel> lst = new PaginatedList <ProjectsModel>(listProjets, pageIndex, countElementPage);
return(View("AllProjects", lst));
}
public ActionResult AllProjets(int?pageIndex)
{
ProjetRepositery prtRep = new ProjetRepositery();
int countElementPage = 10;
var projets = prtRep.allProjects();
if (projets.Count() == 0)
{
ViewData["erreurMessage"] = "Aucun Projet!";
ViewData["element"] = "Projet";
ViewData["create"] = "true";
return(View("ErrorEmptyList"));
}
List <ProjectsModel> projetsModel = new List <ProjectsModel>();
foreach (var prjt in projets)
{
ProjectsModel prjtModel = new ProjectsModel();
CustomersModel Customer = new CustomersModel();
prjtModel.Project_ID = prjt.Project_ID;
prjtModel.Pole_ID = prjt.Pole_ID;
prjtModel.Description = prjt.Description;
prjtModel.Budget = prjt.Budget;
prjtModel.Name = prjt.Name;
Customer.Name = prtRep.GetByIdCutomer(prjt.Customer_ID).Name;
prjtModel.Customers = Customer;
projetsModel.Add(prjtModel);
}
IQueryable <ProjectsModel> listProjets = projetsModel.AsQueryable();
PaginatedList <ProjectsModel> lst = new PaginatedList <ProjectsModel>(listProjets, pageIndex, countElementPage);
return(View("AllProjects", lst));
}
public IActionResult Index()
{
CustomersModel sm = new CustomersModel();
ViewBag.CustomerTable = sm.GetAllCustomers();
return(View());
}
public PartialViewResult ListProject(Guid customerId)
{
ProjetRepositery prjtRepo = new ProjetRepositery();
IQueryable <Projects> projectsList = prjtRepo.GetProjectsByIdCutomer(customerId);
List <ProjectsModel> projectsListModel = new List <ProjectsModel>();
foreach (var prjt in projectsList)
{
ProjectsModel prjtModel = new ProjectsModel();
CustomersModel Customer = new CustomersModel();
prjtModel.Project_ID = prjt.Project_ID;
prjtModel.Pole_ID = prjt.Pole_ID;
prjtModel.Description = prjt.Description;
prjtModel.Budget = prjt.Budget;
prjtModel.Name = prjt.Name;
Customer.Name = prjtRepo.GetByIdCutomer(prjt.Customer_ID).Name;
prjtModel.Customers = Customer;
projectsListModel.Add(prjtModel);
}
var expanseViewModel = new ExpansesModel
{
ProjectsList = projectsListModel
};
return(PartialView("_ProjectItem", expanseViewModel));
}
public ActionResult Edit(WorkModel workModel, int[] service, int customer, int item)
{
if (service != null)
{
foreach (var id in service)
{
ServicesModel ser = wl.db.Services.Find(id);
workModel.service.Add(ser);
}
}
if (customer != 0)
{
CustomersModel cm = wl.db.Customers.Find(customer);
workModel.customer = cm;
}
if (item != 0)
{
ServiceItemsModel sim = wl.db.ServiceItems.Find(item);
workModel.item = sim;
}
wl.edit(workModel);
return(RedirectToAction("Index"));
}
private void CustomerListView_ItemTapped(object sender, ItemTappedEventArgs e)
{
CustomersModel modelObj = e.Item as CustomersModel;
// Navigation.PushAsync(new CalendarDetailPage(modelObj));
Navigation.PushAsync(new CustomerListviewDetailPage(modelObj));
}
// GET: Customers
public ActionResult Index()
{
CustomersModel model = new CustomersModel();
model.CustomerList = model.GetCustomerList();
return(View(model));
}
public async Task <IActionResult> Edit(int id, [Bind("Cid,Name,Telephone")] CustomersModel customers)
{
if (id != customers.Cid)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await _CustomerService.UpdateCustomer(customers);
}
catch (DbUpdateConcurrencyException)
{
if (!_CustomerService.CustomersExists(customers.Cid))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(customers));
}
public ActionResult DeleteConfirmed(int id)
{
CustomersModel customersModel = cl.find(id);
cl.remove(customersModel);
return(RedirectToAction("Index"));
}
public static CustomersModel EntityToModel(this Customers entity, bool virtualActive = false)
{
try
{
CustomersModel model = new CustomersModel()
{
Description = entity.Description,
Name = entity.Name,
BloodGroup = entity.BloodGroup,
DateOfBirth = entity.DateOfBirth,
EmailAddress = entity.EmailAddress,
IdentificationNumber = entity.IdentificationNumber,
Address = entity.Address,
IsMale = entity.IsMale,
IsMarried = entity.IsMale,
NationalityId = entity.NationalityId,
PhoneNumber = entity.PhoneNumber,
Surname = entity.Surname,
Id = entity.Id
};
if (virtualActive)
{
model.Nationality = entity.Nationality;
model.Sales = entity.Sales;
model.StayingInRoom = entity.StayingInRoom;
}
return(model);
}
catch (Exception)
{
return(new CustomersModel());
}
}
public static Customers ModelToEnity(this CustomersModel model, bool virtualActive = false)
{
Customers entity = new Customers()
{
Address = model.Address,
Name = model.Name,
BloodGroup = model.BloodGroup,
DateOfBirth = model.DateOfBirth,
Description = model.Description,
EmailAddress = model.EmailAddress,
IdentificationNumber = model.IdentificationNumber,
IsMale = model.IsMale,
IsMarried = model.IsMarried,
PhoneNumber = model.PhoneNumber,
Surname = model.Surname,
NationalityId = model.NationalityId,
Id = model.Id,
IsActive = model.IsActive
};
if (virtualActive)
{
entity.Nationality = model.Nationality;
entity.Sales = model.Sales;
entity.StayingInRoom = model.StayingInRoom;
}
return(entity);
}
public async Task <IActionResult> Edit(int id, [Bind("CustomerID,CustomerName,CustomerPhone")] CustomersModel customersModel)
{
if (id != customersModel.CustomerID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(customersModel);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CustomersModelExists(customersModel.CustomerID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(customersModel));
}
public ActionResult CustomerInsert(CustomersModel customersModel)
{
if (ModelState.IsValid)
{
_serviceCustomers.Insert(customersModel.ModelToEnity());
}
return(RedirectToAction("CustomerList"));
}
public async Task <IActionResult> UpdateCustomerAsync([FromBody][Bind("Name,Telephone,Email")] CustomersModel customer)
{
if (ModelState.IsValid)
{
await this.customerService.UpdateCustomer(customer);
}
return(StatusCode((int)HttpStatusCode.OK, customer));
}
public async Task <CustomersModel> FindCustomer(int?Cid)
{
var customerdb = await _CustomerRepository.FindAsync(Cid);
CustomersModel customersModel = this.mapper.Map <CustomersModel>(customerdb);
return(customersModel);
}
/// <summary>
/// Serves the HTML template for the list page.
/// </summary>
/// <returns>The HTML template for the list page.</returns>
public async Task <ActionResult> List()
{
CustomersModel customersModel = new CustomersModel();
customersModel.Customers.AddRange(await GetCustomerModelsAsync().ConfigureAwait(false));
return(PartialView(customersModel));
}
public CustomersController()
{
Model = new CustomersModel();
AddCustomerCommand = new DelegateCommand(Model.CustomerToAdd, (_) => Model.AddCustomer(), e => 0 == 0);
EditCustomerCommand = new DelegateCommand(Model.SelectedCustomer, (_) => Model.EditCustomer(), e => 0 == 0);
DeleteCustomerCommand = new DelegateCommand(Model.SelectedCustomer, (_) => Model.DeleteCustomer(), e => 0 == 0);
}
public async Task <IActionResult> GetCustomerbyIDAsync(int Cid)
{
// int Cid = ((JObject)jObject).GetValue("Cid", StringComparison.OrdinalIgnoreCase).Value<int>();
CustomersModel customers = await this.customerService.FindCustomer(Cid);
// APIMessage aPIMessage = new APIMessage { StatusCode = (int)HttpStatusCode.OK, StatusMessage = "Sucess great !!", Data = customers };
return(StatusCode((int)HttpStatusCode.OK, customers));
}
//public EventsController()
//{
// var m_addressesDataSource = new EventsDataSource();
//}
public ActionResult Index()
{
var customers = m_customersDataSource.GetAllCustomers();
var companiesModel = new CustomersModel();
companiesModel.Customers = customers.ToArray();
return(View(companiesModel));
}
public ActionResult Index()
{
var model = new CustomersModel
{
Customers = _customerService.GetByAny(new TagType[0], Enumerable.Empty <string>().ToArray())
};
return(View(model));
}
// GET: Customer
public ActionResult Customers()
{
CustomersModel customersModel = new CustomersModel
{
Customers = _context.Customers.Include(c => c.MembershipType).ToList().OrderBy(x => x.Name)
};
return(View(customersModel));
}
// GET: Customer/Create
public ActionResult Create()
{
CustomersModel customersModel = new CustomersModel();
customersModel.Days = new SelectList(Enum.GetValues(typeof(DayOfWeek)));
return(View(customersModel));
}
