/// <summary>
/// Actualiza un store consumiendo un webapi rest
/// </summary>
private void UpdateStore()
{
try
{
Models.Store store = (Models.Store) this.Tag;
string urlApi = apiStores + "/" + store.Id; //"https://localhost:44380/api/Stores/" + store.Id;
store.Name = txtName.Text;
store.Address = txtAddress.Text;
JsonSerializerSettings settings = new JsonSerializerSettings();
settings.MaxDepth = int.MaxValue;
var inputJson = JsonConvert.SerializeObject(store, settings);
var content = new StringContent(inputJson, System.Text.Encoding.UTF8, "application/json");
using (HttpClient cliente = new HttpClient())
{
using (var response = cliente.PutAsync(urlApi, content).Result)
{
if (response.StatusCode == HttpStatusCode.OK)
{
this.DialogResult = DialogResult.OK;
this.Close();
return;
}
logger.LogInformation("La petición Put " + urlApi + " devolvió código " + response.StatusCode.ToString());
MessageBox.Show("No se han registrado los datos", "", MessageBoxButtons.OK);
}
}
}
catch (Exception ex)
{
logger.LogError("Ocurrió un error al actualizar el registro", ex);
MessageBox.Show("Ocurrió un error al actualizar el registro", "", MessageBoxButtons.OK);
}
}
public static DataAccess.Store Map(Models.Store store) => new DataAccess.Store
{
Id = store.Id,
Address = store.Address,
State = store.State,
// Orders = Map(store.Orders).ToList(),
Ingredients = Map(store.Ingredients).ToList()
};
public IActionResult StoreManagerSelected(Models.Store store)
{
var dbStore = client.GetAllStores().FirstOrDefault(s => s.ID == store.ID);
if (dbStore is null)
{
return(BadRequest("How did you even manage to do this, man?"));
}
return(RedirectToAction("ManagerMenu", new { StoreId = dbStore.ID }));
}
public async Task<IActionResult> OnGetAsync(int? id)
{
if (id == null) return NotFound();
Store = await _storeService.GetByIdAsync(id.Value);
if (Store == null) return NotFound();
ViewData["Addresses"] = new SelectList(await _addressService.ListAsync(), "Id", "Building");
ViewData["Companies"] = new SelectList(await _companyService.ListAsync(), "Id", "Name");
return Page();
}
public List <Store> PostScore(Store data)
{
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
var paramater = new Models.Store {
Email = data.Email, win = data.win, pic = data.pic
};
var sql = @"update AspNetUsers set win = @win, pic = @pic where Email = @Email";
var r = conn.Query <Store>(sql, paramater).ToList();
conn.Close();
return(r);
}
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
Store = await _storeService.GetByIdAsync(id.Value);
if (Store == null)
{
return(NotFound());
}
return(Page());
}
public void AddIngredients(Models.Ingredients ingredients, Models.Store store)
{
if (store != null)
{
// get the db's version of that restaurant
// (can't use Find with Include)
DataAccess.Store contextStore = _db.Store.Include(r => r.Ingredients)
.First(r => r.Id == store.Id);
store.Ingredients.Add(ingredients);
contextStore.Ingredients.Add(Map(ingredients));
}
else
{
_db.Add(Map(ingredients));
}
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
Store = await _storeService.GetByIdAsync(id.Value);
if (Store != null)
{
await _storeService.RemoveAsync(Store);
}
return(RedirectToPage("./Index"));
}
public IActionResult StoreSelected(Models.Store store)
{
var dbStore = client.GetAllStores().FirstOrDefault(s => s.ID == store.ID);
if (dbStore is null)
{
return(BadRequest("Store you selected was somehow null"));
}
var sessionOrder = Utils.GetCurrentOrder(HttpContext.Session);
sessionOrder.Store.Name = dbStore.Name;
sessionOrder.Store.StoreType = dbStore.StoreType;
sessionOrder.Store.ID = dbStore.ID;
Utils.SaveOrder(HttpContext.Session, sessionOrder);
return(RedirectToAction("Menu", "Order"));
}
public IActionResult Post([FromBody] Models.Store store)
{
if (store == null)
{
return(BadRequest());
}
var s = this._mapper.Map <Entities.Store>(store);
s.CreatedIP = "1.1.1.1";
var result = this._storesRepository.Insert(s);
if (result != null)
{
return(Created("api/stores", result.Id));
}
else
{
return(BadRequest("Failed to create store."));
}
}
public IActionResult Put(string id, [FromBody] Models.Store store)
{
if (store == null)
{
return(BadRequest());
}
var s = this._mapper.Map <Entities.Store>(store);
s.ModifiedIP = "2.2.2.2";
var result = this._storesRepository.Update(id, s);
if (result)
{
var item = this._storesRepository.Find(id);
return(Ok(item));
}
else
{
return(BadRequest("Failed to Update store."));
}
}
/// <summary>
/// Carga el formulario de edición
/// </summary>
/// <param name="title">Titulo del formulario</param>
/// <param name="record">Registro para editar</param>
/// <param name="store">Store seleccionado</param>
private void LoadEditForm(string title, object record, Models.Store store)
{
try
{
frmNewEditArticle formulario = new frmNewEditArticle(logger);
formulario.Text = title;
formulario.Tag = record;
formulario.Store = store;
var result = formulario.ShowDialog(this);
if (result == DialogResult.OK)
{
if (cmbStores.SelectedItem != null)
{
LoadArticles(((Models.Store)cmbStores.SelectedItem).Id);
}
}
}
catch (Exception ex)
{
logger.LogError("Ocurrió un error al cargar el formulario para edición.", ex);
}
}
public void AddStores(Models.Store store)
{
_db.Add(Map(store));
}
public void UpdateStore(Models.Store store)
{
_db.Entry(_db.Store.Find(store.Id)).CurrentValues.SetValues(Map(store));
}
public Models.Store NewStore(Models.Store newStore)
{
try
{
if (newStore == null)
{
throw new ArgumentNullException("newStore");
}
using (var db = new HKSupplyContext())
{
var store = db.Stores.FirstOrDefault(s => s.IdStore.Equals(newStore.IdStore));
if (store != null)
{
throw new NewExistingStoreException(GlobalSetting.ResManager.GetString("StoreAlreadyExist"));
}
db.Stores.Add(newStore);
db.SaveChanges();
return(GetStoreById(newStore.IdStore));
}
}
catch (ArgumentNullException nrex)
{
_log.Error(nrex.Message, nrex);
throw nrex;
}
catch (NewExistingRoleException areex)
{
_log.Info(areex.Message, areex);
throw areex;
}
catch (NonexistentRoleException nerex)
{
_log.Error(nerex.Message, nerex);
throw nerex;
}
catch (DbEntityValidationException e)
{
_log.Error(e.Message, e);
throw e;
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
/// <summary>
/// Carga los datos para edición en el formulario
/// </summary>
/// <param name="store">Store para edición</param>
private void LoadDataForm(Models.Store store)
{
txtName.Text = store.Name;
txtAddress.Text = store.Address;
}
