public IHttpActionResult Save([FromBody] CustomerSaveModel model)
{
var customers = _context.Select <Customer>().ToList();
foreach (var customer in customers)
{
if (customer.Name == model.Name)
{
customer.Address = model.Address;
_context.Update(customer);
return(Ok(customer));
}
}
var newCustomer = new Customer
{
Name = model.Name,
Address = model.Address,
CreatedAt = DateTime.Now,
CreatedById = model.CreatedBy
};
_context.Insert(newCustomer);
return(Ok(newCustomer));
}
private Customer CreateUpdateCustomer(CustomerSaveModel customerSaveModel)
{
Customer customer;
if (customerSaveModel.Id == 0)
{
customer = new Customer();
}
else
{
customer = _unitOfWork.CustomerRepository.Get(customerSaveModel.Id);
if (customer == null)
{
return(null);
}
}
customer.Name = customerSaveModel.Name;
customer.Phone = customerSaveModel.Phone;
customer.Address = customerSaveModel.Address;
customer.NumberOfSchools = customerSaveModel.NumberOfSchools;
customer.TypeId = customerSaveModel.Type;
customer.Comments = customerSaveModel.Comments;
customer.Email = customerSaveModel.Email;
_unitOfWork.CustomerRepository.Update(customer);
return(customer);
}
/// <inheritdoc />
public Task <Customer> Save(string name, string address)
{
var model = new CustomerSaveModel(name, address)
{
CreatedBy = Application.User.Id
};
return(_client.ExecuteAsync <Customer>(Controller, Method.POST, null, model));
}
public async Task <Customer> CreateAsync(CustomerSaveModel customerModel)
{
var customer = new Customer();
customerModel.ApplyToEntity(customer, dataStore, positionService);
await dataStore.SaveAsync(customer);
return(customer);
}
public Customer Create(CustomerSaveModel customerModel)
{
var customer = new Customer();
customerModel.ApplyToEntity(customer, dataStore, positionService);
dataStore.Save(customer);
return(customer);
}
public IActionResult SaveCustomer([FromBody] CustomerSaveModel customerSaveModel)
{
if (customerSaveModel != null)
{
var handler = new CreateUpdateCustomerHandler(_unitOfWork);
handler.Execute(customerSaveModel);
}
return(new OkResult());
}
public async Task <HttpResponseMessage> Put(long id, CustomerSaveModel model)
{
if (model != null)
{
await customerService.UpdateAsync(id, model);
return(Success());
}
return(Failure("Невозможно добавить пустой элемент"));
}
public async Task UpdateAsync(long id, CustomerSaveModel customerModel)
{
var customer = dataStore.Get <Customer>(id);
if (customer == null)
{
throw new EntityNotFoundException($"Запись типа {typeof(Customer).Name} c идентификатором {id} не существует");
}
customerModel.ApplyToEntity(customer, dataStore, positionService);
await dataStore.SaveChangesAsync();
}
/// <summary>
/// Creates or updates customer
/// </summary>
/// <param name="customerSaveModel">Customer data of CustomerSaveModel type</param>
/// <returns></returns>
public bool Execute(CustomerSaveModel customerSaveModel)
{
using (var transaction = _unitOfWork.BeginTransaction())
{
Customer customer = CreateUpdateCustomer(customerSaveModel);
if (customer == null)
{
transaction.Rollback();
return(false);
}
var existingDepartments = customerSaveModel.Departments.Where(d => d.Id != 0)
.Select(e => e.Id).ToList();
RemoveCustomerDepartments(existingDepartments, customer.Id);
List <Department> departments = new List <Department>();
foreach (var departmentSaveModel in customerSaveModel.Departments)
{
Department department = CreateUpdateDepartment(departmentSaveModel, customer);
if (department == null)
{
transaction.Rollback();
return(false);
}
departments.Add(department);
}
var existingUsers = customerSaveModel.Users.Where(d => !string.IsNullOrWhiteSpace(d.Id))
.Select(e => e.Id).ToList();
RemoveCustomerUsers(existingUsers, customer.Id);
List <User> users = new List <User>();
foreach (var userSaveModel in customerSaveModel.Users)
{
User user = CreateUpdateUser(userSaveModel, customer, departments);
if (user == null)
{
transaction.Rollback();
return(false);
}
users.Add(user);
}
foreach (var department in departments)
{
var departmentSM = customerSaveModel.Departments.FirstOrDefault(d => d.Name == department.Name);
var user = users.FirstOrDefault(u => u.UserName == departmentSM.ManagerLogin);
if (department.DepartmentManager == null)
{
department.DepartmentManager = new DepartmentManager {
Department = department, User = user
};
}
else
{
department.DepartmentManager.User = user;
_unitOfWork.DepartmentManagerRepository.Update(department.DepartmentManager);
}
}
var existingContacts = customerSaveModel.Contacts.Where(d => d.Id != 0)
.Select(e => e.Id).ToList();
RemoveCustomerContacts(existingContacts, customer.Id);
List <Contact> contacts = new List <Contact>();
foreach (var contactSaveModel in customerSaveModel.Contacts)
{
Contact contact = CreateUpdateContact(contactSaveModel, customer);
if (contact == null)
{
transaction.Rollback();
return(false);
}
contacts.Add(contact);
}
_unitOfWork.Save();
transaction.Commit();
}
return(true);
}
/// <summary>
/// Частичное представление - открытие окна создания
/// </summary>
public ActionResult Create()
{
var model = new CustomerSaveModel();
return(PartialView("Partial/Create", model));
}
public void ApplyToEntity(Request request, IDataStore dataStore, IPositionService positionService,
ICustomerService customerService)
{
if (request.Id == 0)
{
request.CreateDateTime = DateTime.Now;
}
request.PlannedDateTime = DateTime.Parse(this.PlannedDate);
if (!string.IsNullOrEmpty(ExecutionDate))
{
request.ExecutionDateTime = DateTime.Parse(this.ExecutionDate);
}
request.Container = dataStore.FindById <Container>(this.ContainerId);
request.Type = this.Type;
//"малые" контейнеры - забор через 3 дня, "большие" - через день
var daysCountForUninstall = request.Container?.ContainerType.Capacity <= 8 ? 3 : 1;
request.PlannedUninstallDateTime = string.IsNullOrEmpty(PlannedUninstallDate)
? (request.Type == RequestType.Install ? request.PlannedDateTime.AddDays(daysCountForUninstall) : (DateTime?)null)
: DateTime.Parse(this.PlannedUninstallDate);
request.Address = this.Address;
request.ContactPersonName = this.ContactPersonName;
request.ContactPersonPhone = this.ContactPersonPhone;
request.Comment = this.Comment;
request.Status = this.Status;
request.PaymentType = this.PaymentType;
request.IsPaid = this.IsPaid ? Enums.IsPaid.Yes : Enums.IsPaid.No;
request.Sum = this.Sum;
request.Polygon = dataStore.FindById <Polygon>(this.PolygonId);
request.Customer = dataStore.FindById <Customer>(this.CustomerId);
request.Car = dataStore.FindById <Car>(this.CarId);
request.Driver = dataStore.FindById <Driver>(this.DriverId);
if (request.PositionId.HasValue)
{
positionService.Update(request.PositionId.Value, PositionLatitude, PositionLongitude);
}
else
{
request.Position = positionService.Create(PositionLatitude, PositionLongitude);
}
//создаем нового
if (this.CustomerId == "0")
{
var customerDbEntity = customerService.GetAllCustomerModels(null)
.FirstOrDefault(x => x.Phone == CustomerPhone);
if (customerDbEntity == null)
{
var createModel = new CustomerSaveModel
{
Address = this.Address,
ContactPersonPhone = this.ContactPersonPhone,
ContactPersonName = this.ContactPersonName,
Name = this.CustomerName,
Phone = this.CustomerPhone,
PositionLatitude = request.Position?.Latitude,
PositionLongitude = request.Position?.Longitude
};
var customer = customerService.Create(createModel);
request.CustomerId = customer.Id;
}
else
{
request.CustomerId = customerDbEntity.Id;
}
}
request.Address = Address;
request.ContactPersonName = ContactPersonName;
request.ContactPersonPhone = ContactPersonPhone;
}
