public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var client = await _clientService.GetClientByIdAsync(id);
var viewModel = new ClientCreateViewModel
{
ClientId = client.ClientId,
Name = client.Name,
Address = client.Address,
SelectedCompanyId = client.CompanyFK,
Companies = await GetCompanySelections()
};
if (client == null)
{
return(NotFound());
}
return(View(viewModel));
}
public async Task <IActionResult> Create(ClientCreateViewModel clientCreateViewModel)
{
try
{
if (ModelState.IsValid)
{
var client = new Client
{
Name = clientCreateViewModel.Name,
CompanyFK = clientCreateViewModel.SelectedCompanyId,
Address = clientCreateViewModel.Address
};
var result = await _clientService.CreateClientAsync(client);
if (result)
{
return(RedirectToAction(nameof(Index)));
}
}
}
catch (DbUpdateException ex)
{
ModelState.AddModelError("", "Unable to save changes." + ex.Message);
}
clientCreateViewModel.Companies = await GetCompanySelections();
return(View(clientCreateViewModel));
}
public IActionResult Create(ClientCreateViewModel model)
{
if (context.Clients.FirstOrDefault(u => u.PhoneNumber == model.PhoneNumber) != null)
{
ModelState.AddModelError("PhoneNumber", "There is an user with this phone number.");
//return Page();
}
if (context.Clients.FirstOrDefault(u => u.Email == model.Email) != null)
{
ModelState.AddModelError("Email", "There is an user with this email.");
//return Page();
}
if (ModelState.IsValid)
{
Client client = new Client()
{
Id = Guid.NewGuid().ToString(),
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = model.PhoneNumber,
Email = model.Email,
IsAdult = !model.IsAdult
};
context.Clients.AddAsync(client);
context.SaveChanges();
return(Redirect("~/Client/Details/" + client.Id));
}
return(View(model));
}
public IActionResult Create(ClientCreateViewModel model)
{
if (ModelState.IsValid)
{
string uniqueFileName = null;
if (model.Photo != null)
{
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "images");
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.Photo.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
model.Photo.CopyTo(new FileStream(filePath, FileMode.Create));
}
Client newClient = new Client
{
Name = model.Name,
Email = model.Email,
PhoneNumber = model.PhoneNumber,
Address = model.Address,
DogName = model.DogName,
DogBreed = model.DogBreed,
DogDescription = model.DogDescription,
PhotoPath = uniqueFileName
};
model.Persist(context);
return(RedirectToAction(actionName: nameof(Index)));
}
return(View());
}
public async Task <IActionResult> Create(ClientCreateViewModel viewModel)
{
var user = await GetCurrentUserAsync();
ModelState.Remove("Client.User");
ModelState.Remove("Client.UserId");
viewModel.Client.User = user;
viewModel.Client.UserId = user.Id;
if (ModelState.IsValid)
{
//viewModel.Client.UserId = user.Id;
_context.Add(viewModel.Client);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["StatusTypeId"] = new SelectList(_context.StatusTypes, "StatusTypeId", "Name", viewModel.Client.StatusTypeId);
//ViewData["UserId"] = new SelectList(_context.ApplicationUsers, "Id", "Id", client.UserId);
viewModel.Facilities = await _context.Facilities.Where(c => c.UserId == user.Id).ToListAsync();
ViewData["FacilityId"] = new SelectList(viewModel.Facilities, "FacilityId", "Name");
return(View(viewModel));
}
public IActionResult CreateLegalPerson(ClientCreateViewModel clientCreateViewModel)
{
var client = HttpContext.Session.Get <Client>("NewClientData");
var legalPersonCreateViewModel = new LegalPersonViewModel()
{
Client = client
};
return(View(legalPersonCreateViewModel));
}
public async Task <Client> UpdateClientAsync(ClientCreateViewModel clientViewModel)
{
var client = await _repo.GetClientByIdAsync(clientViewModel.ClientId);
if (client != null)
{
client.Name = clientViewModel.Name;
client.Address = clientViewModel.Address;
client.CompanyFK = clientViewModel.SelectedCompanyId;
}
return(await _repo.UpdateClientAsync(client));
}
public IActionResult Create(ClientCreateViewModel model)
{
string[] validImageTypes = new string[]
{
"image/gif",
"image/jpeg",
"image/pjpeg",
"image/png"
};
// Check on null or zero length file
if (model.ImageUpload == null || model.ImageUpload.Length == 0)
{
ModelState.AddModelError("ImageUpload", "Изображение не может быть пустым");
}
// Check on image file
else if (!validImageTypes.Contains(model.ImageUpload.ContentType))
{
ModelState.AddModelError("ImageUpload", "Изображение должно быть в формате JPG, GIF или PNG");
}
// Create new Client
if (ModelState.IsValid)
{
// Add new Client
Client client = new Client
{
Name = model.Name,
ShortDescription = model.ShortDescription,
Description = model.Description,
HttpUrl = model.HttpUrl
};
// Add Client's Image
// Copy File To Server
string pathDir = _optionsAccessor.Value.ClientImages;
string pathFileName = Guid.NewGuid().ToString();
string pathFileExt = Path.GetExtension(model.ImageUpload.FileName);
_filesHelper.Copy(pathDir, pathFileName + pathFileExt, model.ImageUpload);
// Add related record - reference on file, in Database
ClientImage clientImage = new ClientImage {
IsPoster = true, Path = @"\" + pathDir + pathFileName + pathFileExt
};
client.ClientImages.Add(clientImage);
_context.Set <Client>().Add(client);
return(RedirectToAction("Index"));
}
// If Model is not valid
return(View(model));
}
// GET: Clients/Create
public async Task <IActionResult> Create()
{
var user = await _userManager.GetUserAsync(HttpContext.User);
ViewData["StatusTypeId"] = new SelectList(_context.StatusTypes, "StatusTypeId", "Name");
//ViewData["UserId"] = new SelectList(_context.ApplicationUsers, "Id", "Id");
var viewModel = new ClientCreateViewModel()
{
Facilities = await _context.Facilities.Where(c => c.UserId == user.Id).ToListAsync()
};
ViewData["FacilityId"] = new SelectList(viewModel.Facilities, "FacilityId", "Name");
return(View(viewModel));
}
public IActionResult SignUp(ClientCreateViewModel clientCreateViewModel)
{
var account = new AccountResource()
{
Login = clientCreateViewModel.Login,
Phone = clientCreateViewModel.Phone,
Email = clientCreateViewModel.Email,
Password = clientCreateViewModel.Password
};
var jsonResponse = _client.GetStringAsync("api/accounts").Result;
var oldAccounts = JsonConvert.DeserializeObject <List <AccountResource> >(jsonResponse);
if (oldAccounts.Any(account => account.Login == clientCreateViewModel.Login))
{
return(Redirect("/site/vertical/pages-register.html"));
}
var json = JsonConvert.SerializeObject(account);
var data = new StringContent(json, Encoding.UTF8, "application/json");
var result = _client.PostAsync("api/accounts", data).Result;
if (result.StatusCode == System.Net.HttpStatusCode.OK)
{
var accountsJson = _client.GetStringAsync("api/accounts").Result;
var accounts = JsonConvert.DeserializeObject <List <AccountResource> >(accountsJson);
var accountGet = accounts.Where(a => a.Login == clientCreateViewModel.Login && a.Phone == clientCreateViewModel.Phone && a.Email == clientCreateViewModel.Email).FirstOrDefault();
var client = new ClientResource()
{
AccountId = accountGet.Id,
Name = clientCreateViewModel.Name
};
var clientJson = JsonConvert.SerializeObject(client);
var clientData = new StringContent(clientJson, Encoding.UTF8, "application/json");
var clientResult = _client.PostAsync("api/clients", clientData).Result;
if (clientResult.StatusCode == System.Net.HttpStatusCode.OK)
{
return(Redirect("/site/vertical/pages-login.html"));
}
}
return(Redirect("/site/vertical/pages-register.html"));
}
public async Task <ActionResult> Edit(ClientCreateViewModel clientViewModel)
{
if (ModelState.IsValid)
{
try
{
await _clientService.UpdateClientAsync(clientViewModel);
return(RedirectToAction("Index"));
}
catch (DbUpdateException ex)
{
ModelState.AddModelError("", "Unable to save changes." + ex.Message);
}
}
return(View(clientViewModel));
}
public async Task <IActionResult> Create(ClientCreateViewModel createModel)
{
if (ModelState.IsValid)
{
Client client = new Client
{
Name = createModel.Name,
Surname = createModel.Surname,
Email = createModel.Email,
PhoneNumber = createModel.PhoneNumber,
IsAdult = createModel.IsAdult
};
_context.Add(client);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(createModel));
}
public IActionResult Create(ClientCreateViewModel model)
{
if (ModelState.IsValid)
{
Client client = new Client
{
Name = model.Name,
Street = model.Street,
City = model.City,
Zip = model.Zip,
ClientType = model.ClientType,
IdNumber1 = model.IdNumber1,
IdNumber2 = model.IdNumber2,
IdNumber3 = model.IdNumber3,
RepName = model.RepName,
RepPhone = model.RepPhone,
RepMail = model.RepMail,
Id = new Guid()
};
_clientsRepository.Add(client);
return(RedirectToAction("details", new { id = client.Id }));
}
return(RedirectToAction("create"));
}
public async Task <IActionResult> CreateClient(ClientCreateViewModel clientCreateViewModel)
{
if (!ModelState.IsValid)
{
return(View(clientCreateViewModel));
}
var result = await Mediator.Send(new GetPasswordValidationQuery(null, clientCreateViewModel.Password));
if (result.Succeeded)
{
HttpContext.Session.Set <Client>("NewClientData", clientCreateViewModel.Client);
HttpContext.Session.Set <string>("PassClient", clientCreateViewModel.Password);
//if pass is valid
if (clientCreateViewModel.IsPhysicalPerson)
{
//PhysicalPerson
return(RedirectToAction(nameof(CreatePhysicalPerson), clientCreateViewModel));
}
else
{
//LegalPerson
return(RedirectToAction(nameof(CreateLegalPerson), clientCreateViewModel));
}
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View(clientCreateViewModel));
}
public async Task <IActionResult> CreateClient(ClientCreateViewModel clientCreateViewModel)
{
if (!ModelState.IsValid)
{
return(View(model: clientCreateViewModel));
}
var result =
await _mediator.Send(
request : new GetPasswordValidationQuery(user: null, password: clientCreateViewModel.Password));
if (result.Succeeded)
{
HttpContext.Session.Set("NewClientData", clientCreateViewModel.Client);
HttpContext.Session.Set(key: "PassClient", value: clientCreateViewModel.Password);
//if pass is valid
if (clientCreateViewModel.IsPhysicalPerson)
{
//PhysicalPerson
return(RedirectToAction(actionName: nameof(CreatePhysicalPerson),
routeValues: clientCreateViewModel));
}
//LegalPerson
return(RedirectToAction(actionName: nameof(CreateLegalPerson), routeValues: clientCreateViewModel));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(key: string.Empty, errorMessage: error.Description);
}
return(View(model: clientCreateViewModel));
}
public ViewResult Create()
{
ClientCreateViewModel model = new ClientCreateViewModel();
return(View(model));
}
public async Task <IActionResult> Add([FromBody] ClientCreateViewModel item)
{
var clientId = await _commandFunctionality.AddAsync(Mapper.Map <ClientCreateCommand>(item));
return(ResponseWithData(StatusCodes.Status201Created, clientId));
}
