source: PostgreSqlDotnetCore/Controllers/PetCaresController.cs@ 99d0ecc

using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.AspNetCore.Mvc.Rendering;
using PostgreSqlDotnetCore.Models;
using System;
using System.Net;

namespace PostgreSqlDotnetCore.Controllers
{
    public class PetCaresController : BaseController
    {
        public PetCaresController(UserManager<IdentityUser> userManager) : base(userManager)
        {
        }


        [HttpGet]
        /*  public async Task<ActionResult> Create()
          {

              var vetCenters = await db.VetCentersObj.ToListAsync();

              ViewBag.VetCenters = new SelectList(vetCenters, "id", "name");

              return View();
          }*/
        public async Task<ActionResult> Create()
        {


            UsersClass customerClass = await getCrrentUser();

            ViewBag.isAuthenticated = customerClass;
            var vetCenters = await db.VetCentersObj.ToListAsync();
            ViewBag.VetCenters = new SelectList(vetCenters, "id", "name");


            // check if the user is authenticated so we can take only his pets
            if (customerClass != null)
            {
                var queryPetsByUser = from st in db.PetsObj
                                      where st.usersid == customerClass.id
                                      select st;
                var userPets = await queryPetsByUser.ToListAsync<PetsClass>();
                ViewBag.Pets = new SelectList(userPets, "id", "name");

            }
            return View();
        }




        // GET: Customer
        public async Task<ActionResult> IndexAsync()
        {
            // check for permission
            bool isAuthenticated = User.Identity.IsAuthenticated;
            UsersClass customerClass = await getCrrentUser();
            // set if is authenticated
            ViewBag.isAuthenticated = customerClass;
            if (customerClass == null)
            {
                return RedirectToAction("AccessDenied", "Error");
            }
            // no access for standard user
            ViewBag.OnlyAdminManager = await checkAuthorizationSpecificRoleAsync(RoleConstants.Admin) ?? await checkAuthorizationSpecificRoleAsync(RoleConstants.Manager);

            if (customerClass.role_id == RoleConstants.Standard)
            {
                // query
                var query = from st in db.PetCaresObj
                            where st.usersid == customerClass.id
                            select st;

                var userPetCares =
                    await query.Include(n => n.PetsClass).ToListAsync<Pet_CaresClass>();

                return View(userPetCares);
            }
            else
            {
                return View(db.PetCaresObj.Include(n => n.PetsClass).ToList());
            }

        }

        // GET: Customer/Details/5
        public async Task<ActionResult> Details(int? id)
        {
            if (id == null)
            {
                return RedirectToAction("NotExist", "Error");
            }
            UsersClass customerClass = await getCrrentUser();
            ViewBag.isAuthenticated = customerClass;
            Pet_CaresClass peClass = db.PetCaresObj.Find(id);
            if (peClass == null)
            {
                return RedirectToAction("NotExist", "Error");
            }
            // no access for standard user
            ViewBag.OnlyAdminManager = await checkAuthorizationSpecificRoleAsync(RoleConstants.Admin) ?? await checkAuthorizationSpecificRoleAsync(RoleConstants.Manager);

            return View(peClass);
        }

        // GET: Customer/Create
        //public ActionResult Create()
        //{
        //    return View();
        //}

        /*public ActionResult Create()
        {
            
            return View();
        }*/

        // POST: Customer/Create
        // To protect from overposting attacks, enable the specific properties you want to bind to, for 
        // more details see https://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<ActionResult> CreateAsync([Bind(include: "id,title,description,dateending, start_date, usersid, vetcentersid, pet_id")] Pet_CaresClass peClass)
        {
            bool isAuthenticated = User.Identity.IsAuthenticated;
            if (!isAuthenticated)
            {
                return RedirectToAction("AccessDenied", "Error");
            }
            ModelState.Remove("PetsClass");
            ViewBag.isAuthenticated = new UsersClass();
            // no access for standard user
            ViewBag.OnlyAdminManager = await checkAuthorizationSpecificRoleAsync(RoleConstants.Admin) ?? await checkAuthorizationSpecificRoleAsync(RoleConstants.Manager);
            UsersClass customerClass =  null;
            if (ModelState.IsValid)
            {
                ViewBag.isAuthenticated = new UsersClass();
                peClass.dateending = DateTime.SpecifyKind(peClass.dateending, DateTimeKind.Utc);
                peClass.start_date = DateTime.SpecifyKind(peClass.start_date, DateTimeKind.Utc);
                var user = await _userManager.GetUserAsync(User);
                customerClass = db.CustomerObj.SingleOrDefault(x => x.email == user.Email);
                peClass.usersid = customerClass.id;
                db.PetCaresObj.Add(peClass);
                db.SaveChanges();
                return RedirectToAction("Index");
            }
            var vetCenters = await db.VetCentersObj.ToListAsync();
            ViewBag.VetCenters = new SelectList(vetCenters, "id", "name");

            if (customerClass != null)
            {
                var queryPetsByUser = from st in db.PetsObj
                                      where st.usersid == customerClass.id
                                      select st;
                var userPets = await queryPetsByUser.ToListAsync<PetsClass>();
                ViewBag.Pets = new SelectList(userPets, "id", "name");

            }

            return View(peClass);
        }



        // GET: Customer/Edit/5
        /*  public ActionResult Edit(int? id)
          {
              if (id == null)
              {
                  return RedirectToAction("NotExist", "Error");
              }
              Pet_CaresClass peClass = db.PetCaresObj.Find(id);
              if (peClass == null)
              {
                  return RedirectToAction("NotExist", "Error");
              }


              return View(peClass);
          }*/
        // GET: Customer/Edit/5
        /* public  ActionResult Edit(int? id)
         {
             if (id == null)
             {
                 return RedirectToAction("NotExist", "Error");
             }
             Pet_CaresClass peClass = db.PetCaresObj.Find(id);
             if (peClass == null)
             {
                 return RedirectToAction("NotExist", "Error");
             }


             return View(peClass);
         }*/
        public async Task<ActionResult> Edit(int? id)
        {
            if (id == null)
            {
                return RedirectToAction("NotExist", "Error");
            }

            Pet_CaresClass peClass = await db.PetCaresObj.FindAsync(id);
            if (peClass == null)
            {
                return RedirectToAction("NotExist", "Error");
            }

            var vetCenters = await db.VetCentersObj.ToListAsync();
            ViewBag.VetCenters = new SelectList(vetCenters, "id", "name", peClass.vetcentersid);
            // dodadeno na 22.08
            UsersClass customerClass = await getCrrentUser();
            // check if the user is authenticated so we can take only his pets
            if (customerClass != null)
            {
                var queryPetsByUser = from st in db.PetsObj
                                      where st.usersid == customerClass.id
                                      select st;
                var userPets = await queryPetsByUser.ToListAsync<PetsClass>();
                ViewBag.Pets = new SelectList(userPets, "id", "name");

            }
            ViewBag.isAuthenticated = customerClass;
            return View(peClass);
        }



        // POST: Customer/Edit/5
        // To protect from overposting attacks, enable the specific properties you want to bind to, for 
        // more details see https://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<ActionResult> EditAsync([Bind(include: "id,title,description,dateending, vetcentersid, pet_id")] Pet_CaresClass peClass)
        {
            bool isAuthenticated = User.Identity.IsAuthenticated;
            if (!isAuthenticated)
            {
                return RedirectToAction("AccessDenied", "Error");
            }

            ModelState.Remove("PetsClass");
            ViewBag.isAuthenticated = await getCrrentUser();
            // no access for standard user
            ViewBag.OnlyAdminManager = await checkAuthorizationSpecificRoleAsync(RoleConstants.Admin) ?? await checkAuthorizationSpecificRoleAsync(RoleConstants.Manager);

            if (ModelState.IsValid)
            {
                peClass.dateending = DateTime.SpecifyKind(peClass.dateending, DateTimeKind.Utc);
                var user = await _userManager.GetUserAsync(User);
                var customerClass = db.CustomerObj.SingleOrDefault(x => x.email == user.Email);
                peClass.usersid = customerClass.id;
                db.Entry(peClass).State = EntityState.Modified;
                db.SaveChanges();
                return RedirectToAction("Index");
            }
            return View(peClass);
        }




        // GET: Customer/Delete/5
        public async Task<ActionResult> Delete(int? id)
        {
            if (id == null)
            {
                return RedirectToAction("NotExist", "Error");
            }
            UsersClass customerClass = await getCrrentUser(); // Добијте ја тековната улога на корисникот
            ViewBag.isAuthenticated = customerClass;
            Pet_CaresClass peClass = db.PetCaresObj.Find(id);
            if (peClass == null)
            {
                return RedirectToAction("NotExist", "Error");
            }
            // no access for standard user
            ViewBag.OnlyAdminManager = await checkAuthorizationSpecificRoleAsync(RoleConstants.Admin) ?? await checkAuthorizationSpecificRoleAsync(RoleConstants.Manager);

            return View(peClass);
        }

        // POST: Customer/Delete/5
        /*  [HttpPost, ActionName("Delete")]
          [ValidateAntiForgeryToken]
          public ActionResult DeleteConfirmed(int id)
          {
              Pet_CaresClass peClass = db.PetCaresObj.Find(id);
              db.PetCaresObj.Remove(peClass);
              db.SaveChanges();
              return RedirectToAction("Index");
          }
        */

        [HttpPost, ActionName("Delete")]
        [ValidateAntiForgeryToken]
        public async Task<ActionResult> DeleteConfirmed(int id)
        {
            Pet_CaresClass peClass = await db.PetCaresObj.FindAsync(id);
            if (peClass == null)
            {
                return RedirectToAction("NotExist", "Error");
            }
            db.PetCaresObj.Remove(peClass);
            await db.SaveChangesAsync();
            return RedirectToAction("Index");
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                db.Dispose();
            }
            base.Dispose(disposing);
        }
    }
}