public async Task <IActionResult> Edit(int id, [Bind("Id,Emertimi")] Kategoria kategoria)
{
if (id != kategoria.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(kategoria);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!KategoriaExists(kategoria.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(kategoria));
}
public ActionResult Categories(string id, int page = 1)
{
using (var db = new DatabaseContext())
{
ViewModels viewModel = new ViewModels();
GroupListViewModel groupList = new GroupListViewModel();
Kategoria category = db.Kategoria.FirstOrDefault(p => p.Skrot == id);
if (category == null)
{
return(View("Error", new string[] { "Nie ma kategorii o podanej nazwie" }));
}
groupList.Groups = (db.KoloNaukowe.Where(p => p.KategoriaId == category.Id).
OrderBy(p => p.Id).Skip((page - 1) * PageSize).Take(PageSize)).ToList();
if (groupList.Groups == null)
{
return(View("Error", new string[] { "Brak kół w kategorii" }));
}
int totalItems = db.KoloNaukowe.Where(p => p.KategoriaId == category.Id).Count();
groupList.Pages = (int)Math.Ceiling((decimal)totalItems / PageSize);
groupList.CurrentPage = page;
groupList.Category = id;
groupList.CategoryName = category.Nazwa;
groupList = SetDetails(groupList);
viewModel.GroupList = groupList;
return(View(viewModel));
}
}
public ActionResult Save(Kategoria kategoria)
{
if (!ModelState.IsValid)
{
return(View("New", kategoria));
}
if (kategoria.Id == 0)
{
_context.Kategorias.Add(kategoria);
}
else
{
var kategoriaDb = _context.Kategorias.Single(c => c.Id == kategoria.Id);
kategoriaDb.Nazwa = kategoria.Nazwa;
}
_context.SaveChanges();
return(RedirectToAction("Index", "Kategorias"));
}
public Towary this[Kategoria kategoria]
{
get
{
return(this.CreateSubtable <Towary>(kategoria));
}
}
public Opis(Kategoria category)
{
Parameters = new Dictionary <string, string>();
switch (category)
{
case Kategoria.Dom:
this.Parameters.Add("Rodzaj", "");
this.Parameters.Add("Garaż", "");
this.Parameters.Add("Taras", "");
this.Parameters.Add("Ilość pięter", "");
this.Parameters.Add("Balkon", "");
break;
case Kategoria.Lokal:
this.Parameters.Add("Użytkowy", "");
this.Parameters.Add("Cel", "");
this.Parameters.Add("Asortyment", "");
break;
case Kategoria.Magazyn:
this.Parameters.Add("Sprzęt", "");
break;
case Kategoria.Mieszkanie:
this.Parameters.Add("Piętro", "");
this.Parameters.Add("Balkon", "");
break;
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Nazwa,NadKategoriaId")] Kategoria kategoria)
{
if (id != kategoria.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(kategoria);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!KategoriaExists(kategoria.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["NadKategoriaId"] = new SelectList(_context.Kategorie, "Id", "Nazwa", kategoria.NadKategoriaId);
return(View(kategoria));
}
public async Task <IActionResult> PutKategoria([FromRoute] int id, [FromBody] Kategoria kategoria)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != kategoria.IdKategoria)
{
return(BadRequest());
}
_context.Entry(kategoria).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!KategoriaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void TestValidateKategoriak(double kor, int pontszam, double tapasztalat, double nem, bool expectedResult)
{
var kateg = new Kategoria();
var actualResult = kateg.ValidateKategoriak(kor, pontszam, tapasztalat, nem);
Assert.AreEqual(expectedResult, actualResult);
}
public ActionResult Delete(int id)
{
Kategoria n = _db.Kategorie.Find(id);
_db.Kategorie.Remove(n);
_db.SaveChanges();
return(RedirectToAction("List"));
}
public ActionResult DeleteConfirmed(int id)
{
Kategoria kategoria = _context.Kategorie.Find(id);
_context.Kategorie.Remove(kategoria);
_context.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
public ActionResult DeleteConfirmed(int id)
{
Kategoria kategoria = db.Kategorias.Find(id);
db.Kategorias.Remove(kategoria);
db.SaveChanges();
return(RedirectToAction("Index"));
}
// PUT api/Kategoriaapi/5
public void Put(int id, [FromBody] string json)
{
Kategoria model = Json.Decode <Kategoria>(json);
Kategoria Kategoria = _db.Kategorie.Find(id);
Kategoria.Name = model.Name;
Kategoria.Description = model.Description;
this._db.SaveChanges();
}
public ActionResult Edit([Bind(Include = "Id,Nazwa")] Kategoria kategoria)
{
if (ModelState.IsValid)
{
db.Entry(kategoria).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(kategoria));
}
public ActionResult DodajKategorie([Bind(Include = "Nazwa")] Kategoria kategoria)
{
if (ModelState.IsValid)
{
db.Kategorie.Add(kategoria);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(kategoria));
}
public ActionResult Edit(Kategoria kategoria)
{
if (ModelState.IsValid)
{
_context.Entry(kategoria).State = EntityState.Modified;
_context.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
return(View(kategoria));
}
public async Task <Guid> Save(Kategoria kategoria)
{
var sqlInsert = "INSERT INTO dbo.Kategoria (Id, Name, PrzedsiebiorstwoId) VALUES (@Id, @Nazwa, @PrzedsiebiorstwoId)";
using (var conn = _dbConnectionSource.GetConnection())
{
await conn.ExecuteAsync(sqlInsert, kategoria);
return(kategoria.Id);
}
}
public ActionResult Create([Bind(Include = "Id,Nazwa,ParentId,MetaTytul,MetaOpis,MetaSlowa,Tresc")] Kategoria kategoria)
{
if (ModelState.IsValid)
{
db.Kategorie.Add(kategoria);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(kategoria));
}
public KategoriaViewModel(Kategoria model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
_model = model;
this.DelegateKategorieCommand = new DelegateCommand(HelloAction, HelloCanExecute);
}
public ActionResult Create([Bind(Include = "KategoriaId,NazwaKat,OpisKat")] Kategoria kategoria)
{
if (ModelState.IsValid)
{
db.Kategoriee.Add(kategoria);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(kategoria));
}
public async Task <IActionResult> Create([Bind("Id,Nazwa")] Kategoria kategoria)
{
if (ModelState.IsValid)
{
_context.Add(kategoria);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(kategoria));
}
public ActionResult Edit([Bind(Include = "IdKategorii,NazwaKategorii,OpisKategorii,IdIkony")] Kategoria kategoria)
{
if (ModelState.IsValid)
{
db.Entry(kategoria).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.IdIkony = new SelectList(db.Ikony, "IdIkony", "NazwaIkony", kategoria.IdIkony);
return(View(kategoria));
}
public ActionResult Edit([Bind(Include = "Id,Nazwa,NadKategoriaId")] Kategoria kategoria)
{
if (ModelState.IsValid)
{
db.Entry(kategoria).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.NadKategoriaId = new SelectList(db.Kategorias, "Id", "Nazwa", kategoria.NadKategoriaId);
return(View(kategoria));
}
public ActionResult CreatePartial([Bind(Include = "IdKategoria,Nazwa")] Kategoria kategoria)
{
if (ModelState.IsValid)
{
db.Kategorias.Add(kategoria);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(kategoria));
}
public ActionResult Create(Kategoria newKategoria)
{
if (!ModelState.IsValid)
{
return(View(newKategoria));
}
_context.Kategorie.Add(newKategoria);
_context.SaveChanges();
return(RedirectToAction("Create"));
}
public ActionResult Create([Bind(Include = "Id,Nazwa,NadKategoriaId")] Kategoria kategoria)
{
if (ModelState.IsValid)
{
db.Kategorias.Add(kategoria);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.NadKategoriaId = new SelectList(db.Kategorias, "Id", "Nazwa", kategoria.NadKategoriaId);
return(View(kategoria));
}
public async Task <IActionResult> Create([Bind("Id,Nazwa,NadKategoriaId")] Kategoria kategoria)
{
if (ModelState.IsValid)
{
_context.Add(kategoria);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["NadKategoriaId"] = new SelectList(_context.Kategorie, "Id", "Nazwa", kategoria.NadKategoriaId);
return(View(kategoria));
}
public ActionResult Create([Bind(Include = "IdKategorii,NazwaKategorii,OpisKategorii,IdIkony")] Kategoria kategoria)
{
if (ModelState.IsValid)
{
db.Kategorie.Add(kategoria);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.IdIkony = new SelectList(db.Ikony, "IdIkony", "NazwaIkony", kategoria.IdIkony);
return(View(kategoria));
}
public async Task <IActionResult> PostKategoria([FromBody] Kategoria kategoria)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.Kategoria.Add(kategoria);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetKategoria", new { id = kategoria.IdKategoria }, kategoria));
}
private void AddNewCategory()
{
Kategoria kt = new Kategoria();
var GetKategoriaId = db.Kategoria.Max(k => k.IdKategoria);
kt.IdKategoria = GetKategoriaId + 1;
kt.Nazwa = CategoryNameTextBox.Text;
kt.Cena = Int32.Parse(PriceTextBox.Text);
db.Kategoria.Add(kt);
db.SaveChanges();
}
public ActionResult Create(bool Catering, [Bind(Include = "Id,Nazwa,RodzicId")] Kategoria kategoria)
{
if (ModelState.IsValid)
{
_repo.Aktualizuj(kategoria);
_repo.SaveChanges();
return(View(new KategoriaView {
Kategoria = new Kategoria(), lista = _repo.PobierzKategorie(Catering).ToList()
}));
}
return(View(kategoria));
}
